diff --git a/.zigversion b/.zigversion deleted file mode 100644 index 0548fb4..0000000 --- a/.zigversion +++ /dev/null @@ -1 +0,0 @@ -0.14.0 \ No newline at end of file diff --git a/README.md b/README.md index 3fbc3ea..383e8a7 100644 --- a/README.md +++ b/README.md @@ -41,9 +41,9 @@ Minimal is `0.15.1`. But you know try your version and believe. ## Bgfx version -- [BX](https://github.com/bkaradzic/bx//compare/d858859d1724fc037129318330f9c5ee5e008a08...master) -- [BImg](https://github.com/bkaradzic/bimg/compare/446b9eb11130821fd11607c2fc94aee80976e56a...master) -- [BGFX](https://github.com/bkaradzic/bgfx/compare/14e0aa5aff65a12df621fbc9466b42d41d01f013...master) +- [BX](https://github.com/bkaradzic/bx//compare/1dc8c4827087c5a6cde221b0978baa15533348fd...master) +- [BImg](https://github.com/bkaradzic/bimg/compare/bf10ffbb3df1f9f12ad7a9105e5e96e11a9c5a0c...master) +- [BGFX](https://github.com/bkaradzic/bgfx/compare/ee2072d02f59ffbd89ef79026474a5e5fa17f206...master) ## Getting started diff --git a/build.zig b/build.zig index e073ce5..c9b191a 100644 --- a/build.zig +++ b/build.zig @@ -37,16 +37,17 @@ pub fn build(b: *std.Build) !void { "-fno-exceptions", "-fno-rtti", "-ffast-math", - "-fomit-frame-pointer", + // "-fomit-frame-pointer", "-Wno-microsoft-enum-value", "-Wno-microsoft-const-init", "-Wno-deprecated-declarations", "-Wno-tautological-constant-compare", "-Wno-error=date-time", + "-Wno-error=unused-command-line-argument", }; const cxx_options = common_options ++ [_][]const u8{ - "-std=c++17", + "-std=c++20", }; const c_options = common_options ++ [_][]const u8{}; const mm_options = cxx_options ++ [_][]const u8{}; @@ -61,6 +62,7 @@ pub fn build(b: *std.Build) !void { .target = target, .optimize = optimize, }), + .use_llvm = true, }); const combine_bin_zig = b.addExecutable(.{ .name = "combine_bin_zig", @@ -69,6 +71,7 @@ pub fn build(b: *std.Build) !void { .target = target, .optimize = optimize, }), + .use_llvm = true, }); b.installArtifact(combine_bin_zig); @@ -83,6 +86,7 @@ pub fn build(b: *std.Build) !void { .target = target, .optimize = optimize, }), + .use_llvm = true, }); bx.addCSourceFiles(.{ .flags = &cxx_options, @@ -104,6 +108,7 @@ pub fn build(b: *std.Build) !void { .target = target, .optimize = optimize, }), + .use_llvm = true, }); bimg.addCSourceFiles(.{ .flags = &cxx_options, @@ -131,6 +136,7 @@ pub fn build(b: *std.Build) !void { .target = target, .optimize = optimize, }), + .use_llvm = true, }); b.installArtifact(bgfx); bxInclude(b, bgfx, target, optimize); @@ -220,6 +226,7 @@ pub fn build(b: *std.Build) !void { .target = target, .optimize = optimize, }), + .use_llvm = true, }); b.installArtifact(shaderc); @@ -427,6 +434,7 @@ pub fn build(b: *std.Build) !void { .target = target, .optimize = optimize, }), + .use_llvm = true, }); spirv_cross_lib.addIncludePath(b.path(spirv_cross_path ++ "include")); spirv_cross_lib.addCSourceFiles(.{ @@ -465,6 +473,7 @@ pub fn build(b: *std.Build) !void { .target = target, .optimize = optimize, }), + .use_llvm = true, }); glslang_lib.addIncludePath(b.path("libs/bgfx/3rdparty")); glslang_lib.addIncludePath(b.path(glslang_path)); @@ -500,7 +509,8 @@ pub fn build(b: *std.Build) !void { "-MP", "-Wall", "-Wextra", - "-ffast-math", + // https://github.com/bkaradzic/bgfx/commit/b4dbc129f3b69b0d6a9093f2d579b883396a839f + // "-ffast-math", "-fomit-frame-pointer", "-g", "-m64", @@ -519,7 +529,8 @@ pub fn build(b: *std.Build) !void { "-MP", "-Wall", "-Wextra", - "-ffast-math", + // https://github.com/bkaradzic/bgfx/commit/b4dbc129f3b69b0d6a9093f2d579b883396a839f + // "-ffast-math", "-fomit-frame-pointer", "-g", "-m64", @@ -535,6 +546,7 @@ pub fn build(b: *std.Build) !void { .target = target, .optimize = optimize, }), + .use_llvm = true, }); glsl_optimizer_lib.addIncludePath(b.path(glsl_optimizer_path ++ "include")); glsl_optimizer_lib.addIncludePath(b.path(glsl_optimizer_path ++ "src")); @@ -580,6 +592,13 @@ fn bxInclude(b: *std.Build, step: *std.Build.Step.Compile, target: std.Build.Res step.root_module.addCMacro("__STDC_FORMAT_MACROS", "1"); step.root_module.addCMacro("__STDC_CONSTANT_MACROS", "1"); + // FIXME: problem with compile with zig. + if (target.result.os.tag == .windows) { + step.root_module.addCMacro("BX_CONFIG_EXCEPTION_HANDLING_USE_WINDOWS_SEH", "0"); + } else if (target.result.os.tag == .linux) { + step.root_module.addCMacro("BX_CONFIG_EXCEPTION_HANDLING_USE_POSIX_SIGNALS", "0"); + } + step.root_module.addCMacro("BX_CONFIG_DEBUG", if (optimize == .Debug) "1" else "0"); switch (target.result.os.tag) { @@ -820,6 +839,7 @@ const spirv_opt_files = .{ spirv_opt_path ++ "source/opcode.cpp", spirv_opt_path ++ "source/operand.cpp", spirv_opt_path ++ "source/to_string.cpp", + spirv_opt_path ++ "source/opt/graph.cpp", spirv_opt_path ++ "source/opt/aggressive_dead_code_elim_pass.cpp", spirv_opt_path ++ "source/opt/amd_ext_to_khr.cpp", spirv_opt_path ++ "source/opt/analyze_live_input_pass.cpp", @@ -942,6 +962,7 @@ const spirv_opt_files = .{ spirv_opt_path ++ "source/opt/struct_packing_pass.cpp", spirv_opt_path ++ "source/opt/split_combined_image_sampler_pass.cpp", spirv_opt_path ++ "source/opt/resolve_binding_conflicts_pass.cpp", + spirv_opt_path ++ "source/opt/canonicalize_ids_pass.cpp", spirv_opt_path ++ "source/parsed_operand.cpp", spirv_opt_path ++ "source/print.cpp", spirv_opt_path ++ "source/reduce/change_operand_reduction_opportunity.cpp", @@ -1035,4 +1056,5 @@ const spirv_opt_files = .{ spirv_opt_path ++ "source/val/validate_tensor_layout.cpp", spirv_opt_path ++ "source/val/validate_tensor.cpp", spirv_opt_path ++ "source/val/validate_invalid_type.cpp", + spirv_opt_path ++ "source/val/validate_graph.cpp", }; diff --git a/build.zig.zon b/build.zig.zon index 3f24b5a..e745b8b 100644 --- a/build.zig.zon +++ b/build.zig.zon @@ -2,7 +2,7 @@ .name = .zbgfx, .fingerprint = 0xc48ed871c4086e4a, .version = "0.5.0", - .minimum_zig_version = "0.15.1", + .minimum_zig_version = "0.15.2", .paths = .{ "includes", "libs", diff --git a/examples/00-minimal/src/main.zig b/examples/00-minimal/src/main.zig index 08df975..225466f 100644 --- a/examples/00-minimal/src/main.zig +++ b/examples/00-minimal/src/main.zig @@ -190,7 +190,7 @@ pub fn main() anyerror!u8 { // // Reset and clear // - bgfx.reset(@intCast(framebufferSize[0]), @intCast(framebufferSize[1]), reset_flags, bgfx_init.resolution.format); + bgfx.reset(@intCast(framebufferSize[0]), @intCast(framebufferSize[1]), reset_flags, bgfx_init.resolution.formatColor); // Set view 0 clear state. bgfx.setViewClear(0, bgfx.ClearFlags_Color | bgfx.ClearFlags_Depth, 0x303030ff, 1.0, 0); @@ -262,7 +262,7 @@ pub fn main() anyerror!u8 { @intCast(size[0]), @intCast(size[1]), reset_flags, - bgfx_init.resolution.format, + bgfx_init.resolution.formatColor, ); old_size = size; old_flags = reset_flags; diff --git a/examples/01-zgui/src/main.zig b/examples/01-zgui/src/main.zig index 63b130e..d07ada6 100644 --- a/examples/01-zgui/src/main.zig +++ b/examples/01-zgui/src/main.zig @@ -100,7 +100,7 @@ pub fn main() anyerror!u8 { // // Reset and clear // - bgfx.reset(@intCast(framebufferSize[0]), @intCast(framebufferSize[1]), reset_flags, bgfx_init.resolution.format); + bgfx.reset(@intCast(framebufferSize[0]), @intCast(framebufferSize[1]), reset_flags, bgfx_init.resolution.formatColor); // Set view 0 clear state. bgfx.setViewClear(0, bgfx.ClearFlags_Color | bgfx.ClearFlags_Depth, 0x303030ff, 1.0, 0); @@ -184,7 +184,7 @@ pub fn main() anyerror!u8 { @intCast(size[0]), @intCast(size[1]), reset_flags, - bgfx_init.resolution.format, + bgfx_init.resolution.formatColor, ); old_size = size; old_flags = reset_flags; diff --git a/examples/02-runtime-shaderc/src/main.zig b/examples/02-runtime-shaderc/src/main.zig index 56fe081..50060f8 100644 --- a/examples/02-runtime-shaderc/src/main.zig +++ b/examples/02-runtime-shaderc/src/main.zig @@ -241,7 +241,7 @@ pub fn main() anyerror!u8 { // // Reset and clear // - bgfx.reset(@intCast(framebufferSize[0]), @intCast(framebufferSize[1]), reset_flags, bgfx_init.resolution.format); + bgfx.reset(@intCast(framebufferSize[0]), @intCast(framebufferSize[1]), reset_flags, bgfx_init.resolution.formatColor); // Set view 0 clear state. bgfx.setViewClear(0, bgfx.ClearFlags_Color | bgfx.ClearFlags_Depth, 0x303030ff, 1.0, 0); @@ -323,7 +323,7 @@ pub fn main() anyerror!u8 { @intCast(size[0]), @intCast(size[1]), reset_flags, - bgfx_init.resolution.format, + bgfx_init.resolution.formatColor, ); old_size = size; old_flags = reset_flags; diff --git a/examples/03-debugdraw/src/main.zig b/examples/03-debugdraw/src/main.zig index e98d199..9f5bd51 100644 --- a/examples/03-debugdraw/src/main.zig +++ b/examples/03-debugdraw/src/main.zig @@ -96,7 +96,7 @@ pub fn main() anyerror!u8 { // // Reset and clear // - bgfx.reset(@intCast(framebufferSize[0]), @intCast(framebufferSize[1]), reset_flags, bgfx_init.resolution.format); + bgfx.reset(@intCast(framebufferSize[0]), @intCast(framebufferSize[1]), reset_flags, bgfx_init.resolution.formatColor); // Set view 0 clear state. bgfx.setViewClear(0, bgfx.ClearFlags_Color | bgfx.ClearFlags_Depth, 0x303030ff, 1.0, 0); @@ -178,7 +178,7 @@ pub fn main() anyerror!u8 { @intCast(size[0]), @intCast(size[1]), reset_flags, - bgfx_init.resolution.format, + bgfx_init.resolution.formatColor, ); old_size = size; old_flags = reset_flags; diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/PIXEvents.h b/libs/bgfx/3rdparty/directx-headers/include/directx/PIXEvents.h new file mode 100644 index 0000000..6078fbf --- /dev/null +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/PIXEvents.h @@ -0,0 +1,1569 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +// Don't include this file directly - use pix3.h + +#pragma once + +#ifndef _PixEvents_H_ +#define _PixEvents_H_ + +#ifndef _PIX3_H_ +# error Do not include this file directly - use pix3.h +#endif + +#include "PIXEventsCommon.h" + + // Xbox does not support CPU events for retail scenarios +#if defined(USE_PIX) || !defined(PIX_XBOX) +#define PIX_CONTEXT_EMIT_CPU_EVENTS +#endif + +namespace PIXEventsDetail +{ + inline void PIXCopyEventArguments(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit) + { + // nothing + UNREFERENCED_PARAMETER(destination); + UNREFERENCED_PARAMETER(limit); + } + + template + void PIXCopyEventArguments(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, ARG const& arg, ARGS const&... args) + { + PIXCopyEventArgument(destination, limit, arg); + PIXCopyEventArguments(destination, limit, args...); + } + + template + void PIXCopyStringArguments(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, ARG const& arg, ARGS const&... args) + { + PIXCopyStringArgument(destination, limit, arg); + PIXCopyEventArguments(destination, limit, args...); + } + + template + void PIXCopyStringArgumentsWithContext(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, void* context, ARG const& arg, ARGS const&... args) + { +#ifdef PIX_XBOX + UNREFERENCED_PARAMETER(context); + PIXCopyStringArgument(destination, limit, arg); + PIXCopyEventArguments(destination, limit, args...); +#else + PIXCopyEventArgument(destination, limit, context); + PIXCopyStringArgument(destination, limit, arg); + PIXCopyEventArguments(destination, limit, args...); +#endif + } + + inline UINT8 PIXGetEventSize(const UINT64* end, const UINT64* start) + { + const UINT64 actualEventSize = end - start; + + return static_cast(actualEventSize > PIXEventsSizeMax ? PIXEventsSizeMax : actualEventSize); + } + + template + inline UINT8 PIXEncodeStringIsAnsi() + { + return PIX_EVENT_METADATA_NONE; + } + + template<> + inline UINT8 PIXEncodeStringIsAnsi() + { + return PIX_EVENT_METADATA_STRING_IS_ANSI; + } + + template<> + inline UINT8 PIXEncodeStringIsAnsi() + { + return PIX_EVENT_METADATA_STRING_IS_ANSI; + } + + template + __declspec(noinline) void PIXBeginEventAllocate(PIXEventsThreadInfo* threadInfo, UINT64 color, STR formatString, ARGS... args) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, false); + if (!time) + return; + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + if (destination >= limit) + return; + + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64* eventDestination = destination++; + *destination++ = color; + + PIXCopyStringArguments(destination, limit, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_HAS_COLOR | + PIXEncodeStringIsAnsi(); + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + + template + void PIXBeginEvent(UINT64 color, STR formatString, ARGS... args) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* limit = threadInfo->biasedLimit; + if (limit != nullptr) + { + UINT64* destination = threadInfo->destination; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + UINT64* eventDestination = destination++; + *destination++ = color; + + PIXCopyStringArguments(destination, limit, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_HAS_COLOR | + PIXEncodeStringIsAnsi(); + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + else + { + PIXBeginEventAllocate(threadInfo, color, formatString, args...); + } + } + } + + template + __declspec(noinline) void PIXBeginEventAllocate(PIXEventsThreadInfo* threadInfo, UINT8 color, STR formatString, ARGS... args) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, false); + if (!time) + return; + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + if (destination >= limit) + return; + + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64* eventDestination = destination++; + + PIXCopyStringArguments(destination, limit, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIXEncodeStringIsAnsi() | + PIXEncodeIndexColor(color); + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + + template + void PIXBeginEvent(UINT8 color, STR formatString, ARGS... args) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* limit = threadInfo->biasedLimit; + if (limit != nullptr) + { + UINT64* destination = threadInfo->destination; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + UINT64* eventDestination = destination++; + + PIXCopyStringArguments(destination, limit, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIXEncodeStringIsAnsi() | + PIXEncodeIndexColor(color); + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + else + { + PIXBeginEventAllocate(threadInfo, color, formatString, args...); + } + } + } + + template + __declspec(noinline) void PIXSetMarkerAllocate(PIXEventsThreadInfo* threadInfo, UINT64 color, STR formatString, ARGS... args) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, false); + if (!time) + return; + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination >= limit) + return; + + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64* eventDestination = destination++; + *destination++ = color; + + PIXCopyStringArguments(destination, limit, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIXEncodeStringIsAnsi() | + PIX_EVENT_METADATA_HAS_COLOR; + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + + template + void PIXSetMarker(UINT64 color, STR formatString, ARGS... args) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* limit = threadInfo->biasedLimit; + if (limit != nullptr) + { + UINT64* destination = threadInfo->destination; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + UINT64* eventDestination = destination++; + *destination++ = color; + + PIXCopyStringArguments(destination, limit, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIXEncodeStringIsAnsi() | + PIX_EVENT_METADATA_HAS_COLOR; + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + else + { + PIXSetMarkerAllocate(threadInfo, color, formatString, args...); + } + } + } + + template + __declspec(noinline) void PIXSetMarkerAllocate(PIXEventsThreadInfo* threadInfo, UINT8 color, STR formatString, ARGS... args) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, false); + if (!time) + return; + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination >= limit) + return; + + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64* eventDestination = destination++; + + PIXCopyStringArguments(destination, limit, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIXEncodeStringIsAnsi() | + PIXEncodeIndexColor(color); + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + + template + void PIXSetMarker(UINT8 color, STR formatString, ARGS... args) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* limit = threadInfo->biasedLimit; + if (limit != nullptr) + { + UINT64* destination = threadInfo->destination; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + UINT64* eventDestination = destination++; + + PIXCopyStringArguments(destination, limit, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIXEncodeStringIsAnsi() | + PIXEncodeIndexColor(color); + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + else + { + PIXSetMarkerAllocate(threadInfo, color, formatString, args...); + } + } + } + + template + __declspec(noinline) void PIXBeginEventOnContextCpuAllocate(UINT64*& eventDestination, UINT8& eventSize, PIXEventsThreadInfo* threadInfo, void* context, UINT64 color, STR formatString, ARGS... args) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, false); + if (!time) + { + eventDestination = nullptr; + return; + } + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination >= limit) + { + eventDestination = nullptr; + return; + } + + limit += PIXEventsSafeFastCopySpaceQwords; + eventDestination = destination++; + *destination++ = color; + + PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_ON_CONTEXT | + PIXEncodeStringIsAnsi() | + PIX_EVENT_METADATA_HAS_COLOR; + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + + template + void PIXBeginEventOnContextCpu(UINT64*& eventDestination, UINT8& eventSize, void* context, UINT64 color, STR formatString, ARGS... args) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* limit = threadInfo->biasedLimit; + if (limit == nullptr) + { + eventDestination = nullptr; + return; + } + + UINT64* destination = threadInfo->destination; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + eventDestination = destination++; + *destination++ = color; + + PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_ON_CONTEXT | + PIXEncodeStringIsAnsi() | + PIX_EVENT_METADATA_HAS_COLOR; + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + else + { + PIXBeginEventOnContextCpuAllocate(eventDestination, eventSize, threadInfo, context, color, formatString, args...); + } + } + + template + void PIXBeginEvent(CONTEXT* context, UINT64 color, STR formatString, ARGS... args) + { + UINT64* destination = nullptr; + UINT8 eventSize = 0u; + +#ifdef PIX_CONTEXT_EMIT_CPU_EVENTS + PIXBeginEventOnContextCpu(destination, eventSize, context, color, formatString, args...); +#endif + +#ifdef PIX_USE_GPU_MARKERS_V2 + if (destination != nullptr) + { + PIXInsertTimingMarkerOnContextForBeginEvent(context, PIXEvent_BeginEvent, static_cast(destination), eventSize * sizeof(UINT64)); + } + else +#endif + { + UINT64 buffer[PIXEventsGraphicsRecordSpaceQwords]; + +#ifdef PIX_USE_GPU_MARKERS_V2 + destination = buffer; + UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords; + + UINT64* eventDestination = destination++; + *destination++ = color; + + PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...); + *destination = 0ull; + + eventSize = static_cast(destination - buffer); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_ON_CONTEXT | + PIXEncodeStringIsAnsi() | + PIX_EVENT_METADATA_HAS_COLOR; + *eventDestination = PIXEncodeEventInfo(0, PIXEvent_BeginEvent, eventSize, eventMetadata); + PIXInsertGPUMarkerOnContextForBeginEvent(context, PIXEvent_BeginEvent, static_cast(buffer), static_cast(reinterpret_cast(destination) - reinterpret_cast(buffer))); +#else + destination = PixEventsLegacy::EncodeBeginEventForContext(buffer, color, formatString, args...); + PIXBeginGPUEventOnContext(context, static_cast(buffer), static_cast(reinterpret_cast(destination) - reinterpret_cast(buffer))); +#endif + } + } + + template + __declspec(noinline) void PIXBeginEventOnContextCpuAllocate(UINT64*& eventDestination, UINT8& eventSize, PIXEventsThreadInfo* threadInfo, void* context, UINT8 color, STR formatString, ARGS... args) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, false); + if (!time) + { + eventDestination = nullptr; + return; + } + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination >= limit) + { + eventDestination = nullptr; + return; + } + + limit += PIXEventsSafeFastCopySpaceQwords; + eventDestination = destination++; + + PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_ON_CONTEXT | + PIXEncodeStringIsAnsi() | + PIXEncodeIndexColor(color); + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + + template + void PIXBeginEventOnContextCpu(UINT64*& eventDestination, UINT8& eventSize, void* context, UINT8 color, STR formatString, ARGS... args) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* limit = threadInfo->biasedLimit; + if (limit == nullptr) + { + eventDestination = nullptr; + return; + } + + UINT64* destination = threadInfo->destination; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + eventDestination = destination++; + + PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_ON_CONTEXT | + PIXEncodeStringIsAnsi() | + PIXEncodeIndexColor(color); + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_BeginEvent, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + else + { + PIXBeginEventOnContextCpuAllocate(eventDestination, eventSize, threadInfo, context, color, formatString, args...); + } + } + + template + void PIXBeginEvent(CONTEXT* context, UINT8 color, STR formatString, ARGS... args) + { + UINT64* destination = nullptr; + UINT8 eventSize = 0u; + +#ifdef PIX_CONTEXT_EMIT_CPU_EVENTS + PIXBeginEventOnContextCpu(destination, eventSize, context, color, formatString, args...); +#endif + +#ifdef PIX_USE_GPU_MARKERS_V2 + if (destination != nullptr) + { + PIXInsertTimingMarkerOnContextForBeginEvent(context, PIXEvent_BeginEvent, static_cast(destination), eventSize * sizeof(UINT64)); + } + else +#endif + { + UINT64 buffer[PIXEventsGraphicsRecordSpaceQwords]; + +#ifdef PIX_USE_GPU_MARKERS_V2 + destination = buffer; + UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords; + + UINT64* eventDestination = destination++; + + PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...); + *destination = 0ull; + + eventSize = static_cast(destination - buffer); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_ON_CONTEXT | + PIXEncodeStringIsAnsi() | + PIXEncodeIndexColor(color); + *eventDestination = PIXEncodeEventInfo(0, PIXEvent_BeginEvent, eventSize, eventMetadata); + + PIXInsertGPUMarkerOnContextForBeginEvent(context, PIXEvent_BeginEvent, static_cast(buffer), static_cast(reinterpret_cast(destination) - reinterpret_cast(buffer))); +#else + destination = PixEventsLegacy::EncodeBeginEventForContext(buffer, color, formatString, args...); + PIXBeginGPUEventOnContext(context, static_cast(buffer), static_cast(reinterpret_cast(destination) - reinterpret_cast(buffer))); +#endif + } + } + + template + __declspec(noinline) void PIXSetMarkerOnContextCpuAllocate(UINT64*& eventDestination, UINT8& eventSize, PIXEventsThreadInfo* threadInfo, void* context, UINT64 color, STR formatString, ARGS... args) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, false); + if (!time) + { + eventDestination = nullptr; + return; + } + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination >= limit) + { + eventDestination = nullptr; + return; + } + + limit += PIXEventsSafeFastCopySpaceQwords; + eventDestination = destination++; + *destination++ = color; + + PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_ON_CONTEXT | + PIXEncodeStringIsAnsi() | + PIX_EVENT_METADATA_HAS_COLOR; + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + + template + void PIXSetMarkerOnContextCpu(UINT64*& eventDestination, UINT8& eventSize, void* context, UINT64 color, STR formatString, ARGS... args) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* limit = threadInfo->biasedLimit; + if (limit == nullptr) + { + eventDestination = nullptr; + return; + } + + UINT64* destination = threadInfo->destination; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + eventDestination = destination++; + *destination++ = color; + + PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_ON_CONTEXT | + PIXEncodeStringIsAnsi() | + PIX_EVENT_METADATA_HAS_COLOR; + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + else + { + PIXSetMarkerOnContextCpuAllocate(eventDestination, eventSize, threadInfo, context, color, formatString, args...); + } + } + + template + void PIXSetMarker(CONTEXT* context, UINT64 color, STR formatString, ARGS... args) + { + UINT64* destination = nullptr; + UINT8 eventSize = 0u; + +#ifdef PIX_CONTEXT_EMIT_CPU_EVENTS + PIXSetMarkerOnContextCpu(destination, eventSize, context, color, formatString, args...); +#endif + +#ifdef PIX_USE_GPU_MARKERS_V2 + if (destination != nullptr) + { + PIXInsertTimingMarkerOnContextForSetMarker(context, PIXEvent_SetMarker, static_cast(destination), eventSize * sizeof(UINT64)); + } + else +#endif + { + UINT64 buffer[PIXEventsGraphicsRecordSpaceQwords]; + +#ifdef PIX_USE_GPU_MARKERS_V2 + destination = buffer; + UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords; + + UINT64* eventDestination = destination++; + *destination++ = color; + + PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...); + *destination = 0ull; + + eventSize = static_cast(destination - buffer); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_ON_CONTEXT | + PIXEncodeStringIsAnsi() | + PIX_EVENT_METADATA_HAS_COLOR; + *eventDestination = PIXEncodeEventInfo(0, PIXEvent_SetMarker, eventSize, eventMetadata); + PIXInsertGPUMarkerOnContextForSetMarker(context, PIXEvent_SetMarker, static_cast(buffer), static_cast(reinterpret_cast(destination) - reinterpret_cast(buffer))); +#else + destination = PixEventsLegacy::EncodeSetMarkerForContext(buffer, color, formatString, args...); + PIXSetGPUMarkerOnContext(context, static_cast(buffer), static_cast(reinterpret_cast(destination) - reinterpret_cast(buffer))); +#endif + } + } + + template + __declspec(noinline) void PIXSetMarkerOnContextCpuAllocate(UINT64*& eventDestination, UINT8& eventSize, PIXEventsThreadInfo* threadInfo, void* context, UINT8 color, STR formatString, ARGS... args) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, false); + if (!time) + { + eventDestination = nullptr; + return; + } + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination >= limit) + { + eventDestination = nullptr; + return; + } + + limit += PIXEventsSafeFastCopySpaceQwords; + eventDestination = destination++; + + PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_ON_CONTEXT | + PIXEncodeStringIsAnsi() | + PIXEncodeIndexColor(color); + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + + template + void PIXSetMarkerOnContextCpu(UINT64*& eventDestination, UINT8& eventSize, void* context, UINT8 color, STR formatString, ARGS... args) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* limit = threadInfo->biasedLimit; + if (limit == nullptr) + { + eventDestination = nullptr; + return; + } + + UINT64* destination = threadInfo->destination; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + eventDestination = destination++; + + PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...); + *destination = PIXEventsBlockEndMarker; + + eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_ON_CONTEXT | + PIXEncodeStringIsAnsi() | + PIXEncodeIndexColor(color); + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_SetMarker, eventSize, eventMetadata); + + threadInfo->destination = destination; + } + else + { + PIXSetMarkerOnContextCpuAllocate(eventDestination, eventSize, threadInfo, context, color, formatString, args...); + } + } + + template + void PIXSetMarker(CONTEXT* context, UINT8 color, STR formatString, ARGS... args) + { + UINT64* destination = nullptr; + UINT8 eventSize = 0u; + +#ifdef PIX_CONTEXT_EMIT_CPU_EVENTS + PIXSetMarkerOnContextCpu(destination, eventSize, context, color, formatString, args...); +#endif + +#ifdef PIX_USE_GPU_MARKERS_V2 + if (destination != nullptr) + { + PIXInsertTimingMarkerOnContextForSetMarker(context, PIXEvent_SetMarker, static_cast(destination), eventSize * sizeof(UINT64)); + } + else +#endif + { + UINT64 buffer[PIXEventsGraphicsRecordSpaceQwords]; + +#ifdef PIX_USE_GPU_MARKERS_V2 + destination = buffer; + UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords; + + UINT64* eventDestination = destination++; + + PIXCopyStringArgumentsWithContext(destination, limit, context, formatString, args...); + *destination = 0ull; + + eventSize = static_cast(destination - buffer); + const UINT8 eventMetadata = + PIX_EVENT_METADATA_ON_CONTEXT | + PIXEncodeStringIsAnsi() | + PIXEncodeIndexColor(color); + *eventDestination = PIXEncodeEventInfo(0, PIXEvent_SetMarker, eventSize, eventMetadata); + PIXInsertGPUMarkerOnContextForSetMarker(context, PIXEvent_SetMarker, static_cast(buffer), static_cast(reinterpret_cast(destination) - reinterpret_cast(buffer))); +#else + destination = PixEventsLegacy::EncodeSetMarkerForContext(buffer, color, formatString, args...); + PIXSetGPUMarkerOnContext(context, static_cast(buffer), static_cast(reinterpret_cast(destination) - reinterpret_cast(buffer))); +#endif + } + } + + __declspec(noinline) inline void PIXEndEventAllocate(PIXEventsThreadInfo* threadInfo) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, true); + if (!time) + return; + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination >= limit) + return; + + limit += PIXEventsSafeFastCopySpaceQwords; + const UINT8 eventSize = 1; + const UINT8 eventMetadata = PIX_EVENT_METADATA_NONE; + *destination++ = PIXEncodeEventInfo(time, PIXEvent_EndEvent, eventSize, eventMetadata); + *destination = PIXEventsBlockEndMarker; + + threadInfo->destination = destination; + } + + inline void PIXEndEvent() + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* limit = threadInfo->biasedLimit; + if (limit != nullptr) + { + UINT64* destination = threadInfo->destination; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + const UINT8 eventSize = 1; + const UINT8 eventMetadata = PIX_EVENT_METADATA_NONE; + *destination++ = PIXEncodeEventInfo(time, PIXEvent_EndEvent, eventSize, eventMetadata); + *destination = PIXEventsBlockEndMarker; + + threadInfo->destination = destination; + } + else + { + PIXEndEventAllocate(threadInfo); + } + } + } + + __declspec(noinline) inline UINT64* PIXEndEventOnContextCpuAllocate(PIXEventsThreadInfo* threadInfo, void* context) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, true); + if (!time) + return nullptr; + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination >= limit) + return nullptr; + + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64* eventDestination = destination++; +#ifdef PIX_XBOX + UNREFERENCED_PARAMETER(context); +#else + PIXCopyEventArgument(destination, limit, context); +#endif + * destination = PIXEventsBlockEndMarker; + + const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = PIX_EVENT_METADATA_ON_CONTEXT; + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_EndEvent, eventSize, eventMetadata); + + threadInfo->destination = destination; + + return eventDestination; + } + + inline UINT64* PIXEndEventOnContextCpu(void* context) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* limit = threadInfo->biasedLimit; + if (limit != nullptr) + { + UINT64* destination = threadInfo->destination; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + UINT64* eventDestination = destination++; +#ifndef PIX_XBOX + PIXCopyEventArgument(destination, limit, context); +#endif + * destination = PIXEventsBlockEndMarker; + + const UINT8 eventSize = PIXGetEventSize(destination, threadInfo->destination); + const UINT8 eventMetadata = PIX_EVENT_METADATA_ON_CONTEXT; + *eventDestination = PIXEncodeEventInfo(time, PIXEvent_EndEvent, eventSize, eventMetadata); + + threadInfo->destination = destination; + + return eventDestination; + } + else + { + return PIXEndEventOnContextCpuAllocate(threadInfo, context); + } + } + + return nullptr; + } + + template + void PIXEndEvent(CONTEXT* context) + { + UINT64* destination = nullptr; +#ifdef PIX_CONTEXT_EMIT_CPU_EVENTS + destination = PIXEndEventOnContextCpu(context); +#endif + +#ifdef PIX_USE_GPU_MARKERS_V2 + if (destination != nullptr) + { + PIXInsertTimingMarkerOnContextForEndEvent(context, PIXEvent_EndEvent); + } + else +#endif + { +#ifdef PIX_USE_GPU_MARKERS_V2 + UINT64 buffer[PIXEventsGraphicsRecordSpaceQwords]; + destination = buffer; + + UINT64* eventDestination = destination++; + + const UINT8 eventSize = static_cast(destination - buffer); + const UINT8 eventMetadata = PIX_EVENT_METADATA_NONE; + *eventDestination = PIXEncodeEventInfo(0, PIXEvent_EndEvent, eventSize, eventMetadata); + PIXInsertGPUMarkerOnContextForEndEvent(context, PIXEvent_EndEvent, static_cast(buffer), static_cast(reinterpret_cast(destination) - reinterpret_cast(buffer))); +#else + PIXEndGPUEventOnContext(context); +#endif + } + } +} + +#if defined(USE_PIX) + +template +void PIXBeginEvent(UINT64 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(color, formatString, args...); +} + +template +void PIXBeginEvent(UINT64 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(color, formatString, args...); +} + +template +void PIXBeginEvent(UINT32 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(static_cast(color), formatString, args...); +} + +template +void PIXBeginEvent(UINT32 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(static_cast(color), formatString, args...); +} + +template +void PIXBeginEvent(INT32 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(static_cast(color), formatString, args...); +} + +template +void PIXBeginEvent(INT32 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(static_cast(color), formatString, args...); +} + +template +void PIXBeginEvent(DWORD color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(static_cast(color), formatString, args...); +} + +template +void PIXBeginEvent(DWORD color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(static_cast(color), formatString, args...); +} + +template +void PIXBeginEvent(UINT8 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(color, formatString, args...); +} + +template +void PIXBeginEvent(UINT8 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(color, formatString, args...); +} + +template +void PIXSetMarker(UINT64 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(color, formatString, args...); +} + +template +void PIXSetMarker(UINT64 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(color, formatString, args...); +} + +template +void PIXSetMarker(UINT32 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(static_cast(color), formatString, args...); +} + +template +void PIXSetMarker(UINT32 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(static_cast(color), formatString, args...); +} + +template +void PIXSetMarker(INT32 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(static_cast(color), formatString, args...); +} + +template +void PIXSetMarker(INT32 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(static_cast(color), formatString, args...); +} + +template +void PIXSetMarker(DWORD color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(static_cast(color), formatString, args...); +} + +template +void PIXSetMarker(DWORD color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(static_cast(color), formatString, args...); +} + +template +void PIXSetMarker(UINT8 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(color, formatString, args...); +} + +template +void PIXSetMarker(UINT8 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(color, formatString, args...); +} + +template +void PIXBeginEvent(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...); +} + +template +void PIXBeginEvent(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...); +} + +template +void PIXBeginEvent(CONTEXT* context, UINT32 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, static_cast(color), formatString, args...); +} + +template +void PIXBeginEvent(CONTEXT* context, UINT32 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, static_cast(color), formatString, args...); +} + +template +void PIXBeginEvent(CONTEXT* context, INT32 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, static_cast(color), formatString, args...); +} + +template +void PIXBeginEvent(CONTEXT* context, INT32 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, static_cast(color), formatString, args...); +} + +template +void PIXBeginEvent(CONTEXT* context, DWORD color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, static_cast(color), formatString, args...); +} + +template +void PIXBeginEvent(CONTEXT* context, DWORD color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, static_cast(color), formatString, args...); +} + +template +void PIXBeginEvent(CONTEXT* context, UINT8 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...); +} + +template +void PIXBeginEvent(CONTEXT* context, UINT8 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...); +} + +template +void PIXSetMarker(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, color, formatString, args...); +} + +template +void PIXSetMarker(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, color, formatString, args...); +} + +template +void PIXSetMarker(CONTEXT* context, UINT32 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, static_cast(color), formatString, args...); +} + +template +void PIXSetMarker(CONTEXT* context, UINT32 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, static_cast(color), formatString, args...); +} + +template +void PIXSetMarker(CONTEXT* context, INT32 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, static_cast(color), formatString, args...); +} + +template +void PIXSetMarker(CONTEXT* context, INT32 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, static_cast(color), formatString, args...); +} + +template +void PIXSetMarker(CONTEXT* context, DWORD color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, static_cast(color), formatString, args...); +} + +template +void PIXSetMarker(CONTEXT* context, DWORD color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, static_cast(color), formatString, args...); +} + +template +void PIXSetMarker(CONTEXT* context, UINT8 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, color, formatString, args...); +} + +template +void PIXSetMarker(CONTEXT* context, UINT8 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, color, formatString, args...); +} + +inline void PIXEndEvent() +{ + PIXEventsDetail::PIXEndEvent(); +} + +template +void PIXEndEvent(CONTEXT* context) +{ + PIXEventsDetail::PIXEndEvent(context); +} + +#else // USE_PIX_RETAIL + +inline void PIXBeginEvent(UINT64, _In_ PCSTR, ...) {} +inline void PIXBeginEvent(UINT64, _In_ PCWSTR, ...) {} +inline void PIXBeginEvent(void*, UINT64, _In_ PCSTR, ...) {} +inline void PIXBeginEvent(void*, UINT64, _In_ PCWSTR, ...) {} +inline void PIXEndEvent() {} +inline void PIXEndEvent(void*) {} +inline void PIXSetMarker(UINT64, _In_ PCSTR, ...) {} +inline void PIXSetMarker(UINT64, _In_ PCWSTR, ...) {} +inline void PIXSetMarker(void*, UINT64, _In_ PCSTR, ...) {} +inline void PIXSetMarker(void*, UINT64, _In_ PCWSTR, ...) {} + +#endif // USE_PIX + +template +void PIXBeginRetailEvent(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...); +} + +template +void PIXBeginRetailEvent(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...); +} + +template +void PIXBeginRetailEvent(CONTEXT* context, UINT32 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, static_cast(color), formatString, args...); +} + +template +void PIXBeginRetailEvent(CONTEXT* context, UINT32 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, static_cast(color), formatString, args...); +} + +template +void PIXBeginRetailEvent(CONTEXT* context, INT32 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, static_cast(color), formatString, args...); +} + +template +void PIXBeginRetailEvent(CONTEXT* context, INT32 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, static_cast(color), formatString, args...); +} + +template +void PIXBeginRetailEvent(CONTEXT* context, DWORD color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, static_cast(color), formatString, args...); +} + +template +void PIXBeginRetailEvent(CONTEXT* context, DWORD color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, static_cast(color), formatString, args...); +} + +template +void PIXBeginRetailEvent(CONTEXT* context, UINT8 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...); +} + +template +void PIXBeginRetailEvent(CONTEXT* context, UINT8 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...); +} + +template +void PIXSetRetailMarker(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, color, formatString, args...); +} + +template +void PIXSetRetailMarker(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, color, formatString, args...); +} + +template +void PIXSetRetailMarker(CONTEXT* context, UINT32 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, static_cast(color), formatString, args...); +} + +template +void PIXSetRetailMarker(CONTEXT* context, UINT32 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, static_cast(color), formatString, args...); +} + +template +void PIXSetRetailMarker(CONTEXT* context, INT32 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, static_cast(color), formatString, args...); +} + +template +void PIXSetRetailMarker(CONTEXT* context, INT32 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, static_cast(color), formatString, args...); +} + +template +void PIXSetRetailMarker(CONTEXT* context, DWORD color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, static_cast(color), formatString, args...); +} + +template +void PIXSetRetailMarker(CONTEXT* context, DWORD color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, static_cast(color), formatString, args...); +} + +template +void PIXSetRetailMarker(CONTEXT* context, UINT8 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, color, formatString, args...); +} + +template +void PIXSetRetailMarker(CONTEXT* context, UINT8 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, color, formatString, args...); +} + +template +void PIXEndRetailEvent(CONTEXT* context) +{ + PIXEventsDetail::PIXEndEvent(context); +} + +template +class PIXScopedEventObject +{ + CONTEXT* m_context; + +public: + template + PIXScopedEventObject(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginEvent(m_context, color, formatString, args...); + } + + template + PIXScopedEventObject(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginEvent(m_context, color, formatString, args...); + } + + template + PIXScopedEventObject(CONTEXT* context, UINT32 color, PCWSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginEvent(m_context, color, formatString, args...); + } + + template + PIXScopedEventObject(CONTEXT* context, UINT32 color, PCSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginEvent(m_context, color, formatString, args...); + } + + template + PIXScopedEventObject(CONTEXT* context, INT32 color, PCWSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginEvent(m_context, color, formatString, args...); + } + + template + PIXScopedEventObject(CONTEXT* context, INT32 color, PCSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginEvent(m_context, color, formatString, args...); + } + + template + PIXScopedEventObject(CONTEXT* context, DWORD color, PCWSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginEvent(m_context, color, formatString, args...); + } + + template + PIXScopedEventObject(CONTEXT* context, DWORD color, PCSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginEvent(m_context, color, formatString, args...); + } + + template + PIXScopedEventObject(CONTEXT* context, UINT8 color, PCWSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginEvent(m_context, color, formatString, args...); + } + + template + PIXScopedEventObject(CONTEXT* context, UINT8 color, PCSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginEvent(m_context, color, formatString, args...); + } + + ~PIXScopedEventObject() + { + PIXEndEvent(m_context); + } +}; + +template +class PIXScopedRetailEventObject +{ + CONTEXT* m_context; + +public: + template + PIXScopedRetailEventObject(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginRetailEvent(m_context, color, formatString, args...); + } + + template + PIXScopedRetailEventObject(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginRetailEvent(m_context, color, formatString, args...); + } + + template + PIXScopedRetailEventObject(CONTEXT* context, UINT32 color, PCWSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginRetailEvent(m_context, color, formatString, args...); + } + + template + PIXScopedRetailEventObject(CONTEXT* context, UINT32 color, PCSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginRetailEvent(m_context, color, formatString, args...); + } + + template + PIXScopedRetailEventObject(CONTEXT* context, INT32 color, PCWSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginRetailEvent(m_context, color, formatString, args...); + } + + template + PIXScopedRetailEventObject(CONTEXT* context, INT32 color, PCSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginRetailEvent(m_context, color, formatString, args...); + } + + template + PIXScopedRetailEventObject(CONTEXT* context, DWORD color, PCWSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginRetailEvent(m_context, color, formatString, args...); + } + + template + PIXScopedRetailEventObject(CONTEXT* context, DWORD color, PCSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginRetailEvent(m_context, color, formatString, args...); + } + + template + PIXScopedRetailEventObject(CONTEXT* context, UINT8 color, PCWSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginRetailEvent(m_context, color, formatString, args...); + } + + template + PIXScopedRetailEventObject(CONTEXT* context, UINT8 color, PCSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginRetailEvent(m_context, color, formatString, args...); + } + + ~PIXScopedRetailEventObject() + { + PIXEndRetailEvent(m_context); + } +}; + +template<> +class PIXScopedEventObject +{ +public: + template + PIXScopedEventObject(UINT64 color, PCWSTR formatString, ARGS... args) + { + PIXBeginEvent(color, formatString, args...); + } + + template + PIXScopedEventObject(UINT64 color, PCSTR formatString, ARGS... args) + { + PIXBeginEvent(color, formatString, args...); + } + + template + PIXScopedEventObject(UINT32 color, PCWSTR formatString, ARGS... args) + { + PIXBeginEvent(color, formatString, args...); + } + + template + PIXScopedEventObject(UINT32 color, PCSTR formatString, ARGS... args) + { + PIXBeginEvent(color, formatString, args...); + } + + template + PIXScopedEventObject(INT32 color, PCWSTR formatString, ARGS... args) + { + PIXBeginEvent(color, formatString, args...); + } + + template + PIXScopedEventObject(INT32 color, PCSTR formatString, ARGS... args) + { + PIXBeginEvent(color, formatString, args...); + } + + template + PIXScopedEventObject(DWORD color, PCWSTR formatString, ARGS... args) + { + PIXBeginEvent(color, formatString, args...); + } + + template + PIXScopedEventObject(DWORD color, PCSTR formatString, ARGS... args) + { + PIXBeginEvent(color, formatString, args...); + } + + template + PIXScopedEventObject(UINT8 color, PCWSTR formatString, ARGS... args) + { + PIXBeginEvent(color, formatString, args...); + } + + template + PIXScopedEventObject(UINT8 color, PCSTR formatString, ARGS... args) + { + PIXBeginEvent(color, formatString, args...); + } + + ~PIXScopedEventObject() + { + PIXEndEvent(); + } +}; + +#define PIXConcatenate(a, b) a ## b +#define PIXGetScopedEventVariableName(a, b) PIXConcatenate(a, b) +#define PIXScopedEvent(context, ...) PIXScopedEventObject::Type> PIXGetScopedEventVariableName(pixEvent, __LINE__)(context, __VA_ARGS__) + +#ifdef PIX3__DEFINED_CONSTEXPR +#undef constexpr +#undef PIX3__DEFINED_CONSTEXPR +#endif + +#endif // _PIXEvents_H__ + diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/PIXEventsCommon.h b/libs/bgfx/3rdparty/directx-headers/include/directx/PIXEventsCommon.h index 515d174..f1c184b 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/PIXEventsCommon.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/PIXEventsCommon.h @@ -1,41 +1,84 @@ -/*==========================================================================; -* -* Copyright (C) Microsoft Corporation. All Rights Reserved. -* -* File: PIXEventsCommon.h -* Content: PIX include file -* Don't include this file directly - use pix3.h -* -****************************************************************************/ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +// Don't include this file directly - use pix3.h + #pragma once #ifndef _PIXEventsCommon_H_ #define _PIXEventsCommon_H_ -#if defined(_AMD64_) || defined(_X86_) -#include -#endif // _AMD64_ || _X86_ - -enum PIXEventType +// +// The PIXBeginEvent and PIXSetMarker functions have an optimized path for +// copying strings that work by copying 128-bit or 64-bits at a time. In some +// circumstances this may result in PIX logging the remaining memory after the +// null terminator. +// +// By default this optimization is enabled unless Address Sanitizer is enabled, +// since this optimization can trigger a global-buffer-overflow when copying +// string literals. +// +// The PIX_ENABLE_BLOCK_ARGUMENT_COPY controls whether or not this optimization +// is enabled. Applications may also explicitly set this macro to 0 to disable +// the optimization if necessary. +// + +// Check for Address Sanitizer on either Clang or MSVC + +#if defined(__has_feature) +#if __has_feature(address_sanitizer) +#define PIX_ASAN_ENABLED +#endif +#elif defined(__SANITIZE_ADDRESS__) +#define PIX_ASAN_ENABLED +#endif + +#if defined(PIX_ENABLE_BLOCK_ARGUMENT_COPY) +// Previously set values override everything +# define PIX_ENABLE_BLOCK_ARGUMENT_COPY_SET 0 +#elif defined(PIX_ASAN_ENABLED) +// Disable block argument copy when address sanitizer is enabled +#define PIX_ENABLE_BLOCK_ARGUMENT_COPY 0 +#define PIX_ENABLE_BLOCK_ARGUMENT_COPY_SET 1 +#endif + +#if !defined(PIX_ENABLE_BLOCK_ARGUMENT_COPY) +// Default to enabled. +#define PIX_ENABLE_BLOCK_ARGUMENT_COPY 1 +#define PIX_ENABLE_BLOCK_ARGUMENT_COPY_SET 1 +#endif + +struct PIXEventsBlockInfo; + +struct PIXEventsThreadInfo { - PIXEvent_EndEvent = 0x000, - PIXEvent_BeginEvent_VarArgs = 0x001, - PIXEvent_BeginEvent_NoArgs = 0x002, - PIXEvent_SetMarker_VarArgs = 0x007, - PIXEvent_SetMarker_NoArgs = 0x008, + PIXEventsBlockInfo* block; + UINT64* biasedLimit; + UINT64* destination; +}; + +//extern "C" UINT64 WINAPI PIXEventsReplaceBlock(PIXEventsThreadInfo * threadInfo, bool getEarliestTime) noexcept; - PIXEvent_EndEvent_OnContext = 0x010, - PIXEvent_BeginEvent_OnContext_VarArgs = 0x011, - PIXEvent_BeginEvent_OnContext_NoArgs = 0x012, - PIXEvent_SetMarker_OnContext_VarArgs = 0x017, - PIXEvent_SetMarker_OnContext_NoArgs = 0x018, +#define PIX_EVENT_METADATA_NONE 0x0 +#define PIX_EVENT_METADATA_ON_CONTEXT 0x1 +#define PIX_EVENT_METADATA_STRING_IS_ANSI 0x2 +#define PIX_EVENT_METADATA_HAS_COLOR 0xF0 + +#ifndef PIX_GAMING_XBOX +#include "PIXEventsLegacy.h" +#endif + +enum PIXEventType : UINT8 +{ + PIXEvent_EndEvent = 0x00, + PIXEvent_BeginEvent = 0x01, + PIXEvent_SetMarker = 0x02, }; static const UINT64 PIXEventsReservedRecordSpaceQwords = 64; //this is used to make sure SSE string copy always will end 16-byte write in the current block //this way only a check if destination < limit can be performed, instead of destination < limit - 1 //since both these are UINT64* and SSE writes in 16 byte chunks, 8 bytes are kept in reserve -//so even if SSE overwrites 8 extra bytes, those will still belong to the correct block +//so even if SSE overwrites 8-15 extra bytes, those will still belong to the correct block //on next iteration check destination will be greater than limit //this is used as well for fixed size UMD events and PIXEndEvent since these require less space //than other variable length user events and do not need big reserved space @@ -46,20 +89,43 @@ static const UINT64 PIXEventsGraphicsRecordSpaceQwords = 64; //Bits 7-19 (13 bits) static const UINT64 PIXEventsBlockEndMarker = 0x00000000000FFF80; -//Bits 10-19 (10 bits) -static const UINT64 PIXEventsTypeReadMask = 0x00000000000FFC00; -static const UINT64 PIXEventsTypeWriteMask = 0x00000000000003FF; -static const UINT64 PIXEventsTypeBitShift = 10; -//Bits 20-63 (44 bits) -static const UINT64 PIXEventsTimestampReadMask = 0xFFFFFFFFFFF00000; +// V2 events + +// Bits 00..06 (7 bits) - Size in QWORDS +static const UINT64 PIXEventsSizeWriteMask = 0x000000000000007F; +static const UINT64 PIXEventsSizeBitShift = 0; +static const UINT64 PIXEventsSizeReadMask = PIXEventsSizeWriteMask << PIXEventsSizeBitShift; +static const UINT64 PIXEventsSizeMax = (1ull << 7) - 1ull; + +// Bits 07..11 (5 bits) - Event Type +static const UINT64 PIXEventsTypeWriteMask = 0x000000000000001F; +static const UINT64 PIXEventsTypeBitShift = 7; +static const UINT64 PIXEventsTypeReadMask = PIXEventsTypeWriteMask << PIXEventsTypeBitShift; + +// Bits 12..19 (8 bits) - Event Specific Metadata +static const UINT64 PIXEventsMetadataWriteMask = 0x00000000000000FF; +static const UINT64 PIXEventsMetadataBitShift = 12; +static const UINT64 PIXEventsMetadataReadMask = PIXEventsMetadataWriteMask << PIXEventsMetadataBitShift; + +// Buts 20..63 (44 bits) - Timestamp static const UINT64 PIXEventsTimestampWriteMask = 0x00000FFFFFFFFFFF; static const UINT64 PIXEventsTimestampBitShift = 20; +static const UINT64 PIXEventsTimestampReadMask = PIXEventsTimestampWriteMask << PIXEventsTimestampBitShift; + +inline UINT64 PIXEncodeEventInfo(UINT64 timestamp, PIXEventType eventType, UINT8 eventSize, UINT8 eventMetadata) +{ + return + ((timestamp & PIXEventsTimestampWriteMask) << PIXEventsTimestampBitShift) | + (((UINT64)eventType & PIXEventsTypeWriteMask) << PIXEventsTypeBitShift) | + (((UINT64)eventMetadata & PIXEventsMetadataWriteMask) << PIXEventsMetadataBitShift) | + (((UINT64)eventSize & PIXEventsSizeWriteMask) << PIXEventsSizeBitShift); +} -inline UINT64 PIXEncodeEventInfo(UINT64 timestamp, PIXEventType eventType) +inline UINT8 PIXEncodeIndexColor(UINT8 color) { - return ((timestamp & PIXEventsTimestampWriteMask) << PIXEventsTimestampBitShift) | - (((UINT64)eventType & PIXEventsTypeWriteMask) << PIXEventsTypeBitShift); + // There are 8 index colors, indexed 0 (default) to 7 + return (color & 0x7) << 4; } //Bits 60-63 (4) @@ -82,12 +148,13 @@ static const UINT64 PIXEventsStringIsShortcutWriteMask = 0x0000000000000001; static const UINT64 PIXEventsStringIsShortcutReadMask = 0x0020000000000000; static const UINT64 PIXEventsStringIsShortcutBitShift = 53; -inline UINT64 PIXEncodeStringInfo(UINT64 alignment, UINT64 copyChunkSize, BOOL isANSI, BOOL isShortcut) +inline void PIXEncodeStringInfo(UINT64*& destination, BOOL isANSI) { - return ((alignment & PIXEventsStringAlignmentWriteMask) << PIXEventsStringAlignmentBitShift) | - ((copyChunkSize & PIXEventsStringCopyChunkSizeWriteMask) << PIXEventsStringCopyChunkSizeBitShift) | - (((UINT64)isANSI & PIXEventsStringIsANSIWriteMask) << PIXEventsStringIsANSIBitShift) | - (((UINT64)isShortcut & PIXEventsStringIsShortcutWriteMask) << PIXEventsStringIsShortcutBitShift); + const UINT64 encodedStringInfo = + ((sizeof(UINT64) & PIXEventsStringCopyChunkSizeWriteMask) << PIXEventsStringCopyChunkSizeBitShift) | + (((UINT64)isANSI & PIXEventsStringIsANSIWriteMask) << PIXEventsStringIsANSIBitShift); + + *destination++ = encodedStringInfo; } template @@ -96,16 +163,62 @@ inline bool PIXIsPointerAligned(T* pointer) return !(((UINT64)pointer) & (alignment - 1)); } +// Generic template version slower because of the additional clear write template inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, T argument) { if (destination < limit) { + *destination = 0ull; *((T*)destination) = argument; ++destination; } } +// int32 specialization to avoid slower double memory writes +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, INT32 argument) +{ + if (destination < limit) + { + *reinterpret_cast(destination) = static_cast(argument); + ++destination; + } +} + +// unsigned int32 specialization to avoid slower double memory writes +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, UINT32 argument) +{ + if (destination < limit) + { + *destination = static_cast(argument); + ++destination; + } +} + +// int64 specialization to avoid slower double memory writes +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, INT64 argument) +{ + if (destination < limit) + { + *reinterpret_cast(destination) = argument; + ++destination; + } +} + +// unsigned int64 specialization to avoid slower double memory writes +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, UINT64 argument) +{ + if (destination < limit) + { + *destination = argument; + ++destination; + } +} + //floats must be cast to double during writing the data to be properly printed later when reading the data //this is needed because when float is passed to varargs function it's cast to double template<> @@ -113,7 +226,7 @@ inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& dest { if (destination < limit) { - *((double*)destination) = (double)(argument); + *reinterpret_cast(destination) = static_cast(argument); ++destination; } } @@ -125,19 +238,19 @@ inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& desti { if (destination < limit) { - *((INT64*)destination) = (INT64)(argument); + *reinterpret_cast(destination) = static_cast(argument); ++destination; } } -//unsigned char has to be cast to a longer unsigned integer type +//UINT8 has to be cast to a longer unsigned integer type //this is due to printf not ignoring correctly the upper bits of unsigned long long for a char format specifier template<> -inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, unsigned char argument) +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, UINT8 argument) { if (destination < limit) { - *destination = (UINT64)(argument); + *destination = static_cast(argument); ++destination; } } @@ -149,66 +262,65 @@ inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& desti { if (destination < limit) { - *destination = (UINT64)(argument); + *destination = static_cast(argument); ++destination; } } -inline void PIXCopyEventArgumentSlowest(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument) +inline void PIXCopyEventStringArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument) { - *destination++ = PIXEncodeStringInfo(0, 8, TRUE, FALSE); while (destination < limit) { - UINT64 c = argument[0]; + UINT64 c = static_cast(argument[0]); if (!c) { *destination++ = 0; return; } UINT64 x = c; - c = argument[1]; + c = static_cast(argument[1]); if (!c) { *destination++ = x; return; } x |= c << 8; - c = argument[2]; + c = static_cast(argument[2]); if (!c) { *destination++ = x; return; } x |= c << 16; - c = argument[3]; + c = static_cast(argument[3]); if (!c) { *destination++ = x; return; } x |= c << 24; - c = argument[4]; + c = static_cast(argument[4]); if (!c) { *destination++ = x; return; } x |= c << 32; - c = argument[5]; + c = static_cast(argument[5]); if (!c) { *destination++ = x; return; } x |= c << 40; - c = argument[6]; + c = static_cast(argument[6]); if (!c) { *destination++ = x; return; } x |= c << 48; - c = argument[7]; + c = static_cast(argument[7]); if (!c) { *destination++ = x; @@ -220,35 +332,42 @@ inline void PIXCopyEventArgumentSlowest(_Out_writes_to_ptr_(limit) UINT64*& dest } } +template inline void PIXCopyEventArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument) { - if (PIXIsPointerAligned<8>(argument)) + PIXEncodeStringInfo(destination, TRUE); + PIXCopyEventStringArgumentSlow(destination, limit, argument); +} + +template<> +inline void PIXCopyEventArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument) +{ + PIXCopyEventStringArgumentSlow(destination, limit, argument); +} + +#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + +inline void PIXCopyEventStringArgumentFast(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument) +{ + constexpr UINT64 mask1 = 0x0101010101010101ULL; + constexpr UINT64 mask2 = 0x8080808080808080ULL; + UINT64* source = (UINT64*)argument; + + while (destination < limit) { - *destination++ = PIXEncodeStringInfo(0, 8, TRUE, FALSE); - UINT64* source = (UINT64*)argument; - while (destination < limit) + UINT64 qword = *source++; + *destination++ = qword; + + //check if any of the characters is a terminating zero + UINT64 isTerminated = (qword - mask1) & (~qword & mask2); + + if (isTerminated) { - UINT64 qword = *source++; - *destination++ = qword; - //check if any of the characters is a terminating zero - if (!((qword & 0xFF00000000000000) && - (qword & 0xFF000000000000) && - (qword & 0xFF0000000000) && - (qword & 0xFF00000000) && - (qword & 0xFF000000) && - (qword & 0xFF0000) && - (qword & 0xFF00) && - (qword & 0xFF))) - { - break; - } + break; } } - else - { - PIXCopyEventArgumentSlowest(destination, limit, argument); - } } +#endif template<> inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument) @@ -257,44 +376,16 @@ inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& dest { if (argument != nullptr) { -#if defined(_AMD64_) || defined(_X86_) - if (PIXIsPointerAligned<16>(argument)) +#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + if (PIXIsPointerAligned<8>(argument)) { - *destination++ = PIXEncodeStringInfo(0, 16, TRUE, FALSE); - __m128i zero = _mm_setzero_si128(); - if (PIXIsPointerAligned<16>(destination)) - { - while (destination < limit) - { - __m128i mem = _mm_load_si128((__m128i*)argument); - _mm_store_si128((__m128i*)destination, mem); - //check if any of the characters is a terminating zero - __m128i res = _mm_cmpeq_epi8(mem, zero); - destination += 2; - if (_mm_movemask_epi8(res)) - break; - argument += 16; - } - } - else - { - while (destination < limit) - { - __m128i mem = _mm_load_si128((__m128i*)argument); - _mm_storeu_si128((__m128i*)destination, mem); - //check if any of the characters is a terminating zero - __m128i res = _mm_cmpeq_epi8(mem, zero); - destination += 2; - if (_mm_movemask_epi8(res)) - break; - argument += 16; - } - } + PIXEncodeStringInfo(destination, TRUE); + PIXCopyEventStringArgumentFast(destination, limit, argument); } else -#endif // _AMD64_ || _X86_ +#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY { - PIXCopyEventArgumentSlow(destination, limit, argument); + PIXCopyEventArgumentSlow(destination, limit, argument); } } else @@ -304,39 +395,64 @@ inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& dest } } +inline void PIXCopyStringArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument) +{ + if (argument != nullptr) + { +#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + if (PIXIsPointerAligned<8>(argument)) + { + PIXCopyEventStringArgumentFast(destination, limit, argument); + } + else +#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + { + PIXCopyEventArgumentSlow(destination, limit, argument); + } + } + else + { + *destination++ = 0ull; + } +} + template<> inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PSTR argument) { PIXCopyEventArgument(destination, limit, (PCSTR)argument); } -inline void PIXCopyEventArgumentSlowest(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument) +inline void PIXCopyStringArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PSTR argument) +{ + PIXCopyStringArgument(destination, limit, (PCSTR)argument); +} + +inline void PIXCopyEventStringArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument) { - *destination++ = PIXEncodeStringInfo(0, 8, FALSE, FALSE); while (destination < limit) { - UINT64 c = argument[0]; + UINT64 c = static_cast(argument[0]); if (!c) { *destination++ = 0; return; } UINT64 x = c; - c = argument[1]; + c = static_cast(argument[1]); if (!c) { *destination++ = x; return; } x |= c << 16; - c = argument[2]; + c = static_cast(argument[2]); if (!c) { *destination++ = x; return; } x |= c << 32; - c = argument[3]; + c = static_cast(argument[3]); if (!c) { *destination++ = x; @@ -348,32 +464,39 @@ inline void PIXCopyEventArgumentSlowest(_Out_writes_to_ptr_(limit) UINT64*& dest } } +template inline void PIXCopyEventArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument) { - if (PIXIsPointerAligned<8>(argument)) + PIXEncodeStringInfo(destination, FALSE); + PIXCopyEventStringArgumentSlow(destination, limit, argument); +} + +template<> +inline void PIXCopyEventArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument) +{ + PIXCopyEventStringArgumentSlow(destination, limit, argument); +} + +#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY +inline void PIXCopyEventStringArgumentFast(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument) +{ + UINT64* source = (UINT64*)argument; + while (destination < limit) { - *destination++ = PIXEncodeStringInfo(0, 8, FALSE, FALSE); - UINT64* source = (UINT64*)argument; - while (destination < limit) + UINT64 qword = *source++; + *destination++ = qword; + //check if any of the characters is a terminating zero + //TODO: check if reversed condition is faster + if (!((qword & 0xFFFF000000000000) && + (qword & 0xFFFF00000000) && + (qword & 0xFFFF0000) && + (qword & 0xFFFF))) { - UINT64 qword = *source++; - *destination++ = qword; - //check if any of the characters is a terminating zero - //TODO: check if reversed condition is faster - if (!((qword & 0xFFFF000000000000) && - (qword & 0xFFFF00000000) && - (qword & 0xFFFF0000) && - (qword & 0xFFFF))) - { - break; - } + break; } } - else - { - PIXCopyEventArgumentSlowest(destination, limit, argument); - } } +#endif template<> inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument) @@ -382,44 +505,16 @@ inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& des { if (argument != nullptr) { -#if defined(_AMD64_) || defined(_X86_) - if (PIXIsPointerAligned<16>(argument)) +#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + if (PIXIsPointerAligned<8>(argument)) { - *destination++ = PIXEncodeStringInfo(0, 16, FALSE, FALSE); - __m128i zero = _mm_setzero_si128(); - if (PIXIsPointerAligned<16>(destination)) - { - while (destination < limit) - { - __m128i mem = _mm_load_si128((__m128i*)argument); - _mm_store_si128((__m128i*)destination, mem); - //check if any of the characters is a terminating zero - __m128i res = _mm_cmpeq_epi16(mem, zero); - destination += 2; - if (_mm_movemask_epi8(res)) - break; - argument += 8; - } - } - else - { - while (destination < limit) - { - __m128i mem = _mm_load_si128((__m128i*)argument); - _mm_storeu_si128((__m128i*)destination, mem); - //check if any of the characters is a terminating zero - __m128i res = _mm_cmpeq_epi16(mem, zero); - destination += 2; - if (_mm_movemask_epi8(res)) - break; - argument += 8; - } - } + PIXEncodeStringInfo(destination, FALSE); + PIXCopyEventStringArgumentFast(destination, limit, argument); } else -#endif // _AMD64_ || _X86_ +#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY { - PIXCopyEventArgumentSlow(destination, limit, argument); + PIXCopyEventArgumentSlow(destination, limit, argument); } } else @@ -429,44 +524,71 @@ inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& des } } +inline void PIXCopyStringArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument) +{ + if (argument != nullptr) + { +#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + if (PIXIsPointerAligned<8>(argument)) + { + PIXCopyEventStringArgumentFast(destination, limit, argument); + } + else +#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + { + PIXCopyEventArgumentSlow(destination, limit, argument); + } + } + else + { + *destination++ = 0ull; + } +} + template<> inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PWSTR argument) { PIXCopyEventArgument(destination, limit, (PCWSTR)argument); }; -#if defined(__d3d12_x_h__) || defined(__d3d12_h__) +inline void PIXCopyStringArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PWSTR argument) +{ + PIXCopyStringArgument(destination, limit, (PCWSTR)argument); +}; + +#if defined(__d3d12_x_h__) || defined(__d3d12_xs_h__) || defined(__d3d12_h__) -inline void PIXSetMarkerOnContext(_In_ ID3D12GraphicsCommandList* commandList, _In_reads_bytes_(size) void* data, UINT size) +inline void PIXSetGPUMarkerOnContext(_In_ ID3D12GraphicsCommandList* commandList, _In_reads_bytes_(size) void* data, UINT size) { commandList->SetMarker(D3D12_EVENT_METADATA, data, size); } -inline void PIXSetMarkerOnContext(_In_ ID3D12CommandQueue* commandQueue, _In_reads_bytes_(size) void* data, UINT size) +inline void PIXSetGPUMarkerOnContext(_In_ ID3D12CommandQueue* commandQueue, _In_reads_bytes_(size) void* data, UINT size) { commandQueue->SetMarker(D3D12_EVENT_METADATA, data, size); } -inline void PIXBeginEventOnContext(_In_ ID3D12GraphicsCommandList* commandList, _In_reads_bytes_(size) void* data, UINT size) +inline void PIXBeginGPUEventOnContext(_In_ ID3D12GraphicsCommandList* commandList, _In_reads_bytes_(size) void* data, UINT size) { commandList->BeginEvent(D3D12_EVENT_METADATA, data, size); } -inline void PIXBeginEventOnContext(_In_ ID3D12CommandQueue* commandQueue, _In_reads_bytes_(size) void* data, UINT size) +inline void PIXBeginGPUEventOnContext(_In_ ID3D12CommandQueue* commandQueue, _In_reads_bytes_(size) void* data, UINT size) { commandQueue->BeginEvent(D3D12_EVENT_METADATA, data, size); } -inline void PIXEndEventOnContext(_In_ ID3D12GraphicsCommandList* commandList) + +inline void PIXEndGPUEventOnContext(_In_ ID3D12GraphicsCommandList* commandList) { commandList->EndEvent(); } -inline void PIXEndEventOnContext(_In_ ID3D12CommandQueue* commandQueue) +inline void PIXEndGPUEventOnContext(_In_ ID3D12CommandQueue* commandQueue) { commandQueue->EndEvent(); } -#endif //__d3d12_x_h__ +#endif //__d3d12_h__ template struct PIXInferScopedEventType { typedef T Type; }; template struct PIXInferScopedEventType { typedef T Type; }; @@ -480,4 +602,9 @@ template<> struct PIXInferScopedEventType { typedef void Type; }; template<> struct PIXInferScopedEventType { typedef void Type; }; template<> struct PIXInferScopedEventType { typedef void Type; }; template<> struct PIXInferScopedEventType { typedef void Type; }; +template<> struct PIXInferScopedEventType { typedef void Type; }; +template<> struct PIXInferScopedEventType { typedef void Type; }; +template<> struct PIXInferScopedEventType { typedef void Type; }; +template<> struct PIXInferScopedEventType { typedef void Type; }; + #endif //_PIXEventsCommon_H_ diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/PIXEventsLegacy.h b/libs/bgfx/3rdparty/directx-headers/include/directx/PIXEventsLegacy.h new file mode 100644 index 0000000..b5b08be --- /dev/null +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/PIXEventsLegacy.h @@ -0,0 +1,565 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +// Don't include this file directly - use pix3.h +// This file encodes PIX events in the legacy PIX event format. + +#ifndef _PIXEventsLegacy_H_ +#define _PIXEventsLegacy_H_ + +#include + +#if defined(_M_X64) || defined(_M_IX86) +#include +#endif + +namespace PixEventsLegacy +{ + enum PIXEventType + { + PIXEvent_EndEvent = 0x000, + PIXEvent_BeginEvent_VarArgs = 0x001, + PIXEvent_BeginEvent_NoArgs = 0x002, + PIXEvent_SetMarker_VarArgs = 0x007, + PIXEvent_SetMarker_NoArgs = 0x008, + + PIXEvent_EndEvent_OnContext = 0x010, + PIXEvent_BeginEvent_OnContext_VarArgs = 0x011, + PIXEvent_BeginEvent_OnContext_NoArgs = 0x012, + PIXEvent_SetMarker_OnContext_VarArgs = 0x017, + PIXEvent_SetMarker_OnContext_NoArgs = 0x018, + }; + + static const UINT64 PIXEventsReservedRecordSpaceQwords = 64; + static const UINT64 PIXEventsReservedTailSpaceQwords = 2; + static const UINT64 PIXEventsSafeFastCopySpaceQwords = PIXEventsReservedRecordSpaceQwords - PIXEventsReservedTailSpaceQwords; + static const UINT64 PIXEventsGraphicsRecordSpaceQwords = 64; + + //Bits 7-19 (13 bits) + static const UINT64 PIXEventsBlockEndMarker = 0x00000000000FFF80; + + //Bits 10-19 (10 bits) + static const UINT64 PIXEventsTypeReadMask = 0x00000000000FFC00; + static const UINT64 PIXEventsTypeWriteMask = 0x00000000000003FF; + static const UINT64 PIXEventsTypeBitShift = 10; + + //Bits 20-63 (44 bits) + static const UINT64 PIXEventsTimestampReadMask = 0xFFFFFFFFFFF00000; + static const UINT64 PIXEventsTimestampWriteMask = 0x00000FFFFFFFFFFF; + static const UINT64 PIXEventsTimestampBitShift = 20; + + inline UINT64 PIXEncodeEventInfo(UINT64 timestamp, PIXEventType eventType) + { + return ((timestamp & PIXEventsTimestampWriteMask) << PIXEventsTimestampBitShift) | + (((UINT64)eventType & PIXEventsTypeWriteMask) << PIXEventsTypeBitShift); + } + + //Bits 60-63 (4) + static const UINT64 PIXEventsStringAlignmentWriteMask = 0x000000000000000F; + static const UINT64 PIXEventsStringAlignmentReadMask = 0xF000000000000000; + static const UINT64 PIXEventsStringAlignmentBitShift = 60; + + //Bits 55-59 (5) + static const UINT64 PIXEventsStringCopyChunkSizeWriteMask = 0x000000000000001F; + static const UINT64 PIXEventsStringCopyChunkSizeReadMask = 0x0F80000000000000; + static const UINT64 PIXEventsStringCopyChunkSizeBitShift = 55; + + //Bit 54 + static const UINT64 PIXEventsStringIsANSIWriteMask = 0x0000000000000001; + static const UINT64 PIXEventsStringIsANSIReadMask = 0x0040000000000000; + static const UINT64 PIXEventsStringIsANSIBitShift = 54; + + //Bit 53 + static const UINT64 PIXEventsStringIsShortcutWriteMask = 0x0000000000000001; + static const UINT64 PIXEventsStringIsShortcutReadMask = 0x0020000000000000; + static const UINT64 PIXEventsStringIsShortcutBitShift = 53; + + inline UINT64 PIXEncodeStringInfo(UINT64 alignment, UINT64 copyChunkSize, BOOL isANSI, BOOL isShortcut) + { + return ((alignment & PIXEventsStringAlignmentWriteMask) << PIXEventsStringAlignmentBitShift) | + ((copyChunkSize & PIXEventsStringCopyChunkSizeWriteMask) << PIXEventsStringCopyChunkSizeBitShift) | + (((UINT64)isANSI & PIXEventsStringIsANSIWriteMask) << PIXEventsStringIsANSIBitShift) | + (((UINT64)isShortcut & PIXEventsStringIsShortcutWriteMask) << PIXEventsStringIsShortcutBitShift); + } + + template + inline bool PIXIsPointerAligned(T* pointer) + { + return !(((UINT64)pointer) & (alignment - 1)); + } + + // Generic template version slower because of the additional clear write + template + inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, T argument) + { + if (destination < limit) + { + *destination = 0ull; + *((T*)destination) = argument; + ++destination; + } + } + + // int32 specialization to avoid slower double memory writes + template<> + inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, INT32 argument) + { + if (destination < limit) + { + *reinterpret_cast(destination) = static_cast(argument); + ++destination; + } + } + + // unsigned int32 specialization to avoid slower double memory writes + template<> + inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, UINT32 argument) + { + if (destination < limit) + { + *destination = static_cast(argument); + ++destination; + } + } + + // int64 specialization to avoid slower double memory writes + template<> + inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, INT64 argument) + { + if (destination < limit) + { + *reinterpret_cast(destination) = argument; + ++destination; + } + } + + // unsigned int64 specialization to avoid slower double memory writes + template<> + inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, UINT64 argument) + { + if (destination < limit) + { + *destination = argument; + ++destination; + } + } + + //floats must be cast to double during writing the data to be properly printed later when reading the data + //this is needed because when float is passed to varargs function it's cast to double + template<> + inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, float argument) + { + if (destination < limit) + { + *reinterpret_cast(destination) = static_cast(argument); + ++destination; + } + } + + //char has to be cast to a longer signed integer type + //this is due to printf not ignoring correctly the upper bits of unsigned long long for a char format specifier + template<> + inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, char argument) + { + if (destination < limit) + { + *reinterpret_cast(destination) = static_cast(argument); + ++destination; + } + } + + //unsigned char has to be cast to a longer unsigned integer type + //this is due to printf not ignoring correctly the upper bits of unsigned long long for a char format specifier + template<> + inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, unsigned char argument) + { + if (destination < limit) + { + *destination = static_cast(argument); + ++destination; + } + } + + //bool has to be cast to an integer since it's not explicitly supported by string format routines + //there's no format specifier for bool type, but it should work with integer format specifiers + template<> + inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, bool argument) + { + if (destination < limit) + { + *destination = static_cast(argument); + ++destination; + } + } + + inline void PIXCopyEventArgumentSlowest(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument) + { + *destination++ = PIXEncodeStringInfo(0, 8, TRUE, FALSE); + while (destination < limit) + { + UINT64 c = static_cast(argument[0]); + if (!c) + { + *destination++ = 0; + return; + } + UINT64 x = c; + c = static_cast(argument[1]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 8; + c = static_cast(argument[2]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 16; + c = static_cast(argument[3]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 24; + c = static_cast(argument[4]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 32; + c = static_cast(argument[5]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 40; + c = static_cast(argument[6]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 48; + c = static_cast(argument[7]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 56; + *destination++ = x; + argument += 8; + } + } + + inline void PIXCopyEventArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument) + { +#if PIX_ENABLE_BLOCK_ARGUMENT_COPY + if (PIXIsPointerAligned<8>(argument)) + { + *destination++ = PIXEncodeStringInfo(0, 8, TRUE, FALSE); + UINT64* source = (UINT64*)argument; + while (destination < limit) + { + UINT64 qword = *source++; + *destination++ = qword; + //check if any of the characters is a terminating zero + if (!((qword & 0xFF00000000000000) && + (qword & 0xFF000000000000) && + (qword & 0xFF0000000000) && + (qword & 0xFF00000000) && + (qword & 0xFF000000) && + (qword & 0xFF0000) && + (qword & 0xFF00) && + (qword & 0xFF))) + { + break; + } + } + } + else +#endif // PIX_ENABLE_BLOCK_ARGUMENT_COPY + { + PIXCopyEventArgumentSlowest(destination, limit, argument); + } + } + + template<> + inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument) + { + if (destination < limit) + { + if (argument != nullptr) + { +#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + if (PIXIsPointerAligned<16>(argument)) + { + *destination++ = PIXEncodeStringInfo(0, 16, TRUE, FALSE); + __m128i zero = _mm_setzero_si128(); + if (PIXIsPointerAligned<16>(destination)) + { + while (destination < limit) + { + __m128i mem = _mm_load_si128((__m128i*)argument); + _mm_store_si128((__m128i*)destination, mem); + //check if any of the characters is a terminating zero + __m128i res = _mm_cmpeq_epi8(mem, zero); + destination += 2; + if (_mm_movemask_epi8(res)) + break; + argument += 16; + } + } + else + { + while (destination < limit) + { + __m128i mem = _mm_load_si128((__m128i*)argument); + _mm_storeu_si128((__m128i*)destination, mem); + //check if any of the characters is a terminating zero + __m128i res = _mm_cmpeq_epi8(mem, zero); + destination += 2; + if (_mm_movemask_epi8(res)) + break; + argument += 16; + } + } + } + else +#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + { + PIXCopyEventArgumentSlow(destination, limit, argument); + } + } + else + { + *destination++ = 0ull; + } + } + } + + template<> + inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PSTR argument) + { + PIXCopyEventArgument(destination, limit, (PCSTR)argument); + } + + inline void PIXCopyEventArgumentSlowest(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument) + { + *destination++ = PIXEncodeStringInfo(0, 8, FALSE, FALSE); + while (destination < limit) + { + UINT64 c = static_cast(argument[0]); + if (!c) + { + *destination++ = 0; + return; + } + UINT64 x = c; + c = static_cast(argument[1]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 16; + c = static_cast(argument[2]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 32; + c = static_cast(argument[3]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 48; + *destination++ = x; + argument += 4; + } + } + + inline void PIXCopyEventArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument) + { +#if PIX_ENABLE_BLOCK_ARGUMENT_COPY + if (PIXIsPointerAligned<8>(argument)) + { + *destination++ = PIXEncodeStringInfo(0, 8, FALSE, FALSE); + UINT64* source = (UINT64*)argument; + while (destination < limit) + { + UINT64 qword = *source++; + *destination++ = qword; + //check if any of the characters is a terminating zero + //TODO: check if reversed condition is faster + if (!((qword & 0xFFFF000000000000) && + (qword & 0xFFFF00000000) && + (qword & 0xFFFF0000) && + (qword & 0xFFFF))) + { + break; + } + } + } + else +#endif // PIX_ENABLE_BLOCK_ARGUMENT_COPY + { + PIXCopyEventArgumentSlowest(destination, limit, argument); + } + } + + template<> + inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument) + { + if (destination < limit) + { + if (argument != nullptr) + { +#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + if (PIXIsPointerAligned<16>(argument)) + { + *destination++ = PIXEncodeStringInfo(0, 16, FALSE, FALSE); + __m128i zero = _mm_setzero_si128(); + if (PIXIsPointerAligned<16>(destination)) + { + while (destination < limit) + { + __m128i mem = _mm_load_si128((__m128i*)argument); + _mm_store_si128((__m128i*)destination, mem); + //check if any of the characters is a terminating zero + __m128i res = _mm_cmpeq_epi16(mem, zero); + destination += 2; + if (_mm_movemask_epi8(res)) + break; + argument += 8; + } + } + else + { + while (destination < limit) + { + __m128i mem = _mm_load_si128((__m128i*)argument); + _mm_storeu_si128((__m128i*)destination, mem); + //check if any of the characters is a terminating zero + __m128i res = _mm_cmpeq_epi16(mem, zero); + destination += 2; + if (_mm_movemask_epi8(res)) + break; + argument += 8; + } + } + } + else +#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + { + PIXCopyEventArgumentSlow(destination, limit, argument); + } + } + else + { + *destination++ = 0ull; + } + } + } + + inline void PIXCopyEventArguments(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit) + { + // nothing + UNREFERENCED_PARAMETER(destination); + UNREFERENCED_PARAMETER(limit); + } + + template + void PIXCopyEventArguments(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, ARG const& arg, ARGS const&... args) + { + PIXCopyEventArgument(destination, limit, arg); + PIXCopyEventArguments(destination, limit, args...); + } + + template + struct PIXEventTypeInferer + { + static constexpr PIXEventType Begin() { return PIXEvent_BeginEvent_VarArgs; } + static constexpr PIXEventType SetMarker() { return PIXEvent_SetMarker_VarArgs; } + static constexpr PIXEventType BeginOnContext() { return PIXEvent_BeginEvent_OnContext_VarArgs; } + static constexpr PIXEventType SetMarkerOnContext() { return PIXEvent_SetMarker_OnContext_VarArgs; } + static constexpr PIXEventType End() { return PIXEvent_EndEvent; } + + // Xbox and Windows store different types of events for context events. + // On Xbox these include a context argument, while on Windows they do + // not. It is important not to change the event types used on the + // Windows version as there are OS components (eg debug layer & DRED) + // that decode event structs. +#ifdef PIX_XBOX + static constexpr PIXEventType GpuBeginOnContext() { return PIXEvent_BeginEvent_OnContext_VarArgs; } + static constexpr PIXEventType GpuSetMarkerOnContext() { return PIXEvent_SetMarker_OnContext_VarArgs; } + static constexpr PIXEventType GpuEndOnContext() { return PIXEvent_EndEvent_OnContext; } +#else + static constexpr PIXEventType GpuBeginOnContext() { return PIXEvent_BeginEvent_VarArgs; } + static constexpr PIXEventType GpuSetMarkerOnContext() { return PIXEvent_SetMarker_VarArgs; } + static constexpr PIXEventType GpuEndOnContext() { return PIXEvent_EndEvent; } +#endif + }; + + template<> + struct PIXEventTypeInferer<> + { + static constexpr PIXEventType Begin() { return PIXEvent_BeginEvent_NoArgs; } + static constexpr PIXEventType SetMarker() { return PIXEvent_SetMarker_NoArgs; } + static constexpr PIXEventType BeginOnContext() { return PIXEvent_BeginEvent_OnContext_NoArgs; } + static constexpr PIXEventType SetMarkerOnContext() { return PIXEvent_SetMarker_OnContext_NoArgs; } + static constexpr PIXEventType End() { return PIXEvent_EndEvent; } + +#ifdef PIX_XBOX + static constexpr PIXEventType GpuBeginOnContext() { return PIXEvent_BeginEvent_OnContext_NoArgs; } + static constexpr PIXEventType GpuSetMarkerOnContext() { return PIXEvent_SetMarker_OnContext_NoArgs; } + static constexpr PIXEventType GpuEndOnContext() { return PIXEvent_EndEvent_OnContext; } +#else + static constexpr PIXEventType GpuBeginOnContext() { return PIXEvent_BeginEvent_NoArgs; } + static constexpr PIXEventType GpuSetMarkerOnContext() { return PIXEvent_SetMarker_NoArgs; } + static constexpr PIXEventType GpuEndOnContext() { return PIXEvent_EndEvent; } +#endif + }; + + + template + UINT64* EncodeBeginEventForContext(UINT64 (&buffer)[size], UINT64 color, STR formatString, ARGS... args) + { + UINT64* destination = buffer; + UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords; + + *destination++ = PIXEncodeEventInfo(0, PIXEventTypeInferer::GpuBeginOnContext()); + *destination++ = color; + + PIXCopyEventArguments(destination, limit, formatString, args...); + *destination = 0ull; + + return destination; + } + + template + UINT64* EncodeSetMarkerForContext(UINT64 (&buffer)[size], UINT64 color, STR formatString, ARGS... args) + { + UINT64* destination = buffer; + UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords; + + *destination++ = PIXEncodeEventInfo(0, PIXEventTypeInferer::GpuSetMarkerOnContext()); + *destination++ = color; + + PIXCopyEventArguments(destination, limit, formatString, args...); + *destination = 0ull; + + return destination; + } +} + +#endif //_PIXEventsLegacy_H_ diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12.h b/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12.h index 66cfa4c..9e9db13 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12.h @@ -15,7 +15,7 @@ /* verify that the version is high enough to compile this file*/ #ifndef __REQUIRED_RPCNDR_H_VERSION__ -#define __REQUIRED_RPCNDR_H_VERSION__ 475 +#define __REQUIRED_RPCNDR_H_VERSION__ 500 #endif /* verify that the version is high enough to compile this file*/ @@ -136,6 +136,13 @@ typedef interface ID3D12PipelineState ID3D12PipelineState; #endif /* __ID3D12PipelineState_FWD_DEFINED__ */ +#ifndef __ID3D12PipelineState1_FWD_DEFINED__ +#define __ID3D12PipelineState1_FWD_DEFINED__ +typedef interface ID3D12PipelineState1 ID3D12PipelineState1; + +#endif /* __ID3D12PipelineState1_FWD_DEFINED__ */ + + #ifndef __ID3D12DescriptorHeap_FWD_DEFINED__ #define __ID3D12DescriptorHeap_FWD_DEFINED__ typedef interface ID3D12DescriptorHeap ID3D12DescriptorHeap; @@ -192,6 +199,13 @@ typedef interface ID3D12CommandQueue ID3D12CommandQueue; #endif /* __ID3D12CommandQueue_FWD_DEFINED__ */ +#ifndef __ID3D12CommandQueue1_FWD_DEFINED__ +#define __ID3D12CommandQueue1_FWD_DEFINED__ +typedef interface ID3D12CommandQueue1 ID3D12CommandQueue1; + +#endif /* __ID3D12CommandQueue1_FWD_DEFINED__ */ + + #ifndef __ID3D12Device_FWD_DEFINED__ #define __ID3D12Device_FWD_DEFINED__ typedef interface ID3D12Device ID3D12Device; @@ -290,6 +304,27 @@ typedef interface ID3D12StateObjectProperties ID3D12StateObjectProperties; #endif /* __ID3D12StateObjectProperties_FWD_DEFINED__ */ +#ifndef __ID3D12StateObjectProperties1_FWD_DEFINED__ +#define __ID3D12StateObjectProperties1_FWD_DEFINED__ +typedef interface ID3D12StateObjectProperties1 ID3D12StateObjectProperties1; + +#endif /* __ID3D12StateObjectProperties1_FWD_DEFINED__ */ + + +#ifndef __ID3D12StateObjectProperties2_FWD_DEFINED__ +#define __ID3D12StateObjectProperties2_FWD_DEFINED__ +typedef interface ID3D12StateObjectProperties2 ID3D12StateObjectProperties2; + +#endif /* __ID3D12StateObjectProperties2_FWD_DEFINED__ */ + + +#ifndef __ID3D12WorkGraphProperties_FWD_DEFINED__ +#define __ID3D12WorkGraphProperties_FWD_DEFINED__ +typedef interface ID3D12WorkGraphProperties ID3D12WorkGraphProperties; + +#endif /* __ID3D12WorkGraphProperties_FWD_DEFINED__ */ + + #ifndef __ID3D12Device5_FWD_DEFINED__ #define __ID3D12Device5_FWD_DEFINED__ typedef interface ID3D12Device5 ID3D12Device5; @@ -437,6 +472,34 @@ typedef interface ID3D12Device11 ID3D12Device11; #endif /* __ID3D12Device11_FWD_DEFINED__ */ +#ifndef __ID3D12Device12_FWD_DEFINED__ +#define __ID3D12Device12_FWD_DEFINED__ +typedef interface ID3D12Device12 ID3D12Device12; + +#endif /* __ID3D12Device12_FWD_DEFINED__ */ + + +#ifndef __ID3D12Device13_FWD_DEFINED__ +#define __ID3D12Device13_FWD_DEFINED__ +typedef interface ID3D12Device13 ID3D12Device13; + +#endif /* __ID3D12Device13_FWD_DEFINED__ */ + + +#ifndef __ID3D12Device14_FWD_DEFINED__ +#define __ID3D12Device14_FWD_DEFINED__ +typedef interface ID3D12Device14 ID3D12Device14; + +#endif /* __ID3D12Device14_FWD_DEFINED__ */ + + +#ifndef __ID3D12StateObjectDatabase_FWD_DEFINED__ +#define __ID3D12StateObjectDatabase_FWD_DEFINED__ +typedef interface ID3D12StateObjectDatabase ID3D12StateObjectDatabase; + +#endif /* __ID3D12StateObjectDatabase_FWD_DEFINED__ */ + + #ifndef __ID3D12VirtualizationGuestDevice_FWD_DEFINED__ #define __ID3D12VirtualizationGuestDevice_FWD_DEFINED__ typedef interface ID3D12VirtualizationGuestDevice ID3D12VirtualizationGuestDevice; @@ -451,6 +514,41 @@ typedef interface ID3D12Tools ID3D12Tools; #endif /* __ID3D12Tools_FWD_DEFINED__ */ +#ifndef __ID3D12Tools1_FWD_DEFINED__ +#define __ID3D12Tools1_FWD_DEFINED__ +typedef interface ID3D12Tools1 ID3D12Tools1; + +#endif /* __ID3D12Tools1_FWD_DEFINED__ */ + + +#ifndef __ID3D12Tools2_FWD_DEFINED__ +#define __ID3D12Tools2_FWD_DEFINED__ +typedef interface ID3D12Tools2 ID3D12Tools2; + +#endif /* __ID3D12Tools2_FWD_DEFINED__ */ + + +#ifndef __ID3D12PageableTools_FWD_DEFINED__ +#define __ID3D12PageableTools_FWD_DEFINED__ +typedef interface ID3D12PageableTools ID3D12PageableTools; + +#endif /* __ID3D12PageableTools_FWD_DEFINED__ */ + + +#ifndef __ID3D12DeviceTools_FWD_DEFINED__ +#define __ID3D12DeviceTools_FWD_DEFINED__ +typedef interface ID3D12DeviceTools ID3D12DeviceTools; + +#endif /* __ID3D12DeviceTools_FWD_DEFINED__ */ + + +#ifndef __ID3D12DeviceTools1_FWD_DEFINED__ +#define __ID3D12DeviceTools1_FWD_DEFINED__ +typedef interface ID3D12DeviceTools1 ID3D12DeviceTools1; + +#endif /* __ID3D12DeviceTools1_FWD_DEFINED__ */ + + #ifndef __ID3D12SDKConfiguration_FWD_DEFINED__ #define __ID3D12SDKConfiguration_FWD_DEFINED__ typedef interface ID3D12SDKConfiguration ID3D12SDKConfiguration; @@ -479,6 +577,20 @@ typedef interface ID3D12DeviceConfiguration ID3D12DeviceConfiguration; #endif /* __ID3D12DeviceConfiguration_FWD_DEFINED__ */ +#ifndef __ID3D12DeviceConfiguration1_FWD_DEFINED__ +#define __ID3D12DeviceConfiguration1_FWD_DEFINED__ +typedef interface ID3D12DeviceConfiguration1 ID3D12DeviceConfiguration1; + +#endif /* __ID3D12DeviceConfiguration1_FWD_DEFINED__ */ + + +#ifndef __ID3D12StateObjectDatabaseFactory_FWD_DEFINED__ +#define __ID3D12StateObjectDatabaseFactory_FWD_DEFINED__ +typedef interface ID3D12StateObjectDatabaseFactory ID3D12StateObjectDatabaseFactory; + +#endif /* __ID3D12StateObjectDatabaseFactory_FWD_DEFINED__ */ + + #ifndef __ID3D12GraphicsCommandList5_FWD_DEFINED__ #define __ID3D12GraphicsCommandList5_FWD_DEFINED__ typedef interface ID3D12GraphicsCommandList5 ID3D12GraphicsCommandList5; @@ -507,6 +619,34 @@ typedef interface ID3D12GraphicsCommandList8 ID3D12GraphicsCommandList8; #endif /* __ID3D12GraphicsCommandList8_FWD_DEFINED__ */ +#ifndef __ID3D12GraphicsCommandList9_FWD_DEFINED__ +#define __ID3D12GraphicsCommandList9_FWD_DEFINED__ +typedef interface ID3D12GraphicsCommandList9 ID3D12GraphicsCommandList9; + +#endif /* __ID3D12GraphicsCommandList9_FWD_DEFINED__ */ + + +#ifndef __ID3D12GraphicsCommandList10_FWD_DEFINED__ +#define __ID3D12GraphicsCommandList10_FWD_DEFINED__ +typedef interface ID3D12GraphicsCommandList10 ID3D12GraphicsCommandList10; + +#endif /* __ID3D12GraphicsCommandList10_FWD_DEFINED__ */ + + +#ifndef __ID3D12DSRDeviceFactory_FWD_DEFINED__ +#define __ID3D12DSRDeviceFactory_FWD_DEFINED__ +typedef interface ID3D12DSRDeviceFactory ID3D12DSRDeviceFactory; + +#endif /* __ID3D12DSRDeviceFactory_FWD_DEFINED__ */ + + +#ifndef __ID3D12GBVDiagnostics_FWD_DEFINED__ +#define __ID3D12GBVDiagnostics_FWD_DEFINED__ +typedef interface ID3D12GBVDiagnostics ID3D12GBVDiagnostics; + +#endif /* __ID3D12GBVDiagnostics_FWD_DEFINED__ */ + + /* header files for imported files */ #include "oaidl.h" #include "ocidl.h" @@ -523,7 +663,7 @@ extern "C"{ /* [local] */ #include -//#pragma region App Family +#pragma region App Family #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) #ifndef _D3D12_CONSTANTS #define _D3D12_CONSTANTS @@ -1039,7 +1179,7 @@ extern "C"{ #define D3D12_PIXEL_ADDRESS_RANGE_BIT_COUNT ( 15 ) -#define D3D12_PREVIEW_SDK_VERSION ( 706 ) +#define D3D12_PREVIEW_SDK_VERSION ( 717 ) #define D3D12_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT ( 16 ) @@ -1109,6 +1249,10 @@ extern "C"{ #define D3D12_RAYTRACING_MAX_SHADER_RECORD_STRIDE ( 4096 ) +#define D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_BYTE_ALIGNMENT ( 128 ) + +#define D3D12_RAYTRACING_OPACITY_MICROMAP_OC1_MAX_SUBDIVISION_LEVEL ( 12 ) + #define D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT ( 32 ) #define D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT ( 64 ) @@ -1172,7 +1316,7 @@ extern "C"{ #define D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT ( 2 ) -#define D3D12_SDK_VERSION ( 606 ) +#define D3D12_SDK_VERSION ( 618 ) #define D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES ( 32 ) @@ -1270,6 +1414,10 @@ extern "C"{ #define D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT ( 512 ) +#define D3D12_TIGHT_ALIGNMENT_MIN_COMMITTED_RESOURCE_ALIGNMENT ( 4096 ) + +#define D3D12_TIGHT_ALIGNMENT_MIN_PLACED_RESOURCE_ALIGNMENT ( 8 ) + #define D3D12_TILED_RESOURCE_TILE_SIZE_IN_BYTES ( 65536 ) #define D3D12_TRACKED_WORKLOAD_MAX_INSTANCES ( 32 ) @@ -1290,6 +1438,16 @@ extern "C"{ #define D3D12_VIDEO_DECODE_STATUS_MACROBLOCKS_AFFECTED_UNKNOWN ( 0xffffffff ) +#define D3D12_VIDEO_ENCODER_AV1_INVALID_DPB_RESOURCE_INDEX ( 0xff ) + +#define D3D12_VIDEO_ENCODER_AV1_MAX_TILE_COLS ( 64 ) + +#define D3D12_VIDEO_ENCODER_AV1_MAX_TILE_ROWS ( 64 ) + +#define D3D12_VIDEO_ENCODER_AV1_SUPERRES_DENOM_MIN ( 9 ) + +#define D3D12_VIDEO_ENCODER_AV1_SUPERRES_NUM ( 8 ) + #define D3D12_VIDEO_PROCESS_MAX_FILTERS ( 32 ) #define D3D12_VIDEO_PROCESS_STEREO_VIEWS ( 2 ) @@ -1324,6 +1482,10 @@ extern "C"{ #define D3D12_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP ( 25 ) +#define D3D12_WORK_GRAPHS_BACKING_MEMORY_ALIGNMENT_IN_BYTES ( 8 ) + +#define D3D12_WORK_GRAPHS_MAX_NODE_DEPTH ( 32 ) + #endif typedef UINT64 D3D12_GPU_VIRTUAL_ADDRESS; @@ -1345,10 +1507,11 @@ typedef enum D3D12_COMMAND_QUEUE_FLAGS { D3D12_COMMAND_QUEUE_FLAG_NONE = 0, - D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT = 0x1 + D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT = 0x1, + D3D12_COMMAND_QUEUE_FLAG_ALLOW_DYNAMIC_PRIORITY = 0x2 } D3D12_COMMAND_QUEUE_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_QUEUE_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_QUEUE_FLAGS ) typedef enum D3D12_COMMAND_QUEUE_PRIORITY { @@ -1444,6 +1607,19 @@ typedef struct D3D12_BOX UINT back; } D3D12_BOX; +#ifdef __midl +#ifndef LUID_DEFINED +#define LUID_DEFINED 1 +typedef struct __LUID + { + DWORD LowPart; + LONG HighPart; + } LUID; + +typedef struct __LUID *PLUID; + +#endif +#endif typedef enum D3D12_COMPARISON_FUNC { @@ -1642,6 +1818,44 @@ typedef struct D3D12_RASTERIZER_DESC D3D12_CONSERVATIVE_RASTERIZATION_MODE ConservativeRaster; } D3D12_RASTERIZER_DESC; +typedef struct D3D12_RASTERIZER_DESC1 + { + D3D12_FILL_MODE FillMode; + D3D12_CULL_MODE CullMode; + BOOL FrontCounterClockwise; + FLOAT DepthBias; + FLOAT DepthBiasClamp; + FLOAT SlopeScaledDepthBias; + BOOL DepthClipEnable; + BOOL MultisampleEnable; + BOOL AntialiasedLineEnable; + UINT ForcedSampleCount; + D3D12_CONSERVATIVE_RASTERIZATION_MODE ConservativeRaster; + } D3D12_RASTERIZER_DESC1; + +typedef +enum D3D12_LINE_RASTERIZATION_MODE + { + D3D12_LINE_RASTERIZATION_MODE_ALIASED = 0, + D3D12_LINE_RASTERIZATION_MODE_ALPHA_ANTIALIASED = ( D3D12_LINE_RASTERIZATION_MODE_ALIASED + 1 ) , + D3D12_LINE_RASTERIZATION_MODE_QUADRILATERAL_WIDE = ( D3D12_LINE_RASTERIZATION_MODE_ALPHA_ANTIALIASED + 1 ) , + D3D12_LINE_RASTERIZATION_MODE_QUADRILATERAL_NARROW = ( D3D12_LINE_RASTERIZATION_MODE_QUADRILATERAL_WIDE + 1 ) + } D3D12_LINE_RASTERIZATION_MODE; + +typedef struct D3D12_RASTERIZER_DESC2 + { + D3D12_FILL_MODE FillMode; + D3D12_CULL_MODE CullMode; + BOOL FrontCounterClockwise; + FLOAT DepthBias; + FLOAT DepthBiasClamp; + FLOAT SlopeScaledDepthBias; + BOOL DepthClipEnable; + D3D12_LINE_RASTERIZATION_MODE LineRasterizationMode; + UINT ForcedSampleCount; + D3D12_CONSERVATIVE_RASTERIZATION_MODE ConservativeRaster; + } D3D12_RASTERIZER_DESC2; + extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0000_v0_0_c_ifspec; @@ -2048,6 +2262,13 @@ enum D3D12_INDEX_BUFFER_STRIP_CUT_VALUE D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFFFFFF = 2 } D3D12_INDEX_BUFFER_STRIP_CUT_VALUE; +typedef +enum D3D12_STANDARD_MULTISAMPLE_QUALITY_LEVELS + { + D3D12_STANDARD_MULTISAMPLE_PATTERN = 0xffffffff, + D3D12_CENTER_MULTISAMPLE_PATTERN = 0xfffffffe + } D3D12_STANDARD_MULTISAMPLE_QUALITY_LEVELS; + typedef struct D3D12_CACHED_PIPELINE_STATE { _Field_size_bytes_full_(CachedBlobSizeInBytes) const void *pCachedBlob; @@ -2058,10 +2279,12 @@ typedef enum D3D12_PIPELINE_STATE_FLAGS { D3D12_PIPELINE_STATE_FLAG_NONE = 0, - D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG = 0x1 + D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG = 0x1, + D3D12_PIPELINE_STATE_FLAG_DYNAMIC_DEPTH_BIAS = 0x4, + D3D12_PIPELINE_STATE_FLAG_DYNAMIC_INDEX_BUFFER_STRIP_CUT = 0x8 } D3D12_PIPELINE_STATE_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_PIPELINE_STATE_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_PIPELINE_STATE_FLAGS ) typedef struct D3D12_GRAPHICS_PIPELINE_STATE_DESC { ID3D12RootSignature *pRootSignature; @@ -2096,6 +2319,31 @@ typedef struct D3D12_COMPUTE_PIPELINE_STATE_DESC D3D12_PIPELINE_STATE_FLAGS Flags; } D3D12_COMPUTE_PIPELINE_STATE_DESC; +typedef +enum D3D_ROOT_SIGNATURE_VERSION + { + D3D_ROOT_SIGNATURE_VERSION_1 = 0x1, + D3D_ROOT_SIGNATURE_VERSION_1_0 = 0x1, + D3D_ROOT_SIGNATURE_VERSION_1_1 = 0x2, + D3D_ROOT_SIGNATURE_VERSION_1_2 = 0x3 + } D3D_ROOT_SIGNATURE_VERSION; + +typedef struct D3D12_SERIALIZED_ROOT_SIGNATURE_DESC + { + _Field_size_bytes_full_(SerializedBlobSizeInBytes) const void *pSerializedBlob; + SIZE_T SerializedBlobSizeInBytes; + } D3D12_SERIALIZED_ROOT_SIGNATURE_DESC; + +typedef struct D3D12_GLOBAL_SERIALIZED_ROOT_SIGNATURE + { + D3D12_SERIALIZED_ROOT_SIGNATURE_DESC Desc; + } D3D12_GLOBAL_SERIALIZED_ROOT_SIGNATURE; + +typedef struct D3D12_LOCAL_SERIALIZED_ROOT_SIGNATURE + { + D3D12_SERIALIZED_ROOT_SIGNATURE_DESC Desc; + } D3D12_LOCAL_SERIALIZED_ROOT_SIGNATURE; + struct D3D12_RT_FORMAT_ARRAY { DXGI_FORMAT RTFormats[ 8 ]; @@ -2136,7 +2384,10 @@ enum D3D12_PIPELINE_STATE_SUBOBJECT_TYPE D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS = 24, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS = 25, D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL2 = 26, - D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL2 + 1 ) + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER1 = 27, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER2 = 28, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SERIALIZED_ROOT_SIGNATURE = 29, + D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID = ( D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SERIALIZED_ROOT_SIGNATURE + 1 ) } D3D12_PIPELINE_STATE_SUBOBJECT_TYPE; typedef @@ -2176,7 +2427,20 @@ enum D3D12_FEATURE D3D12_FEATURE_D3D12_OPTIONS12 = 41, D3D12_FEATURE_D3D12_OPTIONS13 = 42, D3D12_FEATURE_D3D12_OPTIONS14 = 43, - D3D12_FEATURE_D3D12_OPTIONS15 = 44 + D3D12_FEATURE_D3D12_OPTIONS15 = 44, + D3D12_FEATURE_D3D12_OPTIONS16 = 45, + D3D12_FEATURE_D3D12_OPTIONS17 = 46, + D3D12_FEATURE_D3D12_OPTIONS18 = 47, + D3D12_FEATURE_D3D12_OPTIONS19 = 48, + D3D12_FEATURE_D3D12_OPTIONS20 = 49, + D3D12_FEATURE_PREDICATION = 50, + D3D12_FEATURE_PLACED_RESOURCE_SUPPORT_INFO = 51, + D3D12_FEATURE_HARDWARE_COPY = 52, + D3D12_FEATURE_D3D12_OPTIONS21 = 53, + D3D12_FEATURE_D3D12_TIGHT_ALIGNMENT = 54, + D3D12_FEATURE_APPLICATION_SPECIFIC_DRIVER_STATE = 56, + D3D12_FEATURE_BYTECODE_BYPASS_HASH_SUPPORTED = 57, + D3D12_FEATURE_SHADER_CACHE_ABI_SUPPORT = 61 } D3D12_FEATURE; typedef @@ -2187,7 +2451,7 @@ enum D3D12_SHADER_MIN_PRECISION_SUPPORT D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT = 0x2 } D3D12_SHADER_MIN_PRECISION_SUPPORT; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_MIN_PRECISION_SUPPORT ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_MIN_PRECISION_SUPPORT ) typedef enum D3D12_TILED_RESOURCES_TIER { @@ -2250,7 +2514,7 @@ enum D3D12_FORMAT_SUPPORT1 D3D12_FORMAT_SUPPORT1_VIDEO_ENCODER = 0x40000000 } D3D12_FORMAT_SUPPORT1; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT1 ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT1 ) typedef enum D3D12_FORMAT_SUPPORT2 { @@ -2266,10 +2530,11 @@ enum D3D12_FORMAT_SUPPORT2 D3D12_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP = 0x100, D3D12_FORMAT_SUPPORT2_TILED = 0x200, D3D12_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY = 0x4000, - D3D12_FORMAT_SUPPORT2_SAMPLER_FEEDBACK = 0x8000 + D3D12_FORMAT_SUPPORT2_SAMPLER_FEEDBACK = 0x8000, + D3D12_FORMAT_SUPPORT2_DISPLAYABLE = 0x10000 } D3D12_FORMAT_SUPPORT2; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT2 ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_FORMAT_SUPPORT2 ) typedef enum D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS { @@ -2277,7 +2542,7 @@ enum D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_TILED_RESOURCE = 0x1 } D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS ) typedef enum D3D12_CROSS_NODE_SHARING_TIER { @@ -2312,6 +2577,13 @@ enum D3D12_VIEW_INSTANCING_TIER D3D12_VIEW_INSTANCING_TIER_3 = 3 } D3D12_VIEW_INSTANCING_TIER; +typedef +enum D3D12_WORK_GRAPHS_TIER + { + D3D12_WORK_GRAPHS_TIER_NOT_SUPPORTED = 0, + D3D12_WORK_GRAPHS_TIER_1_0 = 10 + } D3D12_WORK_GRAPHS_TIER; + typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS { _Out_ BOOL DoublePrecisionFloatShaderOps; @@ -2347,14 +2619,6 @@ typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS2 _Out_ D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER ProgrammableSamplePositionsTier; } D3D12_FEATURE_DATA_D3D12_OPTIONS2; -typedef -enum D3D_ROOT_SIGNATURE_VERSION - { - D3D_ROOT_SIGNATURE_VERSION_1 = 0x1, - D3D_ROOT_SIGNATURE_VERSION_1_0 = 0x1, - D3D_ROOT_SIGNATURE_VERSION_1_1 = 0x2 - } D3D_ROOT_SIGNATURE_VERSION; - typedef struct D3D12_FEATURE_DATA_ROOT_SIGNATURE { _Inout_ D3D_ROOT_SIGNATURE_VERSION HighestVersion; @@ -2387,6 +2651,7 @@ typedef struct D3D12_FEATURE_DATA_FEATURE_LEVELS typedef enum D3D_SHADER_MODEL { + D3D_SHADER_MODEL_NONE = 0, D3D_SHADER_MODEL_5_1 = 0x51, D3D_SHADER_MODEL_6_0 = 0x60, D3D_SHADER_MODEL_6_1 = 0x61, @@ -2397,7 +2662,8 @@ enum D3D_SHADER_MODEL D3D_SHADER_MODEL_6_6 = 0x66, D3D_SHADER_MODEL_6_7 = 0x67, D3D_SHADER_MODEL_6_8 = 0x68, - D3D_HIGHEST_SHADER_MODEL = D3D_SHADER_MODEL_6_8 + D3D_SHADER_MODEL_6_9 = 0x69, + D3D_HIGHEST_SHADER_MODEL = D3D_SHADER_MODEL_6_9 } D3D_SHADER_MODEL; typedef struct D3D12_FEATURE_DATA_SHADER_MODEL @@ -2445,7 +2711,7 @@ enum D3D12_SHADER_CACHE_SUPPORT_FLAGS D3D12_SHADER_CACHE_SUPPORT_SHADER_SESSION_DELETE = 0x40 } D3D12_SHADER_CACHE_SUPPORT_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_SUPPORT_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_SUPPORT_FLAGS ) typedef struct D3D12_FEATURE_DATA_SHADER_CACHE { _Out_ D3D12_SHADER_CACHE_SUPPORT_FLAGS SupportFlags; @@ -2471,7 +2737,7 @@ enum D3D12_COMMAND_LIST_SUPPORT_FLAGS D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_ENCODE = ( 1 << D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE ) } D3D12_COMMAND_LIST_SUPPORT_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_SUPPORT_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_SUPPORT_FLAGS ) typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS3 { _Out_ BOOL CopyQueueTimestampQueriesSupported; @@ -2539,7 +2805,8 @@ enum D3D12_RAYTRACING_TIER { D3D12_RAYTRACING_TIER_NOT_SUPPORTED = 0, D3D12_RAYTRACING_TIER_1_0 = 10, - D3D12_RAYTRACING_TIER_1_1 = 11 + D3D12_RAYTRACING_TIER_1_1 = 11, + D3D12_RAYTRACING_TIER_1_2 = 12 } D3D12_RAYTRACING_TIER; typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS5 @@ -2668,6 +2935,97 @@ typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS15 _Out_ BOOL DynamicIndexBufferStripCutSupported; } D3D12_FEATURE_DATA_D3D12_OPTIONS15; +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS16 + { + _Out_ BOOL DynamicDepthBiasSupported; + _Out_ BOOL GPUUploadHeapSupported; + } D3D12_FEATURE_DATA_D3D12_OPTIONS16; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS17 + { + _Out_ BOOL NonNormalizedCoordinateSamplersSupported; + _Out_ BOOL ManualWriteTrackingResourceSupported; + } D3D12_FEATURE_DATA_D3D12_OPTIONS17; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS18 + { + _Out_ BOOL RenderPassesValid; + } D3D12_FEATURE_DATA_D3D12_OPTIONS18; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS19 + { + BOOL MismatchingOutputDimensionsSupported; + UINT SupportedSampleCountsWithNoOutputs; + BOOL PointSamplingAddressesNeverRoundUp; + BOOL RasterizerDesc2Supported; + BOOL NarrowQuadrilateralLinesSupported; + BOOL AnisoFilterWithPointMipSupported; + UINT MaxSamplerDescriptorHeapSize; + UINT MaxSamplerDescriptorHeapSizeWithStaticSamplers; + UINT MaxViewDescriptorHeapSize; + _Out_ BOOL ComputeOnlyCustomHeapSupported; + } D3D12_FEATURE_DATA_D3D12_OPTIONS19; + +typedef +enum D3D12_RECREATE_AT_TIER + { + D3D12_RECREATE_AT_TIER_NOT_SUPPORTED = 0, + D3D12_RECREATE_AT_TIER_1 = 1 + } D3D12_RECREATE_AT_TIER; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS20 + { + _Out_ BOOL ComputeOnlyWriteWatchSupported; + D3D12_RECREATE_AT_TIER RecreateAtTier; + } D3D12_FEATURE_DATA_D3D12_OPTIONS20; + +typedef +enum D3D12_EXECUTE_INDIRECT_TIER + { + D3D12_EXECUTE_INDIRECT_TIER_1_0 = 10, + D3D12_EXECUTE_INDIRECT_TIER_1_1 = 11 + } D3D12_EXECUTE_INDIRECT_TIER; + +typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS21 + { + _Out_ D3D12_WORK_GRAPHS_TIER WorkGraphsTier; + _Out_ D3D12_EXECUTE_INDIRECT_TIER ExecuteIndirectTier; + _Out_ BOOL SampleCmpGradientAndBiasSupported; + _Out_ BOOL ExtendedCommandInfoSupported; + } D3D12_FEATURE_DATA_D3D12_OPTIONS21; + +typedef +enum D3D12_TIGHT_ALIGNMENT_TIER + { + D3D12_TIGHT_ALIGNMENT_TIER_NOT_SUPPORTED = 0, + D3D12_TIGHT_ALIGNMENT_TIER_1 = ( D3D12_TIGHT_ALIGNMENT_TIER_NOT_SUPPORTED + 1 ) + } D3D12_TIGHT_ALIGNMENT_TIER; + +typedef struct D3D12_FEATURE_DATA_TIGHT_ALIGNMENT + { + _Out_ D3D12_TIGHT_ALIGNMENT_TIER SupportTier; + } D3D12_FEATURE_DATA_TIGHT_ALIGNMENT; + +typedef struct D3D12_FEATURE_DATA_PREDICATION + { + _Out_ BOOL Supported; + } D3D12_FEATURE_DATA_PREDICATION; + +typedef struct D3D12_FEATURE_DATA_HARDWARE_COPY + { + _Out_ BOOL Supported; + } D3D12_FEATURE_DATA_HARDWARE_COPY; + +typedef struct D3D12_FEATURE_DATA_APPLICATION_SPECIFIC_DRIVER_STATE + { + _Out_ BOOL Supported; + } D3D12_FEATURE_DATA_APPLICATION_SPECIFIC_DRIVER_STATE; + +typedef struct D3D12_FEATURE_DATA_BYTECODE_BYPASS_HASH_SUPPORTED + { + _Out_ BOOL Supported; + } D3D12_FEATURE_DATA_BYTECODE_BYPASS_HASH_SUPPORTED; + typedef struct D3D12_RESOURCE_ALLOCATION_INFO { UINT64 SizeInBytes; @@ -2687,7 +3045,8 @@ enum D3D12_HEAP_TYPE D3D12_HEAP_TYPE_DEFAULT = 1, D3D12_HEAP_TYPE_UPLOAD = 2, D3D12_HEAP_TYPE_READBACK = 3, - D3D12_HEAP_TYPE_CUSTOM = 4 + D3D12_HEAP_TYPE_CUSTOM = 4, + D3D12_HEAP_TYPE_GPU_UPLOAD = 5 } D3D12_HEAP_TYPE; typedef @@ -2731,13 +3090,14 @@ enum D3D12_HEAP_FLAGS D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS = 0x400, D3D12_HEAP_FLAG_CREATE_NOT_RESIDENT = 0x800, D3D12_HEAP_FLAG_CREATE_NOT_ZEROED = 0x1000, + D3D12_HEAP_FLAG_TOOLS_USE_MANUAL_WRITE_TRACKING = 0x2000, D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES = 0, D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS = 0xc0, D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES = 0x44, D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES = 0x84 } D3D12_HEAP_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_HEAP_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_HEAP_FLAGS ) typedef struct D3D12_HEAP_DESC { UINT64 SizeInBytes; @@ -2756,6 +3116,14 @@ enum D3D12_RESOURCE_DIMENSION D3D12_RESOURCE_DIMENSION_TEXTURE3D = 4 } D3D12_RESOURCE_DIMENSION; +typedef struct D3D12_FEATURE_DATA_PLACED_RESOURCE_SUPPORT_INFO + { + _In_ DXGI_FORMAT Format; + _In_ D3D12_RESOURCE_DIMENSION Dimension; + _In_ D3D12_HEAP_PROPERTIES DestHeapProperties; + _Out_ BOOL Supported; + } D3D12_FEATURE_DATA_PLACED_RESOURCE_SUPPORT_INFO; + typedef enum D3D12_TEXTURE_LAYOUT { @@ -2777,10 +3145,11 @@ enum D3D12_RESOURCE_FLAGS D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS = 0x20, D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY = 0x40, D3D12_RESOURCE_FLAG_VIDEO_ENCODE_REFERENCE_ONLY = 0x80, - D3D12_RESOURCE_FLAG_RAYTRACING_ACCELERATION_STRUCTURE = 0x100 + D3D12_RESOURCE_FLAG_RAYTRACING_ACCELERATION_STRUCTURE = 0x100, + D3D12_RESOURCE_FLAG_USE_TIGHT_ALIGNMENT = 0x400 } D3D12_RESOURCE_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_FLAGS ) typedef struct D3D12_MIP_REGION { UINT Width; @@ -2914,7 +3283,7 @@ enum D3D12_TILE_MAPPING_FLAGS D3D12_TILE_MAPPING_FLAG_NO_HAZARD = 0x1 } D3D12_TILE_MAPPING_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_MAPPING_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_MAPPING_FLAGS ) typedef enum D3D12_TILE_COPY_FLAGS { @@ -2924,7 +3293,7 @@ enum D3D12_TILE_COPY_FLAGS D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = 0x4 } D3D12_TILE_COPY_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_COPY_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_TILE_COPY_FLAGS ) typedef enum D3D12_RESOURCE_STATES { @@ -2945,6 +3314,11 @@ enum D3D12_RESOURCE_STATES D3D12_RESOURCE_STATE_RESOLVE_SOURCE = 0x2000, D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE = 0x400000, D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE = 0x1000000, + D3D12_RESOURCE_STATE_RESERVED_INTERNAL_8000 = 0x8000, + D3D12_RESOURCE_STATE_RESERVED_INTERNAL_4000 = 0x4000, + D3D12_RESOURCE_STATE_RESERVED_INTERNAL_100000 = 0x100000, + D3D12_RESOURCE_STATE_RESERVED_INTERNAL_40000000 = 0x40000000, + D3D12_RESOURCE_STATE_RESERVED_INTERNAL_80000000 = 0x80000000, D3D12_RESOURCE_STATE_GENERIC_READ = ( ( ( ( ( 0x1 | 0x2 ) | 0x40 ) | 0x80 ) | 0x200 ) | 0x800 ) , D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE = ( 0x40 | 0x80 ) , D3D12_RESOURCE_STATE_PRESENT = 0, @@ -2957,7 +3331,7 @@ enum D3D12_RESOURCE_STATES D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE = 0x800000 } D3D12_RESOURCE_STATES; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_STATES ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_STATES ) typedef enum D3D12_RESOURCE_BARRIER_TYPE { @@ -2994,7 +3368,7 @@ enum D3D12_RESOURCE_BARRIER_FLAGS D3D12_RESOURCE_BARRIER_FLAG_END_ONLY = 0x2 } D3D12_RESOURCE_BARRIER_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_BARRIER_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESOURCE_BARRIER_FLAGS ) typedef struct D3D12_RESOURCE_BARRIER { D3D12_RESOURCE_BARRIER_TYPE Type; @@ -3070,7 +3444,7 @@ enum D3D12_VIEW_INSTANCING_FLAGS D3D12_VIEW_INSTANCING_FLAG_ENABLE_VIEW_INSTANCE_MASKING = 0x1 } D3D12_VIEW_INSTANCING_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIEW_INSTANCING_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIEW_INSTANCING_FLAGS ) typedef struct D3D12_VIEW_INSTANCING_DESC { UINT ViewInstanceCount; @@ -3106,7 +3480,7 @@ enum D3D12_BUFFER_SRV_FLAGS D3D12_BUFFER_SRV_FLAG_RAW = 0x1 } D3D12_BUFFER_SRV_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_SRV_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_SRV_FLAGS ) typedef struct D3D12_BUFFER_SRV { UINT64 FirstElement; @@ -3243,6 +3617,7 @@ enum D3D12_FILTER D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11, D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14, D3D12_FILTER_MIN_MAG_MIP_LINEAR = 0x15, + D3D12_FILTER_MIN_MAG_ANISOTROPIC_MIP_POINT = 0x54, D3D12_FILTER_ANISOTROPIC = 0x55, D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 0x80, D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81, @@ -3252,6 +3627,7 @@ enum D3D12_FILTER D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91, D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94, D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 0x95, + D3D12_FILTER_COMPARISON_MIN_MAG_ANISOTROPIC_MIP_POINT = 0xd4, D3D12_FILTER_COMPARISON_ANISOTROPIC = 0xd5, D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT = 0x100, D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x101, @@ -3261,6 +3637,7 @@ enum D3D12_FILTER D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x111, D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x114, D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR = 0x115, + D3D12_FILTER_MINIMUM_MIN_MAG_ANISOTROPIC_MIP_POINT = 0x154, D3D12_FILTER_MINIMUM_ANISOTROPIC = 0x155, D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT = 0x180, D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x181, @@ -3270,6 +3647,7 @@ enum D3D12_FILTER D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x191, D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x194, D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR = 0x195, + D3D12_FILTER_MAXIMUM_MIN_MAG_ANISOTROPIC_MIP_POINT = 0x1d4, D3D12_FILTER_MAXIMUM_ANISOTROPIC = 0x1d5 } D3D12_FILTER; @@ -3316,6 +3694,13 @@ enum D3D12_FILTER_REDUCTION_TYPE D3D12_FILTER_TYPE_LINEAR, \ D3D12_FILTER_TYPE_LINEAR, \ reduction ) ) ) +#define D3D12_ENCODE_MIN_MAG_ANISOTROPIC_MIP_POINT_FILTER( reduction ) \ + ( ( D3D12_FILTER ) ( \ + D3D12_ANISOTROPIC_FILTERING_BIT | \ + D3D12_ENCODE_BASIC_FILTER( D3D12_FILTER_TYPE_LINEAR, \ + D3D12_FILTER_TYPE_LINEAR, \ + D3D12_FILTER_TYPE_POINT, \ + reduction ) ) ) #define D3D12_DECODE_MIN_FILTER( D3D12Filter ) \ ( ( D3D12_FILTER_TYPE ) \ ( ( ( D3D12Filter ) >> D3D12_MIN_FILTER_SHIFT ) & D3D12_FILTER_TYPE_MASK ) ) @@ -3333,8 +3718,7 @@ enum D3D12_FILTER_REDUCTION_TYPE #define D3D12_DECODE_IS_ANISOTROPIC_FILTER( D3D12Filter ) \ ( ( ( D3D12Filter ) & D3D12_ANISOTROPIC_FILTERING_BIT ) && \ ( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MIN_FILTER( D3D12Filter ) ) && \ - ( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MAG_FILTER( D3D12Filter ) ) && \ - ( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MIP_FILTER( D3D12Filter ) ) ) + ( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MAG_FILTER( D3D12Filter ) ) ) typedef enum D3D12_TEXTURE_ADDRESS_MODE { @@ -3363,10 +3747,11 @@ typedef enum D3D12_SAMPLER_FLAGS { D3D12_SAMPLER_FLAG_NONE = 0, - D3D12_SAMPLER_FLAG_UINT_BORDER_COLOR = 0x1 + D3D12_SAMPLER_FLAG_UINT_BORDER_COLOR = 0x1, + D3D12_SAMPLER_FLAG_NON_NORMALIZED_COORDINATES = 0x2 } D3D12_SAMPLER_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_SAMPLER_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_SAMPLER_FLAGS ) typedef struct D3D12_SAMPLER_DESC2 { D3D12_FILTER Filter; @@ -3393,7 +3778,7 @@ enum D3D12_BUFFER_UAV_FLAGS D3D12_BUFFER_UAV_FLAG_RAW = 0x1 } D3D12_BUFFER_UAV_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_UAV_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_BUFFER_UAV_FLAGS ) typedef struct D3D12_BUFFER_UAV { UINT64 FirstElement; @@ -3602,7 +3987,7 @@ enum D3D12_DSV_FLAGS D3D12_DSV_FLAG_READ_ONLY_STENCIL = 0x2 } D3D12_DSV_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_DSV_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_DSV_FLAGS ) typedef enum D3D12_DSV_DIMENSION { @@ -3638,7 +4023,7 @@ enum D3D12_CLEAR_FLAGS D3D12_CLEAR_FLAG_STENCIL = 0x2 } D3D12_CLEAR_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_CLEAR_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_CLEAR_FLAGS ) typedef enum D3D12_FENCE_FLAGS { @@ -3648,7 +4033,7 @@ enum D3D12_FENCE_FLAGS D3D12_FENCE_FLAG_NON_MONITORED = 0x4 } D3D12_FENCE_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_FENCE_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_FENCE_FLAGS ) typedef enum D3D12_DESCRIPTOR_HEAP_TYPE { @@ -3666,7 +4051,7 @@ enum D3D12_DESCRIPTOR_HEAP_FLAGS D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE = 0x1 } D3D12_DESCRIPTOR_HEAP_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_HEAP_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_HEAP_FLAGS ) typedef struct D3D12_DESCRIPTOR_HEAP_DESC { D3D12_DESCRIPTOR_HEAP_TYPE Type; @@ -3765,7 +4150,7 @@ enum D3D12_ROOT_SIGNATURE_FLAGS D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED = 0x800 } D3D12_ROOT_SIGNATURE_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_SIGNATURE_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_SIGNATURE_FLAGS ) typedef enum D3D12_STATIC_BORDER_COLOR { @@ -3793,6 +4178,24 @@ typedef struct D3D12_STATIC_SAMPLER_DESC D3D12_SHADER_VISIBILITY ShaderVisibility; } D3D12_STATIC_SAMPLER_DESC; +typedef struct D3D12_STATIC_SAMPLER_DESC1 + { + D3D12_FILTER Filter; + D3D12_TEXTURE_ADDRESS_MODE AddressU; + D3D12_TEXTURE_ADDRESS_MODE AddressV; + D3D12_TEXTURE_ADDRESS_MODE AddressW; + FLOAT MipLODBias; + UINT MaxAnisotropy; + D3D12_COMPARISON_FUNC ComparisonFunc; + D3D12_STATIC_BORDER_COLOR BorderColor; + FLOAT MinLOD; + FLOAT MaxLOD; + UINT ShaderRegister; + UINT RegisterSpace; + D3D12_SHADER_VISIBILITY ShaderVisibility; + D3D12_SAMPLER_FLAGS Flags; + } D3D12_STATIC_SAMPLER_DESC1; + typedef struct D3D12_ROOT_SIGNATURE_DESC { UINT NumParameters; @@ -3813,7 +4216,7 @@ enum D3D12_DESCRIPTOR_RANGE_FLAGS D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS = 0x10000 } D3D12_DESCRIPTOR_RANGE_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_RANGE_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_DESCRIPTOR_RANGE_FLAGS ) typedef struct D3D12_DESCRIPTOR_RANGE1 { D3D12_DESCRIPTOR_RANGE_TYPE RangeType; @@ -3839,7 +4242,7 @@ enum D3D12_ROOT_DESCRIPTOR_FLAGS D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC = 0x8 } D3D12_ROOT_DESCRIPTOR_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_DESCRIPTOR_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_ROOT_DESCRIPTOR_FLAGS ) typedef struct D3D12_ROOT_DESCRIPTOR1 { UINT ShaderRegister; @@ -3868,6 +4271,15 @@ typedef struct D3D12_ROOT_SIGNATURE_DESC1 D3D12_ROOT_SIGNATURE_FLAGS Flags; } D3D12_ROOT_SIGNATURE_DESC1; +typedef struct D3D12_ROOT_SIGNATURE_DESC2 + { + UINT NumParameters; + _Field_size_full_(NumParameters) const D3D12_ROOT_PARAMETER1 *pParameters; + UINT NumStaticSamplers; + _Field_size_full_(NumStaticSamplers) const D3D12_STATIC_SAMPLER_DESC1 *pStaticSamplers; + D3D12_ROOT_SIGNATURE_FLAGS Flags; + } D3D12_ROOT_SIGNATURE_DESC2; + typedef struct D3D12_VERSIONED_ROOT_SIGNATURE_DESC { D3D_ROOT_SIGNATURE_VERSION Version; @@ -3875,6 +4287,7 @@ typedef struct D3D12_VERSIONED_ROOT_SIGNATURE_DESC { D3D12_ROOT_SIGNATURE_DESC Desc_1_0; D3D12_ROOT_SIGNATURE_DESC1 Desc_1_1; + D3D12_ROOT_SIGNATURE_DESC2 Desc_1_2; } ; } D3D12_VERSIONED_ROOT_SIGNATURE_DESC; @@ -4107,6 +4520,20 @@ HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer( _In_ REFIID pRootSignatureDeserializerInterface, _Out_ void** ppRootSignatureDeserializer); +typedef HRESULT (WINAPI* PFN_D3D12_CREATE_VERSIONED_ROOT_SIGNATURE_DESERIALIZER_FROM_SUBOBJECT_IN_LIBRARY)( + _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData, + _In_ SIZE_T SrcDataSizeInBytes, + _In_ LPCWSTR RootSignatureSubobjectName, + _In_ REFIID pRootSignatureDeserializerInterface, + _Out_ void** ppRootSignatureDeserializer); + +HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializerFromSubobjectInLibrary( + _In_reads_bytes_(SrcDataSizeInBytes) LPCVOID pSrcData, + _In_ SIZE_T SrcDataSizeInBytes, + _In_opt_ LPCWSTR RootSignatureSubobjectName, + _In_ REFIID pRootSignatureDeserializerInterface, + _Out_ void** ppRootSignatureDeserializer); + typedef struct D3D12_CPU_DESCRIPTOR_HANDLE { SIZE_T ptr; @@ -4265,7 +4692,8 @@ enum D3D12_INDIRECT_ARGUMENT_TYPE D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW = ( D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW + 1 ) , D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW = ( D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW + 1 ) , D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_RAYS = ( D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW + 1 ) , - D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_MESH = ( D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_RAYS + 1 ) + D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_MESH = ( D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_RAYS + 1 ) , + D3D12_INDIRECT_ARGUMENT_TYPE_INCREMENTING_CONSTANT = ( D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_MESH + 1 ) } D3D12_INDIRECT_ARGUMENT_TYPE; typedef struct D3D12_INDIRECT_ARGUMENT_DESC @@ -4295,6 +4723,11 @@ typedef struct D3D12_INDIRECT_ARGUMENT_DESC { UINT RootParameterIndex; } UnorderedAccessView; + struct + { + UINT RootParameterIndex; + UINT DestOffsetIn32BitValues; + } IncrementingConstant; } ; } D3D12_INDIRECT_ARGUMENT_DESC; @@ -4447,7 +4880,7 @@ EXTERN_C const IID IID_ID3D12Heap; ID3D12Heap : public ID3D12Pageable { public: -#if defined(_MSC_VER) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual D3D12_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0; #else virtual D3D12_HEAP_DESC *STDMETHODCALLTYPE GetDesc( @@ -4604,7 +5037,7 @@ EXTERN_C const IID IID_ID3D12Resource; UINT Subresource, _In_opt_ const D3D12_RANGE *pWrittenRange) = 0; -#if defined(_MSC_VER) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual D3D12_RESOURCE_DESC STDMETHODCALLTYPE GetDesc( void) = 0; #else virtual D3D12_RESOURCE_DESC *STDMETHODCALLTYPE GetDesc( @@ -5387,100 +5820,243 @@ EXTERN_C const IID IID_ID3D12PipelineState; #endif /* __ID3D12PipelineState_INTERFACE_DEFINED__ */ -#ifndef __ID3D12DescriptorHeap_INTERFACE_DEFINED__ -#define __ID3D12DescriptorHeap_INTERFACE_DEFINED__ +#ifndef __ID3D12PipelineState1_INTERFACE_DEFINED__ +#define __ID3D12PipelineState1_INTERFACE_DEFINED__ -/* interface ID3D12DescriptorHeap */ +/* interface ID3D12PipelineState1 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12DescriptorHeap; +EXTERN_C const IID IID_ID3D12PipelineState1; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("8efb471d-616c-4f49-90f7-127bb763fa51") - ID3D12DescriptorHeap : public ID3D12Pageable + MIDL_INTERFACE("5646804c-9638-48f7-9182-b3ee5a6b60fb") + ID3D12PipelineState1 : public ID3D12PipelineState { public: -#if defined(_MSC_VER) - virtual D3D12_DESCRIPTOR_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0; -#else - virtual D3D12_DESCRIPTOR_HEAP_DESC *STDMETHODCALLTYPE GetDesc( - D3D12_DESCRIPTOR_HEAP_DESC * RetVal) = 0; -#endif - -#if defined(_MSC_VER) - virtual D3D12_CPU_DESCRIPTOR_HANDLE STDMETHODCALLTYPE GetCPUDescriptorHandleForHeapStart( void) = 0; -#else - virtual D3D12_CPU_DESCRIPTOR_HANDLE *STDMETHODCALLTYPE GetCPUDescriptorHandleForHeapStart( - D3D12_CPU_DESCRIPTOR_HANDLE * RetVal) = 0; -#endif - -#if defined(_MSC_VER) - virtual D3D12_GPU_DESCRIPTOR_HANDLE STDMETHODCALLTYPE GetGPUDescriptorHandleForHeapStart( void) = 0; -#else - virtual D3D12_GPU_DESCRIPTOR_HANDLE *STDMETHODCALLTYPE GetGPUDescriptorHandleForHeapStart( - D3D12_GPU_DESCRIPTOR_HANDLE * RetVal) = 0; -#endif + virtual HRESULT STDMETHODCALLTYPE GetRootSignature( + REFIID riid, + _COM_Outptr_ void **ppvRootSignature) = 0; }; #else /* C style interface */ - typedef struct ID3D12DescriptorHeapVtbl + typedef struct ID3D12PipelineState1Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DescriptorHeap * This, + ID3D12PipelineState1 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DescriptorHeap * This); + ID3D12PipelineState1 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DescriptorHeap * This); + ID3D12PipelineState1 * This); DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12DescriptorHeap * This, + ID3D12PipelineState1 * This, _In_ REFGUID guid, _Inout_ UINT *pDataSize, _Out_writes_bytes_opt_( *pDataSize ) void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12DescriptorHeap * This, + ID3D12PipelineState1 * This, _In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_( DataSize ) const void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12DescriptorHeap * This, + ID3D12PipelineState1 * This, _In_ REFGUID guid, _In_opt_ const IUnknown *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetName) HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12DescriptorHeap * This, + ID3D12PipelineState1 * This, _In_z_ LPCWSTR Name); DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12DescriptorHeap * This, + ID3D12PipelineState1 * This, REFIID riid, _COM_Outptr_opt_ void **ppvDevice); - DECLSPEC_XFGVIRT(ID3D12DescriptorHeap, GetDesc) -#if !defined(_WIN32) - D3D12_DESCRIPTOR_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12DescriptorHeap * This); + DECLSPEC_XFGVIRT(ID3D12PipelineState, GetCachedBlob) + HRESULT ( STDMETHODCALLTYPE *GetCachedBlob )( + ID3D12PipelineState1 * This, + _COM_Outptr_ ID3DBlob **ppBlob); + + DECLSPEC_XFGVIRT(ID3D12PipelineState1, GetRootSignature) + HRESULT ( STDMETHODCALLTYPE *GetRootSignature )( + ID3D12PipelineState1 * This, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + END_INTERFACE + } ID3D12PipelineState1Vtbl; + + interface ID3D12PipelineState1 + { + CONST_VTBL struct ID3D12PipelineState1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12PipelineState1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12PipelineState1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12PipelineState1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12PipelineState1_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12PipelineState1_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12PipelineState1_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12PipelineState1_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12PipelineState1_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12PipelineState1_GetCachedBlob(This,ppBlob) \ + ( (This)->lpVtbl -> GetCachedBlob(This,ppBlob) ) + + +#define ID3D12PipelineState1_GetRootSignature(This,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> GetRootSignature(This,riid,ppvRootSignature) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12PipelineState1_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DescriptorHeap_INTERFACE_DEFINED__ +#define __ID3D12DescriptorHeap_INTERFACE_DEFINED__ + +/* interface ID3D12DescriptorHeap */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DescriptorHeap; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8efb471d-616c-4f49-90f7-127bb763fa51") + ID3D12DescriptorHeap : public ID3D12Pageable + { + public: +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) + virtual D3D12_DESCRIPTOR_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0; +#else + virtual D3D12_DESCRIPTOR_HEAP_DESC *STDMETHODCALLTYPE GetDesc( + D3D12_DESCRIPTOR_HEAP_DESC * RetVal) = 0; +#endif + +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) + virtual D3D12_CPU_DESCRIPTOR_HANDLE STDMETHODCALLTYPE GetCPUDescriptorHandleForHeapStart( void) = 0; +#else + virtual D3D12_CPU_DESCRIPTOR_HANDLE *STDMETHODCALLTYPE GetCPUDescriptorHandleForHeapStart( + D3D12_CPU_DESCRIPTOR_HANDLE * RetVal) = 0; +#endif + +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) + virtual D3D12_GPU_DESCRIPTOR_HANDLE STDMETHODCALLTYPE GetGPUDescriptorHandleForHeapStart( void) = 0; +#else + virtual D3D12_GPU_DESCRIPTOR_HANDLE *STDMETHODCALLTYPE GetGPUDescriptorHandleForHeapStart( + D3D12_GPU_DESCRIPTOR_HANDLE * RetVal) = 0; +#endif + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DescriptorHeapVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DescriptorHeap * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DescriptorHeap * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DescriptorHeap * This); + + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12DescriptorHeap * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12DescriptorHeap * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12DescriptorHeap * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12DescriptorHeap * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12DescriptorHeap * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + DECLSPEC_XFGVIRT(ID3D12DescriptorHeap, GetDesc) +#if !defined(_WIN32) + D3D12_DESCRIPTOR_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12DescriptorHeap * This); #else D3D12_DESCRIPTOR_HEAP_DESC *( STDMETHODCALLTYPE *GetDesc )( @@ -7583,7 +8159,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList1; #endif /* __ID3D12GraphicsCommandList1_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12_0000_0018 */ +/* interface __MIDL_itf_d3d12_0000_0019 */ /* [local] */ typedef struct D3D12_WRITEBUFFERIMMEDIATE_PARAMETER @@ -7602,8 +8178,8 @@ enum D3D12_WRITEBUFFERIMMEDIATE_MODE -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0018_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0018_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0019_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0019_v0_0_s_ifspec; #ifndef __ID3D12GraphicsCommandList2_INTERFACE_DEFINED__ #define __ID3D12GraphicsCommandList2_INTERFACE_DEFINED__ @@ -8390,7 +8966,7 @@ EXTERN_C const IID IID_ID3D12CommandQueue; _Out_ UINT64 *pGpuTimestamp, _Out_ UINT64 *pCpuTimestamp) = 0; -#if defined(_MSC_VER) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual D3D12_COMMAND_QUEUE_DESC STDMETHODCALLTYPE GetDesc( void) = 0; #else virtual D3D12_COMMAND_QUEUE_DESC *STDMETHODCALLTYPE GetDesc( @@ -8624,115 +9200,424 @@ EXTERN_C const IID IID_ID3D12CommandQueue; #endif /* __ID3D12CommandQueue_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12_0000_0020 */ +/* interface __MIDL_itf_d3d12_0000_0021 */ /* [local] */ -#ifdef __midl -#ifndef LUID_DEFINED -#define LUID_DEFINED 1 -typedef struct __LUID +typedef struct D3D12_FEATURE_DATA_HARDWARE_SCHEDULING_QUEUE_GROUPINGS { - DWORD LowPart; - LONG HighPart; - } LUID; - -typedef struct __LUID *PLUID; - -#endif -#endif - + _Out_ UINT ComputeQueuesPer3DQueue; + } D3D12_FEATURE_DATA_HARDWARE_SCHEDULING_QUEUE_GROUPINGS; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0020_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0020_v0_0_s_ifspec; - -#ifndef __ID3D12Device_INTERFACE_DEFINED__ -#define __ID3D12Device_INTERFACE_DEFINED__ +typedef +enum D3D12_COMMAND_QUEUE_PROCESS_PRIORITY + { + D3D12_COMMAND_QUEUE_PROCESS_PRIORITY_NORMAL = 0, + D3D12_COMMAND_QUEUE_PROCESS_PRIORITY_HIGH = 1 + } D3D12_COMMAND_QUEUE_PROCESS_PRIORITY; -/* interface ID3D12Device */ +typedef +enum D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY + { + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_IDLE = 0, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_DEFAULT = 1, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_NORMAL_0 = 2, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_0 = 18, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_1 = 19, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_2 = 20, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_3 = 21, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_4 = 22, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_5 = 23, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_6 = 24, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_7 = 25, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_8 = 26, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_9 = 27, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_10 = 28, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_11 = 29, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_12 = 30, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_SOFT_REALTIME_13 = 31, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY_HARD_REALTIME = 32 + } D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0021_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0021_v0_0_s_ifspec; + +#ifndef __ID3D12CommandQueue1_INTERFACE_DEFINED__ +#define __ID3D12CommandQueue1_INTERFACE_DEFINED__ + +/* interface ID3D12CommandQueue1 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12Device; +EXTERN_C const IID IID_ID3D12CommandQueue1; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("189819f1-1db6-4b57-be54-1821339b85f7") - ID3D12Device : public ID3D12Object + MIDL_INTERFACE("3a3c3165-0ee7-4b8e-a0af-6356b4c3bbb9") + ID3D12CommandQueue1 : public ID3D12CommandQueue { public: - virtual UINT STDMETHODCALLTYPE GetNodeCount( void) = 0; + virtual HRESULT STDMETHODCALLTYPE SetProcessPriority( + D3D12_COMMAND_QUEUE_PROCESS_PRIORITY Priority) = 0; - virtual HRESULT STDMETHODCALLTYPE CreateCommandQueue( - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue) = 0; + virtual HRESULT STDMETHODCALLTYPE GetProcessPriority( + D3D12_COMMAND_QUEUE_PROCESS_PRIORITY *pOutValue) = 0; - virtual HRESULT STDMETHODCALLTYPE CreateCommandAllocator( - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator) = 0; + virtual HRESULT STDMETHODCALLTYPE SetGlobalPriority( + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY Priority) = 0; - virtual HRESULT STDMETHODCALLTYPE CreateGraphicsPipelineState( - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState) = 0; + virtual HRESULT STDMETHODCALLTYPE GetGlobalPriority( + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY *pOutValue) = 0; - virtual HRESULT STDMETHODCALLTYPE CreateComputePipelineState( - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState) = 0; + }; + + +#else /* C style interface */ + + typedef struct ID3D12CommandQueue1Vtbl + { + BEGIN_INTERFACE - virtual HRESULT STDMETHODCALLTYPE CreateCommandList( - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12CommandQueue1 * This, REFIID riid, - _COM_Outptr_ void **ppCommandList) = 0; - - virtual HRESULT STDMETHODCALLTYPE CheckFeatureSupport( - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize) = 0; + _COM_Outptr_ void **ppvObject); - virtual HRESULT STDMETHODCALLTYPE CreateDescriptorHeap( - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, - REFIID riid, - _COM_Outptr_ void **ppvHeap) = 0; + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12CommandQueue1 * This); - virtual UINT STDMETHODCALLTYPE GetDescriptorHandleIncrementSize( - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType) = 0; + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12CommandQueue1 * This); - virtual HRESULT STDMETHODCALLTYPE CreateRootSignature( - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, - REFIID riid, - _COM_Outptr_ void **ppvRootSignature) = 0; + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12CommandQueue1 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); - virtual void STDMETHODCALLTYPE CreateConstantBufferView( - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12CommandQueue1 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); - virtual void STDMETHODCALLTYPE CreateShaderResourceView( - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12CommandQueue1 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); - virtual void STDMETHODCALLTYPE CreateUnorderedAccessView( - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12CommandQueue1 * This, + _In_z_ LPCWSTR Name); - virtual void STDMETHODCALLTYPE CreateRenderTargetView( - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12CommandQueue1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); - virtual void STDMETHODCALLTYPE CreateDepthStencilView( - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + DECLSPEC_XFGVIRT(ID3D12CommandQueue, UpdateTileMappings) + void ( STDMETHODCALLTYPE *UpdateTileMappings )( + ID3D12CommandQueue1 * This, + _In_ ID3D12Resource *pResource, + UINT NumResourceRegions, + _In_reads_opt_(NumResourceRegions) const D3D12_TILED_RESOURCE_COORDINATE *pResourceRegionStartCoordinates, + _In_reads_opt_(NumResourceRegions) const D3D12_TILE_REGION_SIZE *pResourceRegionSizes, + _In_opt_ ID3D12Heap *pHeap, + UINT NumRanges, + _In_reads_opt_(NumRanges) const D3D12_TILE_RANGE_FLAGS *pRangeFlags, + _In_reads_opt_(NumRanges) const UINT *pHeapRangeStartOffsets, + _In_reads_opt_(NumRanges) const UINT *pRangeTileCounts, + D3D12_TILE_MAPPING_FLAGS Flags); + + DECLSPEC_XFGVIRT(ID3D12CommandQueue, CopyTileMappings) + void ( STDMETHODCALLTYPE *CopyTileMappings )( + ID3D12CommandQueue1 * This, + _In_ ID3D12Resource *pDstResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pDstRegionStartCoordinate, + _In_ ID3D12Resource *pSrcResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pSrcRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pRegionSize, + D3D12_TILE_MAPPING_FLAGS Flags); + + DECLSPEC_XFGVIRT(ID3D12CommandQueue, ExecuteCommandLists) + void ( STDMETHODCALLTYPE *ExecuteCommandLists )( + ID3D12CommandQueue1 * This, + _In_ UINT NumCommandLists, + _In_reads_(NumCommandLists) ID3D12CommandList *const *ppCommandLists); + + DECLSPEC_XFGVIRT(ID3D12CommandQueue, SetMarker) + void ( STDMETHODCALLTYPE *SetMarker )( + ID3D12CommandQueue1 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + DECLSPEC_XFGVIRT(ID3D12CommandQueue, BeginEvent) + void ( STDMETHODCALLTYPE *BeginEvent )( + ID3D12CommandQueue1 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + DECLSPEC_XFGVIRT(ID3D12CommandQueue, EndEvent) + void ( STDMETHODCALLTYPE *EndEvent )( + ID3D12CommandQueue1 * This); + + DECLSPEC_XFGVIRT(ID3D12CommandQueue, Signal) + HRESULT ( STDMETHODCALLTYPE *Signal )( + ID3D12CommandQueue1 * This, + ID3D12Fence *pFence, + UINT64 Value); + + DECLSPEC_XFGVIRT(ID3D12CommandQueue, Wait) + HRESULT ( STDMETHODCALLTYPE *Wait )( + ID3D12CommandQueue1 * This, + ID3D12Fence *pFence, + UINT64 Value); + + DECLSPEC_XFGVIRT(ID3D12CommandQueue, GetTimestampFrequency) + HRESULT ( STDMETHODCALLTYPE *GetTimestampFrequency )( + ID3D12CommandQueue1 * This, + _Out_ UINT64 *pFrequency); + + DECLSPEC_XFGVIRT(ID3D12CommandQueue, GetClockCalibration) + HRESULT ( STDMETHODCALLTYPE *GetClockCalibration )( + ID3D12CommandQueue1 * This, + _Out_ UINT64 *pGpuTimestamp, + _Out_ UINT64 *pCpuTimestamp); + + DECLSPEC_XFGVIRT(ID3D12CommandQueue, GetDesc) +#if !defined(_WIN32) + D3D12_COMMAND_QUEUE_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12CommandQueue1 * This); + +#else + D3D12_COMMAND_QUEUE_DESC *( STDMETHODCALLTYPE *GetDesc )( + ID3D12CommandQueue1 * This, + D3D12_COMMAND_QUEUE_DESC * RetVal); + +#endif + + DECLSPEC_XFGVIRT(ID3D12CommandQueue1, SetProcessPriority) + HRESULT ( STDMETHODCALLTYPE *SetProcessPriority )( + ID3D12CommandQueue1 * This, + D3D12_COMMAND_QUEUE_PROCESS_PRIORITY Priority); + + DECLSPEC_XFGVIRT(ID3D12CommandQueue1, GetProcessPriority) + HRESULT ( STDMETHODCALLTYPE *GetProcessPriority )( + ID3D12CommandQueue1 * This, + D3D12_COMMAND_QUEUE_PROCESS_PRIORITY *pOutValue); + + DECLSPEC_XFGVIRT(ID3D12CommandQueue1, SetGlobalPriority) + HRESULT ( STDMETHODCALLTYPE *SetGlobalPriority )( + ID3D12CommandQueue1 * This, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY Priority); + + DECLSPEC_XFGVIRT(ID3D12CommandQueue1, GetGlobalPriority) + HRESULT ( STDMETHODCALLTYPE *GetGlobalPriority )( + ID3D12CommandQueue1 * This, + D3D12_COMMAND_QUEUE_GLOBAL_PRIORITY *pOutValue); + + END_INTERFACE + } ID3D12CommandQueue1Vtbl; + + interface ID3D12CommandQueue1 + { + CONST_VTBL struct ID3D12CommandQueue1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12CommandQueue1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12CommandQueue1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12CommandQueue1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12CommandQueue1_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12CommandQueue1_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12CommandQueue1_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12CommandQueue1_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12CommandQueue1_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12CommandQueue1_UpdateTileMappings(This,pResource,NumResourceRegions,pResourceRegionStartCoordinates,pResourceRegionSizes,pHeap,NumRanges,pRangeFlags,pHeapRangeStartOffsets,pRangeTileCounts,Flags) \ + ( (This)->lpVtbl -> UpdateTileMappings(This,pResource,NumResourceRegions,pResourceRegionStartCoordinates,pResourceRegionSizes,pHeap,NumRanges,pRangeFlags,pHeapRangeStartOffsets,pRangeTileCounts,Flags) ) + +#define ID3D12CommandQueue1_CopyTileMappings(This,pDstResource,pDstRegionStartCoordinate,pSrcResource,pSrcRegionStartCoordinate,pRegionSize,Flags) \ + ( (This)->lpVtbl -> CopyTileMappings(This,pDstResource,pDstRegionStartCoordinate,pSrcResource,pSrcRegionStartCoordinate,pRegionSize,Flags) ) + +#define ID3D12CommandQueue1_ExecuteCommandLists(This,NumCommandLists,ppCommandLists) \ + ( (This)->lpVtbl -> ExecuteCommandLists(This,NumCommandLists,ppCommandLists) ) + +#define ID3D12CommandQueue1_SetMarker(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) + +#define ID3D12CommandQueue1_BeginEvent(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) + +#define ID3D12CommandQueue1_EndEvent(This) \ + ( (This)->lpVtbl -> EndEvent(This) ) + +#define ID3D12CommandQueue1_Signal(This,pFence,Value) \ + ( (This)->lpVtbl -> Signal(This,pFence,Value) ) + +#define ID3D12CommandQueue1_Wait(This,pFence,Value) \ + ( (This)->lpVtbl -> Wait(This,pFence,Value) ) + +#define ID3D12CommandQueue1_GetTimestampFrequency(This,pFrequency) \ + ( (This)->lpVtbl -> GetTimestampFrequency(This,pFrequency) ) + +#define ID3D12CommandQueue1_GetClockCalibration(This,pGpuTimestamp,pCpuTimestamp) \ + ( (This)->lpVtbl -> GetClockCalibration(This,pGpuTimestamp,pCpuTimestamp) ) +#if !defined(_WIN32) + +#define ID3D12CommandQueue1_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) +#else +#define ID3D12CommandQueue1_GetDesc(This,RetVal) \ + ( (This)->lpVtbl -> GetDesc(This,RetVal) ) +#endif + + +#define ID3D12CommandQueue1_SetProcessPriority(This,Priority) \ + ( (This)->lpVtbl -> SetProcessPriority(This,Priority) ) + +#define ID3D12CommandQueue1_GetProcessPriority(This,pOutValue) \ + ( (This)->lpVtbl -> GetProcessPriority(This,pOutValue) ) + +#define ID3D12CommandQueue1_SetGlobalPriority(This,Priority) \ + ( (This)->lpVtbl -> SetGlobalPriority(This,Priority) ) + +#define ID3D12CommandQueue1_GetGlobalPriority(This,pOutValue) \ + ( (This)->lpVtbl -> GetGlobalPriority(This,pOutValue) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12CommandQueue1_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Device_INTERFACE_DEFINED__ +#define __ID3D12Device_INTERFACE_DEFINED__ + +/* interface ID3D12Device */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Device; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("189819f1-1db6-4b57-be54-1821339b85f7") + ID3D12Device : public ID3D12Object + { + public: + virtual UINT STDMETHODCALLTYPE GetNodeCount( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateCommandQueue( + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateCommandAllocator( + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateGraphicsPipelineState( + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateComputePipelineState( + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateCommandList( + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList) = 0; + + virtual HRESULT STDMETHODCALLTYPE CheckFeatureSupport( + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateDescriptorHeap( + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap) = 0; + + virtual UINT STDMETHODCALLTYPE GetDescriptorHandleIncrementSize( + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateRootSignature( + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature) = 0; + + virtual void STDMETHODCALLTYPE CreateConstantBufferView( + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + + virtual void STDMETHODCALLTYPE CreateShaderResourceView( + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + + virtual void STDMETHODCALLTYPE CreateUnorderedAccessView( + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + + virtual void STDMETHODCALLTYPE CreateRenderTargetView( + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + + virtual void STDMETHODCALLTYPE CreateDepthStencilView( + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; virtual void STDMETHODCALLTYPE CreateSampler( @@ -8754,7 +9639,7 @@ EXTERN_C const IID IID_ID3D12Device; _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType) = 0; -#if defined(_MSC_VER) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual D3D12_RESOURCE_ALLOCATION_INFO STDMETHODCALLTYPE GetResourceAllocationInfo( _In_ UINT visibleMask, _In_ UINT numResourceDescs, @@ -8767,7 +9652,7 @@ EXTERN_C const IID IID_ID3D12Device; _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs) = 0; #endif -#if defined(_MSC_VER) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual D3D12_HEAP_PROPERTIES STDMETHODCALLTYPE GetCustomHeapProperties( _In_ UINT nodeMask, D3D12_HEAP_TYPE heapType) = 0; @@ -8875,7 +9760,7 @@ EXTERN_C const IID IID_ID3D12Device; _In_ UINT FirstSubresourceTilingToGet, _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips) = 0; -#if defined(_MSC_VER) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual LUID STDMETHODCALLTYPE GetAdapterLuid( void) = 0; #else virtual LUID *STDMETHODCALLTYPE GetAdapterLuid( @@ -9782,7 +10667,7 @@ EXTERN_C const IID IID_ID3D12PipelineLibrary1; #endif /* __ID3D12PipelineLibrary1_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12_0000_0023 */ +/* interface __MIDL_itf_d3d12_0000_0025 */ /* [local] */ typedef @@ -9793,7 +10678,7 @@ enum D3D12_MULTIPLE_FENCE_WAIT_FLAGS D3D12_MULTIPLE_FENCE_WAIT_FLAG_ALL = 0 } D3D12_MULTIPLE_FENCE_WAIT_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTIPLE_FENCE_WAIT_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_MULTIPLE_FENCE_WAIT_FLAGS ) typedef enum D3D12_RESIDENCY_PRIORITY { @@ -9806,8 +10691,8 @@ enum D3D12_RESIDENCY_PRIORITY -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0023_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0023_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0025_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0025_v0_0_s_ifspec; #ifndef __ID3D12Device1_INTERFACE_DEFINED__ #define __ID3D12Device1_INTERFACE_DEFINED__ @@ -10993,7 +11878,7 @@ EXTERN_C const IID IID_ID3D12Device2; #endif /* __ID3D12Device2_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12_0000_0025 */ +/* interface __MIDL_itf_d3d12_0000_0027 */ /* [local] */ typedef @@ -11003,11 +11888,11 @@ enum D3D12_RESIDENCY_FLAGS D3D12_RESIDENCY_FLAG_DENY_OVERBUDGET = 0x1 } D3D12_RESIDENCY_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESIDENCY_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RESIDENCY_FLAGS ) -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0025_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0025_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0027_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0027_v0_0_s_ifspec; #ifndef __ID3D12Device3_INTERFACE_DEFINED__ #define __ID3D12Device3_INTERFACE_DEFINED__ @@ -11645,7 +12530,7 @@ EXTERN_C const IID IID_ID3D12Device3; #endif /* __ID3D12Device3_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12_0000_0026 */ +/* interface __MIDL_itf_d3d12_0000_0028 */ /* [local] */ typedef @@ -11654,21 +12539,21 @@ enum D3D12_COMMAND_LIST_FLAGS D3D12_COMMAND_LIST_FLAG_NONE = 0 } D3D12_COMMAND_LIST_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_LIST_FLAGS ) typedef enum D3D12_COMMAND_POOL_FLAGS { D3D12_COMMAND_POOL_FLAG_NONE = 0 } D3D12_COMMAND_POOL_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_POOL_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_POOL_FLAGS ) typedef enum D3D12_COMMAND_RECORDER_FLAGS { D3D12_COMMAND_RECORDER_FLAG_NONE = 0 } D3D12_COMMAND_RECORDER_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_RECORDER_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMMAND_RECORDER_FLAGS ) typedef enum D3D12_PROTECTED_SESSION_STATUS { @@ -11678,8 +12563,8 @@ enum D3D12_PROTECTED_SESSION_STATUS -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0026_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0026_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0028_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0028_v0_0_s_ifspec; #ifndef __ID3D12ProtectedSession_INTERFACE_DEFINED__ #define __ID3D12ProtectedSession_INTERFACE_DEFINED__ @@ -11823,7 +12708,7 @@ EXTERN_C const IID IID_ID3D12ProtectedSession; #endif /* __ID3D12ProtectedSession_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12_0000_0027 */ +/* interface __MIDL_itf_d3d12_0000_0029 */ /* [local] */ typedef @@ -11833,7 +12718,7 @@ enum D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED = 0x1 } D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS ) typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT { UINT NodeIndex; @@ -11846,7 +12731,7 @@ enum D3D12_PROTECTED_RESOURCE_SESSION_FLAGS D3D12_PROTECTED_RESOURCE_SESSION_FLAG_NONE = 0 } D3D12_PROTECTED_RESOURCE_SESSION_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_PROTECTED_RESOURCE_SESSION_FLAGS ) typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC { UINT NodeMask; @@ -11855,8 +12740,8 @@ typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0027_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0027_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0029_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0029_v0_0_s_ifspec; #ifndef __ID3D12ProtectedResourceSession_INTERFACE_DEFINED__ #define __ID3D12ProtectedResourceSession_INTERFACE_DEFINED__ @@ -11873,7 +12758,7 @@ EXTERN_C const IID IID_ID3D12ProtectedResourceSession; ID3D12ProtectedResourceSession : public ID3D12ProtectedSession { public: -#if defined(_MSC_VER) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual D3D12_PROTECTED_RESOURCE_SESSION_DESC STDMETHODCALLTYPE GetDesc( void) = 0; #else virtual D3D12_PROTECTED_RESOURCE_SESSION_DESC *STDMETHODCALLTYPE GetDesc( @@ -12073,7 +12958,7 @@ EXTERN_C const IID IID_ID3D12Device4; REFIID riid, _COM_Outptr_opt_ void **ppvResource) = 0; -#if defined(_MSC_VER) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual D3D12_RESOURCE_ALLOCATION_INFO STDMETHODCALLTYPE GetResourceAllocationInfo1( UINT visibleMask, UINT numResourceDescs, @@ -12782,7 +13667,7 @@ EXTERN_C const IID IID_ID3D12Device4; #endif /* __ID3D12Device4_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12_0000_0029 */ +/* interface __MIDL_itf_d3d12_0000_0031 */ /* [local] */ typedef @@ -12795,8 +13680,8 @@ enum D3D12_LIFETIME_STATE -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0029_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0029_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0031_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0031_v0_0_s_ifspec; #ifndef __ID3D12LifetimeOwner_INTERFACE_DEFINED__ #define __ID3D12LifetimeOwner_INTERFACE_DEFINED__ @@ -12896,7 +13781,7 @@ EXTERN_C const IID IID_ID3D12SwapChainAssistant; ID3D12SwapChainAssistant : public IUnknown { public: -#if defined(_MSC_VER) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual LUID STDMETHODCALLTYPE GetLUID( void) = 0; #else virtual LUID *STDMETHODCALLTYPE GetLUID( @@ -13150,7 +14035,7 @@ EXTERN_C const IID IID_ID3D12LifetimeTracker; #endif /* __ID3D12LifetimeTracker_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12_0000_0032 */ +/* interface __MIDL_itf_d3d12_0000_0034 */ /* [local] */ typedef @@ -13170,7 +14055,7 @@ enum D3D12_META_COMMAND_PARAMETER_FLAGS D3D12_META_COMMAND_PARAMETER_FLAG_OUTPUT = 0x2 } D3D12_META_COMMAND_PARAMETER_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_META_COMMAND_PARAMETER_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_META_COMMAND_PARAMETER_FLAGS ) typedef enum D3D12_META_COMMAND_PARAMETER_STAGE { @@ -13211,7 +14096,7 @@ enum D3D12_GRAPHICS_STATES D3D12_GRAPHICS_STATE_VIEW_INSTANCE_MASK = ( 1 << 16 ) } D3D12_GRAPHICS_STATES; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_GRAPHICS_STATES ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_GRAPHICS_STATES ) typedef struct D3D12_META_COMMAND_DESC { GUID Id; @@ -13222,8 +14107,8 @@ typedef struct D3D12_META_COMMAND_DESC -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0032_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0032_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0034_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0034_v0_0_s_ifspec; #ifndef __ID3D12StateObject_INTERFACE_DEFINED__ #define __ID3D12StateObject_INTERFACE_DEFINED__ @@ -13460,735 +14345,4462 @@ EXTERN_C const IID IID_ID3D12StateObjectProperties; #endif /* __ID3D12StateObjectProperties_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12_0000_0034 */ +/* interface __MIDL_itf_d3d12_0000_0036 */ /* [local] */ -typedef -enum D3D12_STATE_SUBOBJECT_TYPE +typedef struct D3D12_PROGRAM_IDENTIFIER { - D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG = 0, - D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE = 1, - D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE = 2, - D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK = 3, - D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY = 5, - D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION = 6, - D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 7, - D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 8, - D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG = 9, - D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG = 10, - D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP = 11, - D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1 = 12, - D3D12_STATE_SUBOBJECT_TYPE_MAX_VALID = ( D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1 + 1 ) - } D3D12_STATE_SUBOBJECT_TYPE; + UINT64 OpaqueData[ 4 ]; + } D3D12_PROGRAM_IDENTIFIER; -typedef struct D3D12_STATE_SUBOBJECT - { - D3D12_STATE_SUBOBJECT_TYPE Type; - const void *pDesc; - } D3D12_STATE_SUBOBJECT; -typedef -enum D3D12_STATE_OBJECT_FLAGS - { - D3D12_STATE_OBJECT_FLAG_NONE = 0, - D3D12_STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS = 0x1, - D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS = 0x2, - D3D12_STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS = 0x4 - } D3D12_STATE_OBJECT_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_STATE_OBJECT_FLAGS ); -typedef struct D3D12_STATE_OBJECT_CONFIG - { - D3D12_STATE_OBJECT_FLAGS Flags; - } D3D12_STATE_OBJECT_CONFIG; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0036_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0036_v0_0_s_ifspec; -typedef struct D3D12_GLOBAL_ROOT_SIGNATURE - { - ID3D12RootSignature *pGlobalRootSignature; - } D3D12_GLOBAL_ROOT_SIGNATURE; +#ifndef __ID3D12StateObjectProperties1_INTERFACE_DEFINED__ +#define __ID3D12StateObjectProperties1_INTERFACE_DEFINED__ -typedef struct D3D12_LOCAL_ROOT_SIGNATURE - { - ID3D12RootSignature *pLocalRootSignature; - } D3D12_LOCAL_ROOT_SIGNATURE; +/* interface ID3D12StateObjectProperties1 */ +/* [unique][local][object][uuid] */ -typedef struct D3D12_NODE_MASK - { - UINT NodeMask; - } D3D12_NODE_MASK; -typedef -enum D3D12_EXPORT_FLAGS - { - D3D12_EXPORT_FLAG_NONE = 0 - } D3D12_EXPORT_FLAGS; +EXTERN_C const IID IID_ID3D12StateObjectProperties1; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_EXPORT_FLAGS ); -typedef struct D3D12_EXPORT_DESC +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("460caac7-1d24-446a-a184-ca67db494138") + ID3D12StateObjectProperties1 : public ID3D12StateObjectProperties { - LPCWSTR Name; - _In_opt_ LPCWSTR ExportToRename; - D3D12_EXPORT_FLAGS Flags; - } D3D12_EXPORT_DESC; + public: +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) + virtual D3D12_PROGRAM_IDENTIFIER STDMETHODCALLTYPE GetProgramIdentifier( + LPCWSTR pProgramName) = 0; +#else + virtual D3D12_PROGRAM_IDENTIFIER *STDMETHODCALLTYPE GetProgramIdentifier( + D3D12_PROGRAM_IDENTIFIER * RetVal, + LPCWSTR pProgramName) = 0; +#endif + + }; + + +#else /* C style interface */ -typedef struct D3D12_DXIL_LIBRARY_DESC + typedef struct ID3D12StateObjectProperties1Vtbl { - D3D12_SHADER_BYTECODE DXILLibrary; - UINT NumExports; - _In_reads_(NumExports) D3D12_EXPORT_DESC *pExports; - } D3D12_DXIL_LIBRARY_DESC; + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12StateObjectProperties1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12StateObjectProperties1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12StateObjectProperties1 * This); + + DECLSPEC_XFGVIRT(ID3D12StateObjectProperties, GetShaderIdentifier) + void *( STDMETHODCALLTYPE *GetShaderIdentifier )( + ID3D12StateObjectProperties1 * This, + _In_ LPCWSTR pExportName); + + DECLSPEC_XFGVIRT(ID3D12StateObjectProperties, GetShaderStackSize) + UINT64 ( STDMETHODCALLTYPE *GetShaderStackSize )( + ID3D12StateObjectProperties1 * This, + _In_ LPCWSTR pExportName); + + DECLSPEC_XFGVIRT(ID3D12StateObjectProperties, GetPipelineStackSize) + UINT64 ( STDMETHODCALLTYPE *GetPipelineStackSize )( + ID3D12StateObjectProperties1 * This); + + DECLSPEC_XFGVIRT(ID3D12StateObjectProperties, SetPipelineStackSize) + void ( STDMETHODCALLTYPE *SetPipelineStackSize )( + ID3D12StateObjectProperties1 * This, + UINT64 PipelineStackSizeInBytes); + + DECLSPEC_XFGVIRT(ID3D12StateObjectProperties1, GetProgramIdentifier) +#if !defined(_WIN32) + D3D12_PROGRAM_IDENTIFIER ( STDMETHODCALLTYPE *GetProgramIdentifier )( + ID3D12StateObjectProperties1 * This, + LPCWSTR pProgramName); + +#else + D3D12_PROGRAM_IDENTIFIER *( STDMETHODCALLTYPE *GetProgramIdentifier )( + ID3D12StateObjectProperties1 * This, + D3D12_PROGRAM_IDENTIFIER * RetVal, + LPCWSTR pProgramName); + +#endif + + END_INTERFACE + } ID3D12StateObjectProperties1Vtbl; -typedef struct D3D12_EXISTING_COLLECTION_DESC + interface ID3D12StateObjectProperties1 { - ID3D12StateObject *pExistingCollection; - UINT NumExports; - _In_reads_(NumExports) D3D12_EXPORT_DESC *pExports; - } D3D12_EXISTING_COLLECTION_DESC; + CONST_VTBL struct ID3D12StateObjectProperties1Vtbl *lpVtbl; + }; -typedef struct D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION - { - const D3D12_STATE_SUBOBJECT *pSubobjectToAssociate; - UINT NumExports; - _In_reads_(NumExports) LPCWSTR *pExports; - } D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION; + -typedef struct D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION - { - LPCWSTR SubobjectToAssociate; - UINT NumExports; - _In_reads_(NumExports) LPCWSTR *pExports; - } D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION; +#ifdef COBJMACROS -typedef -enum D3D12_HIT_GROUP_TYPE - { - D3D12_HIT_GROUP_TYPE_TRIANGLES = 0, - D3D12_HIT_GROUP_TYPE_PROCEDURAL_PRIMITIVE = 0x1 - } D3D12_HIT_GROUP_TYPE; -typedef struct D3D12_HIT_GROUP_DESC - { - LPCWSTR HitGroupExport; - D3D12_HIT_GROUP_TYPE Type; - _In_opt_ LPCWSTR AnyHitShaderImport; - _In_opt_ LPCWSTR ClosestHitShaderImport; - _In_opt_ LPCWSTR IntersectionShaderImport; - } D3D12_HIT_GROUP_DESC; +#define ID3D12StateObjectProperties1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -typedef struct D3D12_RAYTRACING_SHADER_CONFIG - { - UINT MaxPayloadSizeInBytes; - UINT MaxAttributeSizeInBytes; - } D3D12_RAYTRACING_SHADER_CONFIG; +#define ID3D12StateObjectProperties1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) -typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG - { - UINT MaxTraceRecursionDepth; - } D3D12_RAYTRACING_PIPELINE_CONFIG; +#define ID3D12StateObjectProperties1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) -typedef -enum D3D12_RAYTRACING_PIPELINE_FLAGS - { - D3D12_RAYTRACING_PIPELINE_FLAG_NONE = 0, - D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_TRIANGLES = 0x100, - D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 0x200 - } D3D12_RAYTRACING_PIPELINE_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_PIPELINE_FLAGS ); -typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG1 - { - UINT MaxTraceRecursionDepth; - D3D12_RAYTRACING_PIPELINE_FLAGS Flags; - } D3D12_RAYTRACING_PIPELINE_CONFIG1; +#define ID3D12StateObjectProperties1_GetShaderIdentifier(This,pExportName) \ + ( (This)->lpVtbl -> GetShaderIdentifier(This,pExportName) ) -typedef -enum D3D12_STATE_OBJECT_TYPE - { - D3D12_STATE_OBJECT_TYPE_COLLECTION = 0, - D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE = 3 - } D3D12_STATE_OBJECT_TYPE; +#define ID3D12StateObjectProperties1_GetShaderStackSize(This,pExportName) \ + ( (This)->lpVtbl -> GetShaderStackSize(This,pExportName) ) -typedef struct D3D12_STATE_OBJECT_DESC - { - D3D12_STATE_OBJECT_TYPE Type; - UINT NumSubobjects; - _In_reads_(NumSubobjects) const D3D12_STATE_SUBOBJECT *pSubobjects; - } D3D12_STATE_OBJECT_DESC; +#define ID3D12StateObjectProperties1_GetPipelineStackSize(This) \ + ( (This)->lpVtbl -> GetPipelineStackSize(This) ) -typedef -enum D3D12_RAYTRACING_GEOMETRY_FLAGS - { - D3D12_RAYTRACING_GEOMETRY_FLAG_NONE = 0, - D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE = 0x1, - D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION = 0x2 - } D3D12_RAYTRACING_GEOMETRY_FLAGS; +#define ID3D12StateObjectProperties1_SetPipelineStackSize(This,PipelineStackSizeInBytes) \ + ( (This)->lpVtbl -> SetPipelineStackSize(This,PipelineStackSizeInBytes) ) -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_GEOMETRY_FLAGS ); -typedef -enum D3D12_RAYTRACING_GEOMETRY_TYPE - { - D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES = 0, - D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS = ( D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES + 1 ) - } D3D12_RAYTRACING_GEOMETRY_TYPE; +#if !defined(_WIN32) -typedef -enum D3D12_RAYTRACING_INSTANCE_FLAGS - { - D3D12_RAYTRACING_INSTANCE_FLAG_NONE = 0, - D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE = 0x1, - D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE = 0x2, - D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE = 0x4, - D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE = 0x8 - } D3D12_RAYTRACING_INSTANCE_FLAGS; +#define ID3D12StateObjectProperties1_GetProgramIdentifier(This,pProgramName) \ + ( (This)->lpVtbl -> GetProgramIdentifier(This,pProgramName) ) +#else +#define ID3D12StateObjectProperties1_GetProgramIdentifier(This,RetVal,pProgramName) \ + ( (This)->lpVtbl -> GetProgramIdentifier(This,RetVal,pProgramName) ) +#endif -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_INSTANCE_FLAGS ); -typedef struct D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE - { - D3D12_GPU_VIRTUAL_ADDRESS StartAddress; - UINT64 StrideInBytes; - } D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE; +#endif /* COBJMACROS */ -typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE - { - D3D12_GPU_VIRTUAL_ADDRESS StartAddress; - UINT64 SizeInBytes; - } D3D12_GPU_VIRTUAL_ADDRESS_RANGE; -typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE - { - D3D12_GPU_VIRTUAL_ADDRESS StartAddress; - UINT64 SizeInBytes; - UINT64 StrideInBytes; - } D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE; +#endif /* C style interface */ -typedef struct D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC - { - D3D12_GPU_VIRTUAL_ADDRESS Transform3x4; - DXGI_FORMAT IndexFormat; - DXGI_FORMAT VertexFormat; - UINT IndexCount; - UINT VertexCount; - D3D12_GPU_VIRTUAL_ADDRESS IndexBuffer; - D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE VertexBuffer; - } D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC; -typedef struct D3D12_RAYTRACING_AABB - { - FLOAT MinX; - FLOAT MinY; - FLOAT MinZ; - FLOAT MaxX; - FLOAT MaxY; - FLOAT MaxZ; - } D3D12_RAYTRACING_AABB; -typedef struct D3D12_RAYTRACING_GEOMETRY_AABBS_DESC - { - UINT64 AABBCount; - D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE AABBs; - } D3D12_RAYTRACING_GEOMETRY_AABBS_DESC; -typedef -enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS - { - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE = 0, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE = 0x1, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION = 0x2, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE = 0x4, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD = 0x8, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY = 0x10, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE = 0x20 - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS; +#endif /* __ID3D12StateObjectProperties1_INTERFACE_DEFINED__ */ -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS ); -typedef -enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE - { - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE = 0, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT = 0x1, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_VISUALIZATION_DECODE_FOR_TOOLS = 0x2, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_SERIALIZE = 0x3, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE = 0x4 - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE; -typedef -enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE - { - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL = 0, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL = 0x1 - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE; +#ifndef __ID3D12StateObjectProperties2_INTERFACE_DEFINED__ +#define __ID3D12StateObjectProperties2_INTERFACE_DEFINED__ -typedef -enum D3D12_ELEMENTS_LAYOUT - { - D3D12_ELEMENTS_LAYOUT_ARRAY = 0, - D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS = 0x1 - } D3D12_ELEMENTS_LAYOUT; +/* interface ID3D12StateObjectProperties2 */ +/* [unique][local][object][uuid] */ -typedef -enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE - { - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE = 0, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION = 0x1, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION = 0x2, - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE = 0x3 - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE; -typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC - { - D3D12_GPU_VIRTUAL_ADDRESS DestBuffer; - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE InfoType; - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC; +EXTERN_C const IID IID_ID3D12StateObjectProperties2; -typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("d5e82917-f0f1-44cf-ae5e-ce222dd0b884") + ID3D12StateObjectProperties2 : public ID3D12StateObjectProperties1 { - UINT64 CompactedSizeInBytes; - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC; + public: + virtual HRESULT STDMETHODCALLTYPE GetGlobalRootSignatureForProgram( + LPCWSTR pProgramName, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGlobalRootSignatureForShader( + LPCWSTR pExportName, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature) = 0; + + }; + + +#else /* C style interface */ -typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC + typedef struct ID3D12StateObjectProperties2Vtbl { - UINT64 DecodedSizeInBytes; - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC; + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12StateObjectProperties2 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12StateObjectProperties2 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12StateObjectProperties2 * This); + + DECLSPEC_XFGVIRT(ID3D12StateObjectProperties, GetShaderIdentifier) + void *( STDMETHODCALLTYPE *GetShaderIdentifier )( + ID3D12StateObjectProperties2 * This, + _In_ LPCWSTR pExportName); + + DECLSPEC_XFGVIRT(ID3D12StateObjectProperties, GetShaderStackSize) + UINT64 ( STDMETHODCALLTYPE *GetShaderStackSize )( + ID3D12StateObjectProperties2 * This, + _In_ LPCWSTR pExportName); + + DECLSPEC_XFGVIRT(ID3D12StateObjectProperties, GetPipelineStackSize) + UINT64 ( STDMETHODCALLTYPE *GetPipelineStackSize )( + ID3D12StateObjectProperties2 * This); + + DECLSPEC_XFGVIRT(ID3D12StateObjectProperties, SetPipelineStackSize) + void ( STDMETHODCALLTYPE *SetPipelineStackSize )( + ID3D12StateObjectProperties2 * This, + UINT64 PipelineStackSizeInBytes); + + DECLSPEC_XFGVIRT(ID3D12StateObjectProperties1, GetProgramIdentifier) +#if !defined(_WIN32) + D3D12_PROGRAM_IDENTIFIER ( STDMETHODCALLTYPE *GetProgramIdentifier )( + ID3D12StateObjectProperties2 * This, + LPCWSTR pProgramName); + +#else + D3D12_PROGRAM_IDENTIFIER *( STDMETHODCALLTYPE *GetProgramIdentifier )( + ID3D12StateObjectProperties2 * This, + D3D12_PROGRAM_IDENTIFIER * RetVal, + LPCWSTR pProgramName); + +#endif + + DECLSPEC_XFGVIRT(ID3D12StateObjectProperties2, GetGlobalRootSignatureForProgram) + HRESULT ( STDMETHODCALLTYPE *GetGlobalRootSignatureForProgram )( + ID3D12StateObjectProperties2 * This, + LPCWSTR pProgramName, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + DECLSPEC_XFGVIRT(ID3D12StateObjectProperties2, GetGlobalRootSignatureForShader) + HRESULT ( STDMETHODCALLTYPE *GetGlobalRootSignatureForShader )( + ID3D12StateObjectProperties2 * This, + LPCWSTR pExportName, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + END_INTERFACE + } ID3D12StateObjectProperties2Vtbl; -typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER + interface ID3D12StateObjectProperties2 { - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type; - UINT NumDescs; - } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER; + CONST_VTBL struct ID3D12StateObjectProperties2Vtbl *lpVtbl; + }; -// Regarding D3D12_BUILD_RAY_TRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER above, -// depending on Type field, NumDescs above is followed by either: -// D3D12_RAY_TRACING_INSTANCE_DESC InstanceDescs[NumDescs] -// or D3D12_RAY_TRACING_GEOMETRY_DESC GeometryDescs[NumDescs]. -// There is 4 bytes of padding between GeometryDesc structs in the array so alignment is natural when viewed by CPU. + -typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC - { - UINT64 SerializedSizeInBytes; - UINT64 NumBottomLevelAccelerationStructurePointers; - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC; +#ifdef COBJMACROS -typedef struct D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER - { - GUID DriverOpaqueGUID; - BYTE DriverOpaqueVersioningData[ 16 ]; - } D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER; -typedef -enum D3D12_SERIALIZED_DATA_TYPE - { - D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE = 0 - } D3D12_SERIALIZED_DATA_TYPE; +#define ID3D12StateObjectProperties2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -typedef -enum D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS - { - D3D12_DRIVER_MATCHING_IDENTIFIER_COMPATIBLE_WITH_DEVICE = 0, - D3D12_DRIVER_MATCHING_IDENTIFIER_UNSUPPORTED_TYPE = 0x1, - D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED = 0x2, - D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_VERSION = 0x3, - D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_TYPE = 0x4 - } D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS; +#define ID3D12StateObjectProperties2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) -typedef struct D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER - { - D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER DriverMatchingIdentifier; - UINT64 SerializedSizeInBytesIncludingHeader; - UINT64 DeserializedSizeInBytes; - UINT64 NumBottomLevelAccelerationStructurePointersAfterHeader; - } D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER; +#define ID3D12StateObjectProperties2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) -typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC - { - UINT64 CurrentSizeInBytes; - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC; -typedef struct D3D12_RAYTRACING_INSTANCE_DESC - { - FLOAT Transform[ 3 ][ 4 ]; - UINT InstanceID : 24; - UINT InstanceMask : 8; - UINT InstanceContributionToHitGroupIndex : 24; - UINT Flags : 8; - D3D12_GPU_VIRTUAL_ADDRESS AccelerationStructure; - } D3D12_RAYTRACING_INSTANCE_DESC; +#define ID3D12StateObjectProperties2_GetShaderIdentifier(This,pExportName) \ + ( (This)->lpVtbl -> GetShaderIdentifier(This,pExportName) ) -typedef struct D3D12_RAYTRACING_GEOMETRY_DESC - { - D3D12_RAYTRACING_GEOMETRY_TYPE Type; - D3D12_RAYTRACING_GEOMETRY_FLAGS Flags; - union - { - D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC Triangles; - D3D12_RAYTRACING_GEOMETRY_AABBS_DESC AABBs; - } ; - } D3D12_RAYTRACING_GEOMETRY_DESC; +#define ID3D12StateObjectProperties2_GetShaderStackSize(This,pExportName) \ + ( (This)->lpVtbl -> GetShaderStackSize(This,pExportName) ) -typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS - { - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type; - D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS Flags; - UINT NumDescs; - D3D12_ELEMENTS_LAYOUT DescsLayout; - union - { - D3D12_GPU_VIRTUAL_ADDRESS InstanceDescs; - const D3D12_RAYTRACING_GEOMETRY_DESC *pGeometryDescs; - const D3D12_RAYTRACING_GEOMETRY_DESC *const *ppGeometryDescs; - } ; - } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS; +#define ID3D12StateObjectProperties2_GetPipelineStackSize(This) \ + ( (This)->lpVtbl -> GetPipelineStackSize(This) ) -typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC - { - D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData; - D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS Inputs; - _In_opt_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData; - D3D12_GPU_VIRTUAL_ADDRESS ScratchAccelerationStructureData; - } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC; +#define ID3D12StateObjectProperties2_SetPipelineStackSize(This,PipelineStackSizeInBytes) \ + ( (This)->lpVtbl -> SetPipelineStackSize(This,PipelineStackSizeInBytes) ) -typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO - { - UINT64 ResultDataMaxSizeInBytes; - UINT64 ScratchDataSizeInBytes; - UINT64 UpdateScratchDataSizeInBytes; - } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO; +#if !defined(_WIN32) -typedef -enum D3D12_RAY_FLAGS +#define ID3D12StateObjectProperties2_GetProgramIdentifier(This,pProgramName) \ + ( (This)->lpVtbl -> GetProgramIdentifier(This,pProgramName) ) +#else +#define ID3D12StateObjectProperties2_GetProgramIdentifier(This,RetVal,pProgramName) \ + ( (This)->lpVtbl -> GetProgramIdentifier(This,RetVal,pProgramName) ) +#endif + + +#define ID3D12StateObjectProperties2_GetGlobalRootSignatureForProgram(This,pProgramName,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> GetGlobalRootSignatureForProgram(This,pProgramName,riid,ppvRootSignature) ) + +#define ID3D12StateObjectProperties2_GetGlobalRootSignatureForShader(This,pExportName,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> GetGlobalRootSignatureForShader(This,pExportName,riid,ppvRootSignature) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12StateObjectProperties2_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0038 */ +/* [local] */ + +typedef struct D3D12_NODE_ID { - D3D12_RAY_FLAG_NONE = 0, - D3D12_RAY_FLAG_FORCE_OPAQUE = 0x1, - D3D12_RAY_FLAG_FORCE_NON_OPAQUE = 0x2, - D3D12_RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH = 0x4, - D3D12_RAY_FLAG_SKIP_CLOSEST_HIT_SHADER = 0x8, - D3D12_RAY_FLAG_CULL_BACK_FACING_TRIANGLES = 0x10, - D3D12_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES = 0x20, - D3D12_RAY_FLAG_CULL_OPAQUE = 0x40, - D3D12_RAY_FLAG_CULL_NON_OPAQUE = 0x80, - D3D12_RAY_FLAG_SKIP_TRIANGLES = 0x100, - D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 0x200 - } D3D12_RAY_FLAGS; + LPCWSTR Name; + UINT ArrayIndex; + } D3D12_NODE_ID; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAY_FLAGS ); -typedef -enum D3D12_HIT_KIND +typedef struct D3D12_WORK_GRAPH_MEMORY_REQUIREMENTS { - D3D12_HIT_KIND_TRIANGLE_FRONT_FACE = 0xfe, - D3D12_HIT_KIND_TRIANGLE_BACK_FACE = 0xff - } D3D12_HIT_KIND; + UINT64 MinSizeInBytes; + UINT64 MaxSizeInBytes; + UINT SizeGranularityInBytes; + } D3D12_WORK_GRAPH_MEMORY_REQUIREMENTS; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0034_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0034_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0038_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0038_v0_0_s_ifspec; -#ifndef __ID3D12Device5_INTERFACE_DEFINED__ -#define __ID3D12Device5_INTERFACE_DEFINED__ +#ifndef __ID3D12WorkGraphProperties_INTERFACE_DEFINED__ +#define __ID3D12WorkGraphProperties_INTERFACE_DEFINED__ -/* interface ID3D12Device5 */ +/* interface ID3D12WorkGraphProperties */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12Device5; +EXTERN_C const IID IID_ID3D12WorkGraphProperties; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("8b4f173b-2fea-4b80-8f58-4307191ab95d") - ID3D12Device5 : public ID3D12Device4 + MIDL_INTERFACE("065acf71-f863-4b89-82f4-02e4d5886757") + ID3D12WorkGraphProperties : public IUnknown { public: - virtual HRESULT STDMETHODCALLTYPE CreateLifetimeTracker( - _In_ ID3D12LifetimeOwner *pOwner, - REFIID riid, - _COM_Outptr_ void **ppvTracker) = 0; + virtual UINT STDMETHODCALLTYPE GetNumWorkGraphs( void) = 0; - virtual void STDMETHODCALLTYPE RemoveDevice( void) = 0; + virtual LPCWSTR STDMETHODCALLTYPE GetProgramName( + UINT WorkGraphIndex) = 0; - virtual HRESULT STDMETHODCALLTYPE EnumerateMetaCommands( - _Inout_ UINT *pNumMetaCommands, - _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs) = 0; + virtual UINT STDMETHODCALLTYPE GetWorkGraphIndex( + LPCWSTR pProgramName) = 0; - virtual HRESULT STDMETHODCALLTYPE EnumerateMetaCommandParameters( - _In_ REFGUID CommandId, - _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, - _Out_opt_ UINT *pTotalStructureSizeInBytes, - _Inout_ UINT *pParameterCount, - _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs) = 0; + virtual UINT STDMETHODCALLTYPE GetNumNodes( + UINT WorkGraphIndex) = 0; - virtual HRESULT STDMETHODCALLTYPE CreateMetaCommand( - _In_ REFGUID CommandId, - _In_ UINT NodeMask, - _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, - _In_ SIZE_T CreationParametersDataSizeInBytes, - REFIID riid, - _COM_Outptr_ void **ppMetaCommand) = 0; +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) + virtual D3D12_NODE_ID STDMETHODCALLTYPE GetNodeID( + UINT WorkGraphIndex, + UINT NodeIndex) = 0; +#else + virtual D3D12_NODE_ID *STDMETHODCALLTYPE GetNodeID( + D3D12_NODE_ID * RetVal, + UINT WorkGraphIndex, + UINT NodeIndex) = 0; +#endif - virtual HRESULT STDMETHODCALLTYPE CreateStateObject( - const D3D12_STATE_OBJECT_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppStateObject) = 0; + virtual UINT STDMETHODCALLTYPE GetNodeIndex( + UINT WorkGraphIndex, + D3D12_NODE_ID NodeID) = 0; - virtual void STDMETHODCALLTYPE GetRaytracingAccelerationStructurePrebuildInfo( - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, - _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo) = 0; + virtual UINT STDMETHODCALLTYPE GetNodeLocalRootArgumentsTableIndex( + UINT WorkGraphIndex, + UINT NodeIndex) = 0; - virtual D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS STDMETHODCALLTYPE CheckDriverMatchingIdentifier( - _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, - _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck) = 0; + virtual UINT STDMETHODCALLTYPE GetNumEntrypoints( + UINT WorkGraphIndex) = 0; + +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) + virtual D3D12_NODE_ID STDMETHODCALLTYPE GetEntrypointID( + UINT WorkGraphIndex, + UINT EntrypointIndex) = 0; +#else + virtual D3D12_NODE_ID *STDMETHODCALLTYPE GetEntrypointID( + D3D12_NODE_ID * RetVal, + UINT WorkGraphIndex, + UINT EntrypointIndex) = 0; +#endif + + virtual UINT STDMETHODCALLTYPE GetEntrypointIndex( + UINT WorkGraphIndex, + D3D12_NODE_ID NodeID) = 0; + + virtual UINT STDMETHODCALLTYPE GetEntrypointRecordSizeInBytes( + UINT WorkGraphIndex, + UINT EntrypointIndex) = 0; + + virtual void STDMETHODCALLTYPE GetWorkGraphMemoryRequirements( + UINT WorkGraphIndex, + _Out_ D3D12_WORK_GRAPH_MEMORY_REQUIREMENTS *pWorkGraphMemoryRequirements) = 0; + + virtual UINT STDMETHODCALLTYPE GetEntrypointRecordAlignmentInBytes( + UINT WorkGraphIndex, + UINT EntrypointIndex) = 0; }; #else /* C style interface */ - typedef struct ID3D12Device5Vtbl + typedef struct ID3D12WorkGraphPropertiesVtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device5 * This, + ID3D12WorkGraphProperties * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device5 * This); + ID3D12WorkGraphProperties * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device5 * This); - - DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device5 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device5 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device5 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetName) - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device5 * This, - _In_z_ LPCWSTR Name); - - DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) - UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device5 * This); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device5 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) - HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device5 * This, - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) - HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device5 * This, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); + ID3D12WorkGraphProperties * This); - DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) - HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device5 * This, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); + DECLSPEC_XFGVIRT(ID3D12WorkGraphProperties, GetNumWorkGraphs) + UINT ( STDMETHODCALLTYPE *GetNumWorkGraphs )( + ID3D12WorkGraphProperties * This); - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) - HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device5 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, - REFIID riid, - _COM_Outptr_ void **ppCommandList); + DECLSPEC_XFGVIRT(ID3D12WorkGraphProperties, GetProgramName) + LPCWSTR ( STDMETHODCALLTYPE *GetProgramName )( + ID3D12WorkGraphProperties * This, + UINT WorkGraphIndex); - DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) - HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device5 * This, - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize); + DECLSPEC_XFGVIRT(ID3D12WorkGraphProperties, GetWorkGraphIndex) + UINT ( STDMETHODCALLTYPE *GetWorkGraphIndex )( + ID3D12WorkGraphProperties * This, + LPCWSTR pProgramName); - DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) - HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device5 * This, - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, - REFIID riid, - _COM_Outptr_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12WorkGraphProperties, GetNumNodes) + UINT ( STDMETHODCALLTYPE *GetNumNodes )( + ID3D12WorkGraphProperties * This, + UINT WorkGraphIndex); - DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) - UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device5 * This, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + DECLSPEC_XFGVIRT(ID3D12WorkGraphProperties, GetNodeID) +#if !defined(_WIN32) + D3D12_NODE_ID ( STDMETHODCALLTYPE *GetNodeID )( + ID3D12WorkGraphProperties * This, + UINT WorkGraphIndex, + UINT NodeIndex); - DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) - HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device5 * This, - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, - REFIID riid, - _COM_Outptr_ void **ppvRootSignature); +#else + D3D12_NODE_ID *( STDMETHODCALLTYPE *GetNodeID )( + ID3D12WorkGraphProperties * This, + D3D12_NODE_ID * RetVal, + UINT WorkGraphIndex, + UINT NodeIndex); - DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) - void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device5 * This, - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); +#endif - DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) - void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device5 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12WorkGraphProperties, GetNodeIndex) + UINT ( STDMETHODCALLTYPE *GetNodeIndex )( + ID3D12WorkGraphProperties * This, + UINT WorkGraphIndex, + D3D12_NODE_ID NodeID); - DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) - void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device5 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12WorkGraphProperties, GetNodeLocalRootArgumentsTableIndex) + UINT ( STDMETHODCALLTYPE *GetNodeLocalRootArgumentsTableIndex )( + ID3D12WorkGraphProperties * This, + UINT WorkGraphIndex, + UINT NodeIndex); - DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) - void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device5 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12WorkGraphProperties, GetNumEntrypoints) + UINT ( STDMETHODCALLTYPE *GetNumEntrypoints )( + ID3D12WorkGraphProperties * This, + UINT WorkGraphIndex); - DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) - void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device5 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12WorkGraphProperties, GetEntrypointID) +#if !defined(_WIN32) + D3D12_NODE_ID ( STDMETHODCALLTYPE *GetEntrypointID )( + ID3D12WorkGraphProperties * This, + UINT WorkGraphIndex, + UINT EntrypointIndex); - DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) - void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device5 * This, - _In_ const D3D12_SAMPLER_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); +#else + D3D12_NODE_ID *( STDMETHODCALLTYPE *GetEntrypointID )( + ID3D12WorkGraphProperties * This, + D3D12_NODE_ID * RetVal, + UINT WorkGraphIndex, + UINT EntrypointIndex); - DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) - void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device5 * This, - _In_ UINT NumDestDescriptorRanges, - _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, - _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, - _In_ UINT NumSrcDescriptorRanges, - _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, - _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); +#endif - DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) - void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device5 * This, - _In_ UINT NumDescriptors, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + DECLSPEC_XFGVIRT(ID3D12WorkGraphProperties, GetEntrypointIndex) + UINT ( STDMETHODCALLTYPE *GetEntrypointIndex )( + ID3D12WorkGraphProperties * This, + UINT WorkGraphIndex, + D3D12_NODE_ID NodeID); + + DECLSPEC_XFGVIRT(ID3D12WorkGraphProperties, GetEntrypointRecordSizeInBytes) + UINT ( STDMETHODCALLTYPE *GetEntrypointRecordSizeInBytes )( + ID3D12WorkGraphProperties * This, + UINT WorkGraphIndex, + UINT EntrypointIndex); + + DECLSPEC_XFGVIRT(ID3D12WorkGraphProperties, GetWorkGraphMemoryRequirements) + void ( STDMETHODCALLTYPE *GetWorkGraphMemoryRequirements )( + ID3D12WorkGraphProperties * This, + UINT WorkGraphIndex, + _Out_ D3D12_WORK_GRAPH_MEMORY_REQUIREMENTS *pWorkGraphMemoryRequirements); + + DECLSPEC_XFGVIRT(ID3D12WorkGraphProperties, GetEntrypointRecordAlignmentInBytes) + UINT ( STDMETHODCALLTYPE *GetEntrypointRecordAlignmentInBytes )( + ID3D12WorkGraphProperties * This, + UINT WorkGraphIndex, + UINT EntrypointIndex); - DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) + END_INTERFACE + } ID3D12WorkGraphPropertiesVtbl; + + interface ID3D12WorkGraphProperties + { + CONST_VTBL struct ID3D12WorkGraphPropertiesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12WorkGraphProperties_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12WorkGraphProperties_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12WorkGraphProperties_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12WorkGraphProperties_GetNumWorkGraphs(This) \ + ( (This)->lpVtbl -> GetNumWorkGraphs(This) ) + +#define ID3D12WorkGraphProperties_GetProgramName(This,WorkGraphIndex) \ + ( (This)->lpVtbl -> GetProgramName(This,WorkGraphIndex) ) + +#define ID3D12WorkGraphProperties_GetWorkGraphIndex(This,pProgramName) \ + ( (This)->lpVtbl -> GetWorkGraphIndex(This,pProgramName) ) + +#define ID3D12WorkGraphProperties_GetNumNodes(This,WorkGraphIndex) \ + ( (This)->lpVtbl -> GetNumNodes(This,WorkGraphIndex) ) #if !defined(_WIN32) - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device5 * This, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); - + +#define ID3D12WorkGraphProperties_GetNodeID(This,WorkGraphIndex,NodeIndex) \ + ( (This)->lpVtbl -> GetNodeID(This,WorkGraphIndex,NodeIndex) ) #else - D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device5 * This, - D3D12_RESOURCE_ALLOCATION_INFO * RetVal, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); - +#define ID3D12WorkGraphProperties_GetNodeID(This,RetVal,WorkGraphIndex,NodeIndex) \ + ( (This)->lpVtbl -> GetNodeID(This,RetVal,WorkGraphIndex,NodeIndex) ) #endif - - DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) + +#define ID3D12WorkGraphProperties_GetNodeIndex(This,WorkGraphIndex,NodeID) \ + ( (This)->lpVtbl -> GetNodeIndex(This,WorkGraphIndex,NodeID) ) + +#define ID3D12WorkGraphProperties_GetNodeLocalRootArgumentsTableIndex(This,WorkGraphIndex,NodeIndex) \ + ( (This)->lpVtbl -> GetNodeLocalRootArgumentsTableIndex(This,WorkGraphIndex,NodeIndex) ) + +#define ID3D12WorkGraphProperties_GetNumEntrypoints(This,WorkGraphIndex) \ + ( (This)->lpVtbl -> GetNumEntrypoints(This,WorkGraphIndex) ) #if !defined(_WIN32) - D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device5 * This, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); - + +#define ID3D12WorkGraphProperties_GetEntrypointID(This,WorkGraphIndex,EntrypointIndex) \ + ( (This)->lpVtbl -> GetEntrypointID(This,WorkGraphIndex,EntrypointIndex) ) #else - D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device5 * This, - D3D12_HEAP_PROPERTIES * RetVal, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); - +#define ID3D12WorkGraphProperties_GetEntrypointID(This,RetVal,WorkGraphIndex,EntrypointIndex) \ + ( (This)->lpVtbl -> GetEntrypointID(This,RetVal,WorkGraphIndex,EntrypointIndex) ) #endif - - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device5 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) - HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device5 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); - - DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device5 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device5 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + +#define ID3D12WorkGraphProperties_GetEntrypointIndex(This,WorkGraphIndex,NodeID) \ + ( (This)->lpVtbl -> GetEntrypointIndex(This,WorkGraphIndex,NodeID) ) + +#define ID3D12WorkGraphProperties_GetEntrypointRecordSizeInBytes(This,WorkGraphIndex,EntrypointIndex) \ + ( (This)->lpVtbl -> GetEntrypointRecordSizeInBytes(This,WorkGraphIndex,EntrypointIndex) ) + +#define ID3D12WorkGraphProperties_GetWorkGraphMemoryRequirements(This,WorkGraphIndex,pWorkGraphMemoryRequirements) \ + ( (This)->lpVtbl -> GetWorkGraphMemoryRequirements(This,WorkGraphIndex,pWorkGraphMemoryRequirements) ) + +#define ID3D12WorkGraphProperties_GetEntrypointRecordAlignmentInBytes(This,WorkGraphIndex,EntrypointIndex) \ + ( (This)->lpVtbl -> GetEntrypointRecordAlignmentInBytes(This,WorkGraphIndex,EntrypointIndex) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12WorkGraphProperties_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0039 */ +/* [local] */ + +typedef +enum D3D12_STATE_SUBOBJECT_TYPE + { + D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG = 0, + D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE = 1, + D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE = 2, + D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK = 3, + D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY = 5, + D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION = 6, + D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 7, + D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 8, + D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG = 9, + D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG = 10, + D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP = 11, + D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1 = 12, + D3D12_STATE_SUBOBJECT_TYPE_WORK_GRAPH = 13, + D3D12_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT = 14, + D3D12_STATE_SUBOBJECT_TYPE_BLEND = 15, + D3D12_STATE_SUBOBJECT_TYPE_SAMPLE_MASK = 16, + D3D12_STATE_SUBOBJECT_TYPE_RASTERIZER = 17, + D3D12_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL = 18, + D3D12_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT = 19, + D3D12_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE = 20, + D3D12_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY = 21, + D3D12_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS = 22, + D3D12_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT = 23, + D3D12_STATE_SUBOBJECT_TYPE_SAMPLE_DESC = 24, + D3D12_STATE_SUBOBJECT_TYPE_FLAGS = 26, + D3D12_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1 = 27, + D3D12_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING = 28, + D3D12_STATE_SUBOBJECT_TYPE_GENERIC_PROGRAM = 29, + D3D12_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL2 = 30, + D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_SERIALIZED_ROOT_SIGNATURE = 31, + D3D12_STATE_SUBOBJECT_TYPE_LOCAL_SERIALIZED_ROOT_SIGNATURE = 32, + D3D12_STATE_SUBOBJECT_TYPE_COMPILER_EXISITING_COLLECTION = 33, + D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION_BY_KEY = 36, + D3D12_STATE_SUBOBJECT_TYPE_MAX_VALID = ( D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION_BY_KEY + 1 ) + } D3D12_STATE_SUBOBJECT_TYPE; + +typedef struct D3D12_STATE_SUBOBJECT + { + D3D12_STATE_SUBOBJECT_TYPE Type; + const void *pDesc; + } D3D12_STATE_SUBOBJECT; + +typedef +enum D3D12_STATE_OBJECT_FLAGS + { + D3D12_STATE_OBJECT_FLAG_NONE = 0, + D3D12_STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS = 0x1, + D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS = 0x2, + D3D12_STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS = 0x4 + } D3D12_STATE_OBJECT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_STATE_OBJECT_FLAGS ) +typedef struct D3D12_STATE_OBJECT_CONFIG + { + D3D12_STATE_OBJECT_FLAGS Flags; + } D3D12_STATE_OBJECT_CONFIG; + +typedef struct D3D12_GLOBAL_ROOT_SIGNATURE + { + ID3D12RootSignature *pGlobalRootSignature; + } D3D12_GLOBAL_ROOT_SIGNATURE; + +typedef struct D3D12_LOCAL_ROOT_SIGNATURE + { + ID3D12RootSignature *pLocalRootSignature; + } D3D12_LOCAL_ROOT_SIGNATURE; + +typedef struct D3D12_NODE_MASK + { + UINT NodeMask; + } D3D12_NODE_MASK; + +typedef struct D3D12_SAMPLE_MASK + { + UINT SampleMask; + } D3D12_SAMPLE_MASK; + +typedef struct D3D12_IB_STRIP_CUT_VALUE + { + D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IndexBufferStripCutValue; + } D3D12_IB_STRIP_CUT_VALUE; + +typedef struct D3D12_PRIMITIVE_TOPOLOGY_DESC + { + D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopology; + } D3D12_PRIMITIVE_TOPOLOGY_DESC; + +typedef struct D3D12_DEPTH_STENCIL_FORMAT + { + DXGI_FORMAT DepthStencilFormat; + } D3D12_DEPTH_STENCIL_FORMAT; + +typedef +enum D3D12_EXPORT_FLAGS + { + D3D12_EXPORT_FLAG_NONE = 0 + } D3D12_EXPORT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_EXPORT_FLAGS ) +typedef struct D3D12_EXPORT_DESC + { + LPCWSTR Name; + _In_opt_ LPCWSTR ExportToRename; + D3D12_EXPORT_FLAGS Flags; + } D3D12_EXPORT_DESC; + +typedef struct D3D12_DXIL_LIBRARY_DESC + { + D3D12_SHADER_BYTECODE DXILLibrary; + UINT NumExports; + _In_reads_(NumExports) const D3D12_EXPORT_DESC *pExports; + } D3D12_DXIL_LIBRARY_DESC; + +typedef struct D3D12_EXISTING_COLLECTION_DESC + { + ID3D12StateObject *pExistingCollection; + UINT NumExports; + _In_reads_(NumExports) const D3D12_EXPORT_DESC *pExports; + } D3D12_EXISTING_COLLECTION_DESC; + +typedef struct D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION + { + const D3D12_STATE_SUBOBJECT *pSubobjectToAssociate; + UINT NumExports; + _In_reads_(NumExports) LPCWSTR *pExports; + } D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION; + +typedef struct D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION + { + LPCWSTR SubobjectToAssociate; + UINT NumExports; + _In_reads_(NumExports) LPCWSTR *pExports; + } D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION; + +typedef +enum D3D12_HIT_GROUP_TYPE + { + D3D12_HIT_GROUP_TYPE_TRIANGLES = 0, + D3D12_HIT_GROUP_TYPE_PROCEDURAL_PRIMITIVE = 0x1 + } D3D12_HIT_GROUP_TYPE; + +typedef struct D3D12_HIT_GROUP_DESC + { + LPCWSTR HitGroupExport; + D3D12_HIT_GROUP_TYPE Type; + _In_opt_ LPCWSTR AnyHitShaderImport; + _In_opt_ LPCWSTR ClosestHitShaderImport; + _In_opt_ LPCWSTR IntersectionShaderImport; + } D3D12_HIT_GROUP_DESC; + +typedef struct D3D12_RAYTRACING_SHADER_CONFIG + { + UINT MaxPayloadSizeInBytes; + UINT MaxAttributeSizeInBytes; + } D3D12_RAYTRACING_SHADER_CONFIG; + +typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG + { + UINT MaxTraceRecursionDepth; + } D3D12_RAYTRACING_PIPELINE_CONFIG; + +typedef +enum D3D12_RAYTRACING_PIPELINE_FLAGS + { + D3D12_RAYTRACING_PIPELINE_FLAG_NONE = 0, + D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_TRIANGLES = 0x100, + D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 0x200, + D3D12_RAYTRACING_PIPELINE_FLAG_ALLOW_OPACITY_MICROMAPS = 0x400 + } D3D12_RAYTRACING_PIPELINE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_PIPELINE_FLAGS ) +typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG1 + { + UINT MaxTraceRecursionDepth; + D3D12_RAYTRACING_PIPELINE_FLAGS Flags; + } D3D12_RAYTRACING_PIPELINE_CONFIG1; + +typedef struct D3D12_NODE_OUTPUT_OVERRIDES + { + UINT OutputIndex; + _In_opt_ const D3D12_NODE_ID *pNewName; + _In_opt_ const BOOL *pAllowSparseNodes; + _In_opt_ const UINT *pMaxRecords; + _In_opt_ const UINT *pMaxRecordsSharedWithOutputIndex; + } D3D12_NODE_OUTPUT_OVERRIDES; + +typedef struct D3D12_BROADCASTING_LAUNCH_OVERRIDES + { + _In_opt_ const UINT *pLocalRootArgumentsTableIndex; + _In_opt_ const BOOL *pProgramEntry; + _In_opt_ const D3D12_NODE_ID *pNewName; + _In_opt_ const D3D12_NODE_ID *pShareInputOf; + _In_reads_opt_(3) const UINT *pDispatchGrid; + _In_reads_opt_(3) const UINT *pMaxDispatchGrid; + UINT NumOutputOverrides; + _In_reads_opt_(NumOutputOverrides) const D3D12_NODE_OUTPUT_OVERRIDES *pOutputOverrides; + } D3D12_BROADCASTING_LAUNCH_OVERRIDES; + +typedef struct D3D12_COALESCING_LAUNCH_OVERRIDES + { + _In_opt_ const UINT *pLocalRootArgumentsTableIndex; + _In_opt_ const BOOL *pProgramEntry; + _In_opt_ const D3D12_NODE_ID *pNewName; + _In_opt_ const D3D12_NODE_ID *pShareInputOf; + UINT NumOutputOverrides; + _In_reads_opt_(NumOutputOverrides) const D3D12_NODE_OUTPUT_OVERRIDES *pOutputOverrides; + } D3D12_COALESCING_LAUNCH_OVERRIDES; + +typedef struct D3D12_THREAD_LAUNCH_OVERRIDES + { + _In_opt_ const UINT *pLocalRootArgumentsTableIndex; + _In_opt_ const BOOL *pProgramEntry; + _In_opt_ const D3D12_NODE_ID *pNewName; + _In_opt_ const D3D12_NODE_ID *pShareInputOf; + UINT NumOutputOverrides; + _In_reads_opt_(NumOutputOverrides) const D3D12_NODE_OUTPUT_OVERRIDES *pOutputOverrides; + } D3D12_THREAD_LAUNCH_OVERRIDES; + +typedef struct D3D12_COMMON_COMPUTE_NODE_OVERRIDES + { + _In_opt_ const UINT *pLocalRootArgumentsTableIndex; + _In_opt_ const BOOL *pProgramEntry; + _In_opt_ const D3D12_NODE_ID *pNewName; + _In_opt_ const D3D12_NODE_ID *pShareInputOf; + UINT NumOutputOverrides; + _In_reads_opt_(NumOutputOverrides) const D3D12_NODE_OUTPUT_OVERRIDES *pOutputOverrides; + } D3D12_COMMON_COMPUTE_NODE_OVERRIDES; + +typedef +enum D3D12_NODE_OVERRIDES_TYPE + { + D3D12_NODE_OVERRIDES_TYPE_NONE = 0, + D3D12_NODE_OVERRIDES_TYPE_BROADCASTING_LAUNCH = 1, + D3D12_NODE_OVERRIDES_TYPE_COALESCING_LAUNCH = 2, + D3D12_NODE_OVERRIDES_TYPE_THREAD_LAUNCH = 3, + D3D12_NODE_OVERRIDES_TYPE_COMMON_COMPUTE = 4 + } D3D12_NODE_OVERRIDES_TYPE; + +typedef struct D3D12_SHADER_NODE + { + LPCWSTR Shader; + D3D12_NODE_OVERRIDES_TYPE OverridesType; + union + { + const D3D12_BROADCASTING_LAUNCH_OVERRIDES *pBroadcastingLaunchOverrides; + const D3D12_COALESCING_LAUNCH_OVERRIDES *pCoalescingLaunchOverrides; + const D3D12_THREAD_LAUNCH_OVERRIDES *pThreadLaunchOverrides; + const D3D12_COMMON_COMPUTE_NODE_OVERRIDES *pCommonComputeNodeOverrides; + } ; + } D3D12_SHADER_NODE; + +typedef +enum D3D12_NODE_TYPE + { + D3D12_NODE_TYPE_SHADER = 0 + } D3D12_NODE_TYPE; + +typedef struct D3D12_NODE + { + D3D12_NODE_TYPE NodeType; + union + { + D3D12_SHADER_NODE Shader; + } ; + } D3D12_NODE; + +typedef +enum D3D12_WORK_GRAPH_FLAGS + { + D3D12_WORK_GRAPH_FLAG_NONE = 0, + D3D12_WORK_GRAPH_FLAG_INCLUDE_ALL_AVAILABLE_NODES = 0x1 + } D3D12_WORK_GRAPH_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_WORK_GRAPH_FLAGS ) +typedef struct D3D12_WORK_GRAPH_DESC + { + LPCWSTR ProgramName; + D3D12_WORK_GRAPH_FLAGS Flags; + UINT NumEntrypoints; + _In_reads_opt_(NumEntrypoints) const D3D12_NODE_ID *pEntrypoints; + UINT NumExplicitlyDefinedNodes; + _In_reads_opt_(NumExplicitlyDefinedNodes) const D3D12_NODE *pExplicitlyDefinedNodes; + } D3D12_WORK_GRAPH_DESC; + +typedef struct D3D12_GENERIC_PROGRAM_DESC + { + LPCWSTR ProgramName; + UINT NumExports; + _In_reads_(NumExports) LPCWSTR *pExports; + UINT NumSubobjects; + _In_reads_opt_(NumSubobjects) const D3D12_STATE_SUBOBJECT *const *ppSubobjects; + } D3D12_GENERIC_PROGRAM_DESC; + +typedef +enum D3D12_STATE_OBJECT_TYPE + { + D3D12_STATE_OBJECT_TYPE_COLLECTION = 0, + D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE = 3, + D3D12_STATE_OBJECT_TYPE_EXECUTABLE = 4 + } D3D12_STATE_OBJECT_TYPE; + +typedef struct D3D12_STATE_OBJECT_DESC + { + D3D12_STATE_OBJECT_TYPE Type; + UINT NumSubobjects; + _In_reads_(NumSubobjects) const D3D12_STATE_SUBOBJECT *pSubobjects; + } D3D12_STATE_OBJECT_DESC; + +typedef +enum D3D12_RAYTRACING_GEOMETRY_FLAGS + { + D3D12_RAYTRACING_GEOMETRY_FLAG_NONE = 0, + D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE = 0x1, + D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION = 0x2 + } D3D12_RAYTRACING_GEOMETRY_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_GEOMETRY_FLAGS ) +typedef +enum D3D12_RAYTRACING_GEOMETRY_TYPE + { + D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES = 0, + D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS = ( D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES + 1 ) , + D3D12_RAYTRACING_GEOMETRY_TYPE_OMM_TRIANGLES = ( D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS + 1 ) + } D3D12_RAYTRACING_GEOMETRY_TYPE; + +typedef +enum D3D12_RAYTRACING_INSTANCE_FLAGS + { + D3D12_RAYTRACING_INSTANCE_FLAG_NONE = 0, + D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE = 0x1, + D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE = 0x2, + D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE = 0x4, + D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE = 0x8, + D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OMM_2_STATE = 0x10, + D3D12_RAYTRACING_INSTANCE_FLAG_DISABLE_OMMS = 0x20 + } D3D12_RAYTRACING_INSTANCE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_INSTANCE_FLAGS ) +typedef struct D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE + { + D3D12_GPU_VIRTUAL_ADDRESS StartAddress; + UINT64 StrideInBytes; + } D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE; + +typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE + { + D3D12_GPU_VIRTUAL_ADDRESS StartAddress; + UINT64 SizeInBytes; + } D3D12_GPU_VIRTUAL_ADDRESS_RANGE; + +typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE + { + D3D12_GPU_VIRTUAL_ADDRESS StartAddress; + UINT64 SizeInBytes; + UINT64 StrideInBytes; + } D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE; + +typedef struct D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC + { + D3D12_GPU_VIRTUAL_ADDRESS Transform3x4; + DXGI_FORMAT IndexFormat; + DXGI_FORMAT VertexFormat; + UINT IndexCount; + UINT VertexCount; + D3D12_GPU_VIRTUAL_ADDRESS IndexBuffer; + D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE VertexBuffer; + } D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC; + +typedef struct D3D12_RAYTRACING_AABB + { + FLOAT MinX; + FLOAT MinY; + FLOAT MinZ; + FLOAT MaxX; + FLOAT MaxY; + FLOAT MaxZ; + } D3D12_RAYTRACING_AABB; + +typedef struct D3D12_RAYTRACING_GEOMETRY_AABBS_DESC + { + UINT64 AABBCount; + D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE AABBs; + } D3D12_RAYTRACING_GEOMETRY_AABBS_DESC; + +typedef +enum D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX + { + D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT = -1, + D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE = -2, + D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT = -3, + D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE = -4 + } D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX; + +typedef +enum D3D12_RAYTRACING_OPACITY_MICROMAP_STATE + { + D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_TRANSPARENT = 0, + D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_OPAQUE = 1, + D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_UNKNOWN_TRANSPARENT = 2, + D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_UNKNOWN_OPAQUE = 3 + } D3D12_RAYTRACING_OPACITY_MICROMAP_STATE; + +typedef +enum D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT + { + D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT_OC1_2_STATE = 0x1, + D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT_OC1_4_STATE = 0x2 + } D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT; + +typedef struct D3D12_RAYTRACING_OPACITY_MICROMAP_DESC +{ + UINT ByteOffset; + UINT SubdivisionLevel : 16; + D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT Format : 16; +} D3D12_RAYTRACING_OPACITY_MICROMAP_DESC; +typedef struct D3D12_RAYTRACING_GEOMETRY_OMM_LINKAGE_DESC + { + D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE OpacityMicromapIndexBuffer; + DXGI_FORMAT OpacityMicromapIndexFormat; + UINT OpacityMicromapBaseLocation; + D3D12_GPU_VIRTUAL_ADDRESS OpacityMicromapArray; + } D3D12_RAYTRACING_GEOMETRY_OMM_LINKAGE_DESC; + +typedef struct D3D12_RAYTRACING_GEOMETRY_OMM_TRIANGLES_DESC + { + const D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC *pTriangles; + const D3D12_RAYTRACING_GEOMETRY_OMM_LINKAGE_DESC *pOmmLinkage; + } D3D12_RAYTRACING_GEOMETRY_OMM_TRIANGLES_DESC; + +typedef +enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS + { + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE = 0, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE = 0x1, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION = 0x2, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE = 0x4, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD = 0x8, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY = 0x10, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE = 0x20, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_OMM_UPDATE = 0x40, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_DISABLE_OMMS = 0x80 + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS ) +typedef +enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE + { + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE = 0, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT = 0x1, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_VISUALIZATION_DECODE_FOR_TOOLS = 0x2, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_SERIALIZE = 0x3, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE = 0x4 + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE; + +typedef +enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE + { + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL = 0, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL = 0x1, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_OPACITY_MICROMAP_ARRAY = 0x2 + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE; + +typedef +enum D3D12_ELEMENTS_LAYOUT + { + D3D12_ELEMENTS_LAYOUT_ARRAY = 0, + D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS = 0x1 + } D3D12_ELEMENTS_LAYOUT; + +typedef +enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE + { + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE = 0, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION = 0x1, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION = 0x2, + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE = 0x3 + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC + { + D3D12_GPU_VIRTUAL_ADDRESS DestBuffer; + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE InfoType; + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC + { + UINT64 CompactedSizeInBytes; + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC + { + UINT64 DecodedSizeInBytes; + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC; + +typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER + { + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type; + UINT NumDescs; + } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER; + +// Regarding D3D12_BUILD_RAY_TRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER above, +// depending on Type field, NumDescs above is followed by either: +// D3D12_RAY_TRACING_INSTANCE_DESC InstanceDescs[NumDescs] +// or D3D12_RAY_TRACING_GEOMETRY_DESC GeometryDescs[NumDescs]. +// or D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_DESC (NumDescs == 1 in this case). +// +// For D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_DESC, the pOmmHistogram pointer becomes a GPUVA instead of CPU pointer +// +// There is 4 bytes of padding between GeometryDesc structs in the array so alignment is natural when viewed by CPU. + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC + { + UINT64 SerializedSizeInBytes; + union + { + UINT64 NumBottomLevelAccelerationStructurePointers; + UINT64 NumBottomLevelAccelerationStructureHeaderAndPointerListPairs; + } ; + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC; + +typedef struct D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER + { + GUID DriverOpaqueGUID; + BYTE DriverOpaqueVersioningData[ 16 ]; + } D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER; + +typedef +enum D3D12_SERIALIZED_DATA_TYPE + { + D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE = 0, + D3D12_SERIALIZED_DATA_APPLICATION_SPECIFIC_DRIVER_STATE = 0x1 + } D3D12_SERIALIZED_DATA_TYPE; + +typedef +enum D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS + { + D3D12_DRIVER_MATCHING_IDENTIFIER_COMPATIBLE_WITH_DEVICE = 0, + D3D12_DRIVER_MATCHING_IDENTIFIER_UNSUPPORTED_TYPE = 0x1, + D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED = 0x2, + D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_VERSION = 0x3, + D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_TYPE = 0x4 + } D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS; + +typedef struct D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER + { + D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER DriverMatchingIdentifier; + UINT64 SerializedSizeInBytesIncludingHeader; + UINT64 DeserializedSizeInBytes; + UINT64 NumBottomLevelAccelerationStructurePointersAfterHeader; + } D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER; + +typedef +enum D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE + { + D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE_NONE = 0, + D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE_BOTTOM_LEVEL_POINTERS = 0, + D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE_BLOCKS = 0xffffffff + } D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE; + +typedef struct D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER1 + { + D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER DriverMatchingIdentifier; + UINT64 SerializedSizeInBytesIncludingHeader; + UINT64 DeserializedSizeInBytes; + union + { + UINT NumBottomLevelAccelerationStructurePointersAfterHeader; + UINT NumBlocks; + } ; + D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER_POSTAMBLE_TYPE HeaderPostambleType; + } D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER1; + +typedef +enum D3D12_SERIALIZED_BLOCK_TYPE + { + D3D12_RAYTRACING_SERIALIZED_BLOCK_TYPE_OPACITY_MICROMAPS = 0 + } D3D12_RAYTRACING_SERIALIZED_BLOCK_TYPE; + +typedef struct D3D12_RAYTRACING_SERIALIZED_BLOCK + { + D3D12_RAYTRACING_SERIALIZED_BLOCK_TYPE Type; + UINT64 NumBlockPointersAfterHeader; + } D3D12_RAYTRACING_SERIALIZED_BLOCK; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC + { + UINT64 CurrentSizeInBytes; + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC; + +typedef struct D3D12_RAYTRACING_INSTANCE_DESC + { + FLOAT Transform[ 3 ][ 4 ]; + UINT InstanceID : 24; + UINT InstanceMask : 8; + UINT InstanceContributionToHitGroupIndex : 24; + UINT Flags : 8; + D3D12_GPU_VIRTUAL_ADDRESS AccelerationStructure; + } D3D12_RAYTRACING_INSTANCE_DESC; + +typedef struct D3D12_RAYTRACING_GEOMETRY_DESC + { + D3D12_RAYTRACING_GEOMETRY_TYPE Type; + D3D12_RAYTRACING_GEOMETRY_FLAGS Flags; + union + { + D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC Triangles; + D3D12_RAYTRACING_GEOMETRY_AABBS_DESC AABBs; + D3D12_RAYTRACING_GEOMETRY_OMM_TRIANGLES_DESC OmmTriangles; + } ; + } D3D12_RAYTRACING_GEOMETRY_DESC; + +typedef struct D3D12_RAYTRACING_OPACITY_MICROMAP_HISTOGRAM_ENTRY + { + UINT Count; + UINT SubdivisionLevel; + D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT Format; + } D3D12_RAYTRACING_OPACITY_MICROMAP_HISTOGRAM_ENTRY; + +typedef struct D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_DESC + { + UINT NumOmmHistogramEntries; + const D3D12_RAYTRACING_OPACITY_MICROMAP_HISTOGRAM_ENTRY *pOmmHistogram; + D3D12_GPU_VIRTUAL_ADDRESS InputBuffer; + D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE PerOmmDescs; + } D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_DESC; + +typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS + { + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type; + D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS Flags; + UINT NumDescs; + D3D12_ELEMENTS_LAYOUT DescsLayout; + union + { + D3D12_GPU_VIRTUAL_ADDRESS InstanceDescs; + const D3D12_RAYTRACING_GEOMETRY_DESC *pGeometryDescs; + const D3D12_RAYTRACING_GEOMETRY_DESC *const *ppGeometryDescs; + const D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_DESC *pOpacityMicromapArrayDesc; + } ; + } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS; + +typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC + { + D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData; + D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS Inputs; + _In_opt_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData; + D3D12_GPU_VIRTUAL_ADDRESS ScratchAccelerationStructureData; + } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC; + +typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO + { + UINT64 ResultDataMaxSizeInBytes; + UINT64 ScratchDataSizeInBytes; + UINT64 UpdateScratchDataSizeInBytes; + } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO; + +typedef +enum D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TYPE + { + D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE = 0, + D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TOOLS_VISUALIZATION = 0x1 + } D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TYPE; + +typedef struct D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_DESC + { + D3D12_GPU_VIRTUAL_ADDRESS DestBuffer; + D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TYPE InfoType; + } D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_DESC; + +typedef struct D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE_DESC + { + UINT64 CurrentSizeInBytes; + } D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE_DESC; + +typedef struct D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC + { + UINT64 DecodedSizeInBytes; + } D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC; + +typedef +enum D3D12_RAY_FLAGS + { + D3D12_RAY_FLAG_NONE = 0, + D3D12_RAY_FLAG_FORCE_OPAQUE = 0x1, + D3D12_RAY_FLAG_FORCE_NON_OPAQUE = 0x2, + D3D12_RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH = 0x4, + D3D12_RAY_FLAG_SKIP_CLOSEST_HIT_SHADER = 0x8, + D3D12_RAY_FLAG_CULL_BACK_FACING_TRIANGLES = 0x10, + D3D12_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES = 0x20, + D3D12_RAY_FLAG_CULL_OPAQUE = 0x40, + D3D12_RAY_FLAG_CULL_NON_OPAQUE = 0x80, + D3D12_RAY_FLAG_SKIP_TRIANGLES = 0x100, + D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 0x200, + D3D12_RAY_FLAG_FORCE_OMM_2_STATE = 0x400 + } D3D12_RAY_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAY_FLAGS ) +typedef +enum D3D12_HIT_KIND + { + D3D12_HIT_KIND_TRIANGLE_FRONT_FACE = 0xfe, + D3D12_HIT_KIND_TRIANGLE_BACK_FACE = 0xff + } D3D12_HIT_KIND; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0039_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0039_v0_0_s_ifspec; + +#ifndef __ID3D12Device5_INTERFACE_DEFINED__ +#define __ID3D12Device5_INTERFACE_DEFINED__ + +/* interface ID3D12Device5 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Device5; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8b4f173b-2fea-4b80-8f58-4307191ab95d") + ID3D12Device5 : public ID3D12Device4 + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateLifetimeTracker( + _In_ ID3D12LifetimeOwner *pOwner, + REFIID riid, + _COM_Outptr_ void **ppvTracker) = 0; + + virtual void STDMETHODCALLTYPE RemoveDevice( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumerateMetaCommands( + _Inout_ UINT *pNumMetaCommands, + _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumerateMetaCommandParameters( + _In_ REFGUID CommandId, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _Out_opt_ UINT *pTotalStructureSizeInBytes, + _Inout_ UINT *pParameterCount, + _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateMetaCommand( + _In_ REFGUID CommandId, + _In_ UINT NodeMask, + _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, + _In_ SIZE_T CreationParametersDataSizeInBytes, + REFIID riid, + _COM_Outptr_ void **ppMetaCommand) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateStateObject( + const D3D12_STATE_OBJECT_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppStateObject) = 0; + + virtual void STDMETHODCALLTYPE GetRaytracingAccelerationStructurePrebuildInfo( + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, + _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo) = 0; + + virtual D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS STDMETHODCALLTYPE CheckDriverMatchingIdentifier( + _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, + _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Device5Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Device5 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Device5 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Device5 * This); + + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Device5 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Device5 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Device5 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Device5 * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device5 * This); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device5 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device5 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device5 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device5 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device5 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device5 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device5 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device5 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device5 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device5 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device5 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device5 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device5 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device5 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device5 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device5 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device5 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device5 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device5 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) +#if !defined(_WIN32) + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device5 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#else + D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device5 * This, + D3D12_HEAP_PROPERTIES * RetVal, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device5 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device5 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device5 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device5 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device5 * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); + + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device5 * This, + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj); + + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device5 * This, + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle); + + DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device5 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + DECLSPEC_XFGVIRT(ID3D12Device, Evict) + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device5 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device5 * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); + + DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device5 * This); + + DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device5 * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device5 * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device5 * This, + BOOL Enable); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device5 * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); + + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device5 * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + + DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) +#if !defined(_WIN32) + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device5 * This); + +#else + LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device5 * This, + LUID * RetVal); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( + ID3D12Device5 * This, + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary); + + DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) + HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( + ID3D12Device5 * This, + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent); + + DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) + HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( + ID3D12Device5 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + + DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( + ID3D12Device5 * This, + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( + ID3D12Device5 * This, + _In_ const void *pAddress, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( + ID3D12Device5 * This, + _In_ HANDLE hFileMapping, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) + HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( + ID3D12Device5 * This, + D3D12_RESIDENCY_FLAGS Flags, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_ ID3D12Fence *pFenceToSignal, + UINT64 FenceValueToSignal); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( + ID3D12Device5 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ D3D12_COMMAND_LIST_FLAGS flags, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( + ID3D12Device5 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( + ID3D12Device5 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) + HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( + ID3D12Device5 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( + ID3D12Device5 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device5 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device5 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) + HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( + ID3D12Device5 * This, + _In_ ID3D12LifetimeOwner *pOwner, + REFIID riid, + _COM_Outptr_ void **ppvTracker); + + DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) + void ( STDMETHODCALLTYPE *RemoveDevice )( + ID3D12Device5 * This); + + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( + ID3D12Device5 * This, + _Inout_ UINT *pNumMetaCommands, + _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); + + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( + ID3D12Device5 * This, + _In_ REFGUID CommandId, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _Out_opt_ UINT *pTotalStructureSizeInBytes, + _Inout_ UINT *pParameterCount, + _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); + + DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) + HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( + ID3D12Device5 * This, + _In_ REFGUID CommandId, + _In_ UINT NodeMask, + _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, + _In_ SIZE_T CreationParametersDataSizeInBytes, + REFIID riid, + _COM_Outptr_ void **ppMetaCommand); + + DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) + HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( + ID3D12Device5 * This, + const D3D12_STATE_OBJECT_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppStateObject); + + DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) + void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( + ID3D12Device5 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, + _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); + + DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) + D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( + ID3D12Device5 * This, + _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, + _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); + + END_INTERFACE + } ID3D12Device5Vtbl; + + interface ID3D12Device5 + { + CONST_VTBL struct ID3D12Device5Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Device5_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Device5_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Device5_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Device5_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Device5_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Device5_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Device5_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Device5_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) + +#define ID3D12Device5_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) + +#define ID3D12Device5_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) + +#define ID3D12Device5_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device5_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device5_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) + +#define ID3D12Device5_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) + +#define ID3D12Device5_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) + +#define ID3D12Device5_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) + +#define ID3D12Device5_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) + +#define ID3D12Device5_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) + +#define ID3D12Device5_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device5_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) + +#define ID3D12Device5_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device5_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device5_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) + +#define ID3D12Device5_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) + +#define ID3D12Device5_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) +#if !defined(_WIN32) + +#define ID3D12Device5_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) +#else +#define ID3D12Device5_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) +#endif +#if !defined(_WIN32) + +#define ID3D12Device5_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) +#else +#define ID3D12Device5_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) +#endif + +#define ID3D12Device5_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) + +#define ID3D12Device5_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device5_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device5_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device5_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) + +#define ID3D12Device5_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) + +#define ID3D12Device5_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) + +#define ID3D12Device5_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) + +#define ID3D12Device5_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) + +#define ID3D12Device5_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) + +#define ID3D12Device5_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) + +#define ID3D12Device5_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + +#define ID3D12Device5_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device5_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) + +#define ID3D12Device5_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) + +#define ID3D12Device5_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) +#if !defined(_WIN32) + +#define ID3D12Device5_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) +#else +#define ID3D12Device5_GetAdapterLuid(This,RetVal) \ + ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) +#endif + + +#define ID3D12Device5_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) + +#define ID3D12Device5_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) + +#define ID3D12Device5_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) + + +#define ID3D12Device5_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) + + +#define ID3D12Device5_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) + +#define ID3D12Device5_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) + +#define ID3D12Device5_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ + ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) + + +#define ID3D12Device5_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) + +#define ID3D12Device5_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) + +#define ID3D12Device5_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) + +#define ID3D12Device5_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) + +#define ID3D12Device5_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) +#if !defined(_WIN32) + +#define ID3D12Device5_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device5_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif + + +#define ID3D12Device5_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ + ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) + +#define ID3D12Device5_RemoveDevice(This) \ + ( (This)->lpVtbl -> RemoveDevice(This) ) + +#define ID3D12Device5_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) + +#define ID3D12Device5_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) + +#define ID3D12Device5_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ + ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) + +#define ID3D12Device5_CreateStateObject(This,pDesc,riid,ppStateObject) \ + ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) + +#define ID3D12Device5_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ + ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) + +#define ID3D12Device5_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ + ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Device5_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0040 */ +/* [local] */ + +typedef +enum D3D12_MARKER_API + { + D3D12_MARKER_API_SETMARKER = 0, + D3D12_MARKER_API_BEGINEVENT = 1, + D3D12_MARKER_API_ENDEVENT = 2, + D3D12_MARKER_API_DRAWINSTANCED = 3, + D3D12_MARKER_API_DRAWINDEXEDINSTANCED = 4, + D3D12_MARKER_API_EXECUTEINDIRECT = 5, + D3D12_MARKER_API_DISPATCH = 6, + D3D12_MARKER_API_COPYBUFFERREGION = 7, + D3D12_MARKER_API_COPYTEXTUREREGION = 8, + D3D12_MARKER_API_COPYRESOURCE = 9, + D3D12_MARKER_API_COPYTILES = 10, + D3D12_MARKER_API_RESOLVESUBRESOURCE = 11, + D3D12_MARKER_API_CLEARRENDERTARGETVIEW = 12, + D3D12_MARKER_API_CLEARUNORDEREDACCESSVIEW = 13, + D3D12_MARKER_API_CLEARDEPTHSTENCILVIEW = 14, + D3D12_MARKER_API_RESOURCEBARRIER = 15, + D3D12_MARKER_API_EXECUTEBUNDLE = 16, + D3D12_MARKER_API_PRESENT = 17, + D3D12_MARKER_API_RESOLVEQUERYDATA = 18, + D3D12_MARKER_API_BEGINSUBMISSION = 19, + D3D12_MARKER_API_ENDSUBMISSION = 20, + D3D12_MARKER_API_DECODEFRAME = 21, + D3D12_MARKER_API_PROCESSFRAMES = 22, + D3D12_MARKER_API_ATOMICCOPYBUFFERUINT = 23, + D3D12_MARKER_API_ATOMICCOPYBUFFERUINT64 = 24, + D3D12_MARKER_API_RESOLVESUBRESOURCEREGION = 25, + D3D12_MARKER_API_WRITEBUFFERIMMEDIATE = 26, + D3D12_MARKER_API_DECODEFRAME1 = 27, + D3D12_MARKER_API_SETPROTECTEDRESOURCESESSION = 28, + D3D12_MARKER_API_DECODEFRAME2 = 29, + D3D12_MARKER_API_PROCESSFRAMES1 = 30, + D3D12_MARKER_API_BUILDRAYTRACINGACCELERATIONSTRUCTURE = 31, + D3D12_MARKER_API_EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO = 32, + D3D12_MARKER_API_COPYRAYTRACINGACCELERATIONSTRUCTURE = 33, + D3D12_MARKER_API_DISPATCHRAYS = 34, + D3D12_MARKER_API_INITIALIZEMETACOMMAND = 35, + D3D12_MARKER_API_EXECUTEMETACOMMAND = 36, + D3D12_MARKER_API_ESTIMATEMOTION = 37, + D3D12_MARKER_API_RESOLVEMOTIONVECTORHEAP = 38, + D3D12_MARKER_API_SETPIPELINESTATE1 = 39, + D3D12_MARKER_API_INITIALIZEEXTENSIONCOMMAND = 40, + D3D12_MARKER_API_EXECUTEEXTENSIONCOMMAND = 41, + D3D12_MARKER_API_DISPATCHMESH = 42, + D3D12_MARKER_API_ENCODEFRAME = 43, + D3D12_MARKER_API_RESOLVEENCODEROUTPUTMETADATA = 44, + D3D12_MARKER_API_BARRIER = 45, + D3D12_MARKER_API_BEGIN_COMMAND_LIST = 46, + D3D12_MARKER_API_DISPATCHGRAPH = 47, + D3D12_MARKER_API_SETPROGRAM = 48, + D3D12_MARKER_API_ENCODEFRAME1 = 49, + D3D12_MARKER_API_RESOLVEENCODEROUTPUTMETADATA1 = 50, + D3D12_MARKER_API_RESOLVEINPUTPARAMLAYOUT = 51, + D3D12_MARKER_API_PROCESSFRAMES2 = 52, + D3D12_MARKER_API_SET_WORK_GRAPH_MAXIMUM_GPU_INPUT_RECORDS = 53 + } D3D12_MARKER_API; + +typedef +enum D3D12_AUTO_BREADCRUMB_OP + { + D3D12_AUTO_BREADCRUMB_OP_SETMARKER = D3D12_MARKER_API_SETMARKER, + D3D12_AUTO_BREADCRUMB_OP_BEGINEVENT = D3D12_MARKER_API_BEGINEVENT, + D3D12_AUTO_BREADCRUMB_OP_ENDEVENT = D3D12_MARKER_API_ENDEVENT, + D3D12_AUTO_BREADCRUMB_OP_DRAWINSTANCED = D3D12_MARKER_API_DRAWINSTANCED, + D3D12_AUTO_BREADCRUMB_OP_DRAWINDEXEDINSTANCED = D3D12_MARKER_API_DRAWINDEXEDINSTANCED, + D3D12_AUTO_BREADCRUMB_OP_EXECUTEINDIRECT = D3D12_MARKER_API_EXECUTEINDIRECT, + D3D12_AUTO_BREADCRUMB_OP_DISPATCH = D3D12_MARKER_API_DISPATCH, + D3D12_AUTO_BREADCRUMB_OP_COPYBUFFERREGION = D3D12_MARKER_API_COPYBUFFERREGION, + D3D12_AUTO_BREADCRUMB_OP_COPYTEXTUREREGION = D3D12_MARKER_API_COPYTEXTUREREGION, + D3D12_AUTO_BREADCRUMB_OP_COPYRESOURCE = D3D12_MARKER_API_COPYRESOURCE, + D3D12_AUTO_BREADCRUMB_OP_COPYTILES = D3D12_MARKER_API_COPYTILES, + D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCE = D3D12_MARKER_API_RESOLVESUBRESOURCE, + D3D12_AUTO_BREADCRUMB_OP_CLEARRENDERTARGETVIEW = D3D12_MARKER_API_CLEARRENDERTARGETVIEW, + D3D12_AUTO_BREADCRUMB_OP_CLEARUNORDEREDACCESSVIEW = D3D12_MARKER_API_CLEARUNORDEREDACCESSVIEW, + D3D12_AUTO_BREADCRUMB_OP_CLEARDEPTHSTENCILVIEW = D3D12_MARKER_API_CLEARDEPTHSTENCILVIEW, + D3D12_AUTO_BREADCRUMB_OP_RESOURCEBARRIER = D3D12_MARKER_API_RESOURCEBARRIER, + D3D12_AUTO_BREADCRUMB_OP_EXECUTEBUNDLE = D3D12_MARKER_API_EXECUTEBUNDLE, + D3D12_AUTO_BREADCRUMB_OP_PRESENT = D3D12_MARKER_API_PRESENT, + D3D12_AUTO_BREADCRUMB_OP_RESOLVEQUERYDATA = D3D12_MARKER_API_RESOLVEQUERYDATA, + D3D12_AUTO_BREADCRUMB_OP_BEGINSUBMISSION = D3D12_MARKER_API_BEGINSUBMISSION, + D3D12_AUTO_BREADCRUMB_OP_ENDSUBMISSION = D3D12_MARKER_API_ENDSUBMISSION, + D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME = D3D12_MARKER_API_DECODEFRAME, + D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES = D3D12_MARKER_API_PROCESSFRAMES, + D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT = D3D12_MARKER_API_ATOMICCOPYBUFFERUINT, + D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT64 = D3D12_MARKER_API_ATOMICCOPYBUFFERUINT64, + D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCEREGION = D3D12_MARKER_API_RESOLVESUBRESOURCEREGION, + D3D12_AUTO_BREADCRUMB_OP_WRITEBUFFERIMMEDIATE = D3D12_MARKER_API_WRITEBUFFERIMMEDIATE, + D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME1 = D3D12_MARKER_API_DECODEFRAME1, + D3D12_AUTO_BREADCRUMB_OP_SETPROTECTEDRESOURCESESSION = D3D12_MARKER_API_SETPROTECTEDRESOURCESESSION, + D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME2 = D3D12_MARKER_API_DECODEFRAME2, + D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES1 = D3D12_MARKER_API_PROCESSFRAMES1, + D3D12_AUTO_BREADCRUMB_OP_BUILDRAYTRACINGACCELERATIONSTRUCTURE = D3D12_MARKER_API_BUILDRAYTRACINGACCELERATIONSTRUCTURE, + D3D12_AUTO_BREADCRUMB_OP_EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO = D3D12_MARKER_API_EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO, + D3D12_AUTO_BREADCRUMB_OP_COPYRAYTRACINGACCELERATIONSTRUCTURE = D3D12_MARKER_API_COPYRAYTRACINGACCELERATIONSTRUCTURE, + D3D12_AUTO_BREADCRUMB_OP_DISPATCHRAYS = D3D12_MARKER_API_DISPATCHRAYS, + D3D12_AUTO_BREADCRUMB_OP_INITIALIZEMETACOMMAND = D3D12_MARKER_API_INITIALIZEMETACOMMAND, + D3D12_AUTO_BREADCRUMB_OP_EXECUTEMETACOMMAND = D3D12_MARKER_API_EXECUTEMETACOMMAND, + D3D12_AUTO_BREADCRUMB_OP_ESTIMATEMOTION = D3D12_MARKER_API_ESTIMATEMOTION, + D3D12_AUTO_BREADCRUMB_OP_RESOLVEMOTIONVECTORHEAP = D3D12_MARKER_API_RESOLVEMOTIONVECTORHEAP, + D3D12_AUTO_BREADCRUMB_OP_SETPIPELINESTATE1 = D3D12_MARKER_API_SETPIPELINESTATE1, + D3D12_AUTO_BREADCRUMB_OP_INITIALIZEEXTENSIONCOMMAND = D3D12_MARKER_API_INITIALIZEEXTENSIONCOMMAND, + D3D12_AUTO_BREADCRUMB_OP_EXECUTEEXTENSIONCOMMAND = D3D12_MARKER_API_EXECUTEEXTENSIONCOMMAND, + D3D12_AUTO_BREADCRUMB_OP_DISPATCHMESH = D3D12_MARKER_API_DISPATCHMESH, + D3D12_AUTO_BREADCRUMB_OP_ENCODEFRAME = D3D12_MARKER_API_ENCODEFRAME, + D3D12_AUTO_BREADCRUMB_OP_RESOLVEENCODEROUTPUTMETADATA = D3D12_MARKER_API_RESOLVEENCODEROUTPUTMETADATA, + D3D12_AUTO_BREADCRUMB_OP_BARRIER = D3D12_MARKER_API_BARRIER, + D3D12_AUTO_BREADCRUMB_OP_BEGIN_COMMAND_LIST = D3D12_MARKER_API_BEGIN_COMMAND_LIST, + D3D12_AUTO_BREADCRUMB_OP_DISPATCHGRAPH = D3D12_MARKER_API_DISPATCHGRAPH, + D3D12_AUTO_BREADCRUMB_OP_SETPROGRAM = D3D12_MARKER_API_SETPROGRAM, + D3D12_AUTO_BREADCRUMB_OP_ENCODEFRAME1 = D3D12_MARKER_API_ENCODEFRAME1, + D3D12_AUTO_BREADCRUMB_OP_RESOLVEENCODEROUTPUTMETADATA1 = D3D12_MARKER_API_RESOLVEENCODEROUTPUTMETADATA1, + D3D12_AUTO_BREADCRUMB_OP_RESOLVEINPUTPARAMLAYOUT = D3D12_MARKER_API_RESOLVEINPUTPARAMLAYOUT, + D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES2 = D3D12_MARKER_API_PROCESSFRAMES2, + D3D12_AUTO_BREADCRUMB_OP_SET_WORK_GRAPH_MAXIMUM_GPU_INPUT_RECORDS = D3D12_MARKER_API_SET_WORK_GRAPH_MAXIMUM_GPU_INPUT_RECORDS + } D3D12_AUTO_BREADCRUMB_OP; + +typedef struct D3D12_AUTO_BREADCRUMB_NODE + { + const char *pCommandListDebugNameA; + const wchar_t *pCommandListDebugNameW; + const char *pCommandQueueDebugNameA; + const wchar_t *pCommandQueueDebugNameW; + ID3D12GraphicsCommandList *pCommandList; + ID3D12CommandQueue *pCommandQueue; + UINT32 BreadcrumbCount; + const UINT32 *pLastBreadcrumbValue; + const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory; + const struct D3D12_AUTO_BREADCRUMB_NODE *pNext; + } D3D12_AUTO_BREADCRUMB_NODE; + +typedef struct D3D12_DRED_BREADCRUMB_CONTEXT + { + UINT BreadcrumbIndex; + const wchar_t *pContextString; + } D3D12_DRED_BREADCRUMB_CONTEXT; + +typedef struct D3D12_AUTO_BREADCRUMB_NODE1 + { + const char *pCommandListDebugNameA; + const wchar_t *pCommandListDebugNameW; + const char *pCommandQueueDebugNameA; + const wchar_t *pCommandQueueDebugNameW; + ID3D12GraphicsCommandList *pCommandList; + ID3D12CommandQueue *pCommandQueue; + UINT BreadcrumbCount; + const UINT *pLastBreadcrumbValue; + const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory; + const struct D3D12_AUTO_BREADCRUMB_NODE1 *pNext; + UINT BreadcrumbContextsCount; + D3D12_DRED_BREADCRUMB_CONTEXT *pBreadcrumbContexts; + } D3D12_AUTO_BREADCRUMB_NODE1; + +typedef +enum D3D12_DRED_VERSION + { + D3D12_DRED_VERSION_1_0 = 0x1, + D3D12_DRED_VERSION_1_1 = 0x2, + D3D12_DRED_VERSION_1_2 = 0x3, + D3D12_DRED_VERSION_1_3 = 0x4 + } D3D12_DRED_VERSION; + +typedef +enum D3D12_DRED_FLAGS + { + D3D12_DRED_FLAG_NONE = 0, + D3D12_DRED_FLAG_FORCE_ENABLE = 1, + D3D12_DRED_FLAG_DISABLE_AUTOBREADCRUMBS = 2 + } D3D12_DRED_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_DRED_FLAGS ) +typedef +enum D3D12_DRED_ENABLEMENT + { + D3D12_DRED_ENABLEMENT_SYSTEM_CONTROLLED = 0, + D3D12_DRED_ENABLEMENT_FORCED_OFF = 1, + D3D12_DRED_ENABLEMENT_FORCED_ON = 2 + } D3D12_DRED_ENABLEMENT; + +typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA + { + _In_ D3D12_DRED_FLAGS Flags; + _Out_ D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode; + } D3D12_DEVICE_REMOVED_EXTENDED_DATA; + +typedef +enum D3D12_DRED_ALLOCATION_TYPE + { + D3D12_DRED_ALLOCATION_TYPE_COMMAND_QUEUE = 19, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_ALLOCATOR = 20, + D3D12_DRED_ALLOCATION_TYPE_PIPELINE_STATE = 21, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_LIST = 22, + D3D12_DRED_ALLOCATION_TYPE_FENCE = 23, + D3D12_DRED_ALLOCATION_TYPE_DESCRIPTOR_HEAP = 24, + D3D12_DRED_ALLOCATION_TYPE_HEAP = 25, + D3D12_DRED_ALLOCATION_TYPE_QUERY_HEAP = 27, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_SIGNATURE = 28, + D3D12_DRED_ALLOCATION_TYPE_PIPELINE_LIBRARY = 29, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER = 30, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_PROCESSOR = 32, + D3D12_DRED_ALLOCATION_TYPE_RESOURCE = 34, + D3D12_DRED_ALLOCATION_TYPE_PASS = 35, + D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSION = 36, + D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSIONPOLICY = 37, + D3D12_DRED_ALLOCATION_TYPE_PROTECTEDRESOURCESESSION = 38, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER_HEAP = 39, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_POOL = 40, + D3D12_DRED_ALLOCATION_TYPE_COMMAND_RECORDER = 41, + D3D12_DRED_ALLOCATION_TYPE_STATE_OBJECT = 42, + D3D12_DRED_ALLOCATION_TYPE_METACOMMAND = 43, + D3D12_DRED_ALLOCATION_TYPE_SCHEDULINGGROUP = 44, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_ESTIMATOR = 45, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_VECTOR_HEAP = 46, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_EXTENSION_COMMAND = 47, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER = 48, + D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER_HEAP = 49, + D3D12_DRED_ALLOCATION_TYPE_INVALID = 0xffffffff + } D3D12_DRED_ALLOCATION_TYPE; + +typedef struct D3D12_DRED_ALLOCATION_NODE + { + const char *ObjectNameA; + const wchar_t *ObjectNameW; + D3D12_DRED_ALLOCATION_TYPE AllocationType; + const struct D3D12_DRED_ALLOCATION_NODE *pNext; + } D3D12_DRED_ALLOCATION_NODE; + +typedef struct D3D12_DRED_ALLOCATION_NODE1 + { + const char *ObjectNameA; + const wchar_t *ObjectNameW; + D3D12_DRED_ALLOCATION_TYPE AllocationType; + const struct D3D12_DRED_ALLOCATION_NODE1 *pNext; + const IUnknown *pObject; + } D3D12_DRED_ALLOCATION_NODE1; + +typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT + { + _Out_ const D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode; + } D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT; + +typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 + { + _Out_ const D3D12_AUTO_BREADCRUMB_NODE1 *pHeadAutoBreadcrumbNode; + } D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1; + +typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT + { + D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA; + _Out_ const D3D12_DRED_ALLOCATION_NODE *pHeadExistingAllocationNode; + _Out_ const D3D12_DRED_ALLOCATION_NODE *pHeadRecentFreedAllocationNode; + } D3D12_DRED_PAGE_FAULT_OUTPUT; + +typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT1 + { + D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA; + _Out_ const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode; + _Out_ const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode; + } D3D12_DRED_PAGE_FAULT_OUTPUT1; + +typedef +enum D3D12_DRED_PAGE_FAULT_FLAGS + { + D3D12_DRED_PAGE_FAULT_FLAGS_NONE = 0 + } D3D12_DRED_PAGE_FAULT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_DRED_PAGE_FAULT_FLAGS ) +typedef +enum D3D12_DRED_DEVICE_STATE + { + D3D12_DRED_DEVICE_STATE_UNKNOWN = 0, + D3D12_DRED_DEVICE_STATE_HUNG = 3, + D3D12_DRED_DEVICE_STATE_FAULT = 6, + D3D12_DRED_DEVICE_STATE_PAGEFAULT = 7 + } D3D12_DRED_DEVICE_STATE; + +typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT2 + { + D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA; + _Out_ const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode; + _Out_ const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode; + D3D12_DRED_PAGE_FAULT_FLAGS PageFaultFlags; + } D3D12_DRED_PAGE_FAULT_OUTPUT2; + +typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA1 + { + HRESULT DeviceRemovedReason; + D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT AutoBreadcrumbsOutput; + D3D12_DRED_PAGE_FAULT_OUTPUT PageFaultOutput; + } D3D12_DEVICE_REMOVED_EXTENDED_DATA1; + +typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA2 + { + HRESULT DeviceRemovedReason; + D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput; + D3D12_DRED_PAGE_FAULT_OUTPUT1 PageFaultOutput; + } D3D12_DEVICE_REMOVED_EXTENDED_DATA2; + +typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA3 + { + HRESULT DeviceRemovedReason; + D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput; + D3D12_DRED_PAGE_FAULT_OUTPUT2 PageFaultOutput; + D3D12_DRED_DEVICE_STATE DeviceState; + } D3D12_DEVICE_REMOVED_EXTENDED_DATA3; + +typedef struct D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA + { + D3D12_DRED_VERSION Version; + union + { + D3D12_DEVICE_REMOVED_EXTENDED_DATA Dred_1_0; + D3D12_DEVICE_REMOVED_EXTENDED_DATA1 Dred_1_1; + D3D12_DEVICE_REMOVED_EXTENDED_DATA2 Dred_1_2; + D3D12_DEVICE_REMOVED_EXTENDED_DATA3 Dred_1_3; + } ; + } D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0040_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0040_v0_0_s_ifspec; + +#ifndef __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__ +#define __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__ + +/* interface ID3D12DeviceRemovedExtendedDataSettings */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedDataSettings; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("82BC481C-6B9B-4030-AEDB-7EE3D1DF1E63") + ID3D12DeviceRemovedExtendedDataSettings : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE SetAutoBreadcrumbsEnablement( + D3D12_DRED_ENABLEMENT Enablement) = 0; + + virtual void STDMETHODCALLTYPE SetPageFaultEnablement( + D3D12_DRED_ENABLEMENT Enablement) = 0; + + virtual void STDMETHODCALLTYPE SetWatsonDumpEnablement( + D3D12_DRED_ENABLEMENT Enablement) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DeviceRemovedExtendedDataSettingsVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceRemovedExtendedDataSettings * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceRemovedExtendedDataSettings * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceRemovedExtendedDataSettings * This); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetAutoBreadcrumbsEnablement) + void ( STDMETHODCALLTYPE *SetAutoBreadcrumbsEnablement )( + ID3D12DeviceRemovedExtendedDataSettings * This, + D3D12_DRED_ENABLEMENT Enablement); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetPageFaultEnablement) + void ( STDMETHODCALLTYPE *SetPageFaultEnablement )( + ID3D12DeviceRemovedExtendedDataSettings * This, + D3D12_DRED_ENABLEMENT Enablement); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetWatsonDumpEnablement) + void ( STDMETHODCALLTYPE *SetWatsonDumpEnablement )( + ID3D12DeviceRemovedExtendedDataSettings * This, + D3D12_DRED_ENABLEMENT Enablement); + + END_INTERFACE + } ID3D12DeviceRemovedExtendedDataSettingsVtbl; + + interface ID3D12DeviceRemovedExtendedDataSettings + { + CONST_VTBL struct ID3D12DeviceRemovedExtendedDataSettingsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DeviceRemovedExtendedDataSettings_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DeviceRemovedExtendedDataSettings_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DeviceRemovedExtendedDataSettings_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DeviceRemovedExtendedDataSettings_SetAutoBreadcrumbsEnablement(This,Enablement) \ + ( (This)->lpVtbl -> SetAutoBreadcrumbsEnablement(This,Enablement) ) + +#define ID3D12DeviceRemovedExtendedDataSettings_SetPageFaultEnablement(This,Enablement) \ + ( (This)->lpVtbl -> SetPageFaultEnablement(This,Enablement) ) + +#define ID3D12DeviceRemovedExtendedDataSettings_SetWatsonDumpEnablement(This,Enablement) \ + ( (This)->lpVtbl -> SetWatsonDumpEnablement(This,Enablement) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DeviceRemovedExtendedDataSettings1_INTERFACE_DEFINED__ +#define __ID3D12DeviceRemovedExtendedDataSettings1_INTERFACE_DEFINED__ + +/* interface ID3D12DeviceRemovedExtendedDataSettings1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedDataSettings1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("DBD5AE51-3317-4F0A-ADF9-1D7CEDCAAE0B") + ID3D12DeviceRemovedExtendedDataSettings1 : public ID3D12DeviceRemovedExtendedDataSettings + { + public: + virtual void STDMETHODCALLTYPE SetBreadcrumbContextEnablement( + D3D12_DRED_ENABLEMENT Enablement) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DeviceRemovedExtendedDataSettings1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceRemovedExtendedDataSettings1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceRemovedExtendedDataSettings1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceRemovedExtendedDataSettings1 * This); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetAutoBreadcrumbsEnablement) + void ( STDMETHODCALLTYPE *SetAutoBreadcrumbsEnablement )( + ID3D12DeviceRemovedExtendedDataSettings1 * This, + D3D12_DRED_ENABLEMENT Enablement); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetPageFaultEnablement) + void ( STDMETHODCALLTYPE *SetPageFaultEnablement )( + ID3D12DeviceRemovedExtendedDataSettings1 * This, + D3D12_DRED_ENABLEMENT Enablement); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetWatsonDumpEnablement) + void ( STDMETHODCALLTYPE *SetWatsonDumpEnablement )( + ID3D12DeviceRemovedExtendedDataSettings1 * This, + D3D12_DRED_ENABLEMENT Enablement); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings1, SetBreadcrumbContextEnablement) + void ( STDMETHODCALLTYPE *SetBreadcrumbContextEnablement )( + ID3D12DeviceRemovedExtendedDataSettings1 * This, + D3D12_DRED_ENABLEMENT Enablement); + + END_INTERFACE + } ID3D12DeviceRemovedExtendedDataSettings1Vtbl; + + interface ID3D12DeviceRemovedExtendedDataSettings1 + { + CONST_VTBL struct ID3D12DeviceRemovedExtendedDataSettings1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DeviceRemovedExtendedDataSettings1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DeviceRemovedExtendedDataSettings1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DeviceRemovedExtendedDataSettings1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DeviceRemovedExtendedDataSettings1_SetAutoBreadcrumbsEnablement(This,Enablement) \ + ( (This)->lpVtbl -> SetAutoBreadcrumbsEnablement(This,Enablement) ) + +#define ID3D12DeviceRemovedExtendedDataSettings1_SetPageFaultEnablement(This,Enablement) \ + ( (This)->lpVtbl -> SetPageFaultEnablement(This,Enablement) ) + +#define ID3D12DeviceRemovedExtendedDataSettings1_SetWatsonDumpEnablement(This,Enablement) \ + ( (This)->lpVtbl -> SetWatsonDumpEnablement(This,Enablement) ) + + +#define ID3D12DeviceRemovedExtendedDataSettings1_SetBreadcrumbContextEnablement(This,Enablement) \ + ( (This)->lpVtbl -> SetBreadcrumbContextEnablement(This,Enablement) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DeviceRemovedExtendedDataSettings1_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DeviceRemovedExtendedDataSettings2_INTERFACE_DEFINED__ +#define __ID3D12DeviceRemovedExtendedDataSettings2_INTERFACE_DEFINED__ + +/* interface ID3D12DeviceRemovedExtendedDataSettings2 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedDataSettings2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("61552388-01ab-4008-a436-83db189566ea") + ID3D12DeviceRemovedExtendedDataSettings2 : public ID3D12DeviceRemovedExtendedDataSettings1 + { + public: + virtual void STDMETHODCALLTYPE UseMarkersOnlyAutoBreadcrumbs( + BOOL MarkersOnly) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DeviceRemovedExtendedDataSettings2Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceRemovedExtendedDataSettings2 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceRemovedExtendedDataSettings2 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceRemovedExtendedDataSettings2 * This); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetAutoBreadcrumbsEnablement) + void ( STDMETHODCALLTYPE *SetAutoBreadcrumbsEnablement )( + ID3D12DeviceRemovedExtendedDataSettings2 * This, + D3D12_DRED_ENABLEMENT Enablement); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetPageFaultEnablement) + void ( STDMETHODCALLTYPE *SetPageFaultEnablement )( + ID3D12DeviceRemovedExtendedDataSettings2 * This, + D3D12_DRED_ENABLEMENT Enablement); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetWatsonDumpEnablement) + void ( STDMETHODCALLTYPE *SetWatsonDumpEnablement )( + ID3D12DeviceRemovedExtendedDataSettings2 * This, + D3D12_DRED_ENABLEMENT Enablement); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings1, SetBreadcrumbContextEnablement) + void ( STDMETHODCALLTYPE *SetBreadcrumbContextEnablement )( + ID3D12DeviceRemovedExtendedDataSettings2 * This, + D3D12_DRED_ENABLEMENT Enablement); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings2, UseMarkersOnlyAutoBreadcrumbs) + void ( STDMETHODCALLTYPE *UseMarkersOnlyAutoBreadcrumbs )( + ID3D12DeviceRemovedExtendedDataSettings2 * This, + BOOL MarkersOnly); + + END_INTERFACE + } ID3D12DeviceRemovedExtendedDataSettings2Vtbl; + + interface ID3D12DeviceRemovedExtendedDataSettings2 + { + CONST_VTBL struct ID3D12DeviceRemovedExtendedDataSettings2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DeviceRemovedExtendedDataSettings2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DeviceRemovedExtendedDataSettings2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DeviceRemovedExtendedDataSettings2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DeviceRemovedExtendedDataSettings2_SetAutoBreadcrumbsEnablement(This,Enablement) \ + ( (This)->lpVtbl -> SetAutoBreadcrumbsEnablement(This,Enablement) ) + +#define ID3D12DeviceRemovedExtendedDataSettings2_SetPageFaultEnablement(This,Enablement) \ + ( (This)->lpVtbl -> SetPageFaultEnablement(This,Enablement) ) + +#define ID3D12DeviceRemovedExtendedDataSettings2_SetWatsonDumpEnablement(This,Enablement) \ + ( (This)->lpVtbl -> SetWatsonDumpEnablement(This,Enablement) ) + + +#define ID3D12DeviceRemovedExtendedDataSettings2_SetBreadcrumbContextEnablement(This,Enablement) \ + ( (This)->lpVtbl -> SetBreadcrumbContextEnablement(This,Enablement) ) + + +#define ID3D12DeviceRemovedExtendedDataSettings2_UseMarkersOnlyAutoBreadcrumbs(This,MarkersOnly) \ + ( (This)->lpVtbl -> UseMarkersOnlyAutoBreadcrumbs(This,MarkersOnly) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DeviceRemovedExtendedDataSettings2_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__ +#define __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__ + +/* interface ID3D12DeviceRemovedExtendedData */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("98931D33-5AE8-4791-AA3C-1A73A2934E71") + ID3D12DeviceRemovedExtendedData : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetAutoBreadcrumbsOutput( + _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPageFaultAllocationOutput( + _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DeviceRemovedExtendedDataVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceRemovedExtendedData * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceRemovedExtendedData * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceRemovedExtendedData * This); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetAutoBreadcrumbsOutput) + HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput )( + ID3D12DeviceRemovedExtendedData * This, + _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetPageFaultAllocationOutput) + HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput )( + ID3D12DeviceRemovedExtendedData * This, + _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput); + + END_INTERFACE + } ID3D12DeviceRemovedExtendedDataVtbl; + + interface ID3D12DeviceRemovedExtendedData + { + CONST_VTBL struct ID3D12DeviceRemovedExtendedDataVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DeviceRemovedExtendedData_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DeviceRemovedExtendedData_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DeviceRemovedExtendedData_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DeviceRemovedExtendedData_GetAutoBreadcrumbsOutput(This,pOutput) \ + ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput(This,pOutput) ) + +#define ID3D12DeviceRemovedExtendedData_GetPageFaultAllocationOutput(This,pOutput) \ + ( (This)->lpVtbl -> GetPageFaultAllocationOutput(This,pOutput) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DeviceRemovedExtendedData1_INTERFACE_DEFINED__ +#define __ID3D12DeviceRemovedExtendedData1_INTERFACE_DEFINED__ + +/* interface ID3D12DeviceRemovedExtendedData1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9727A022-CF1D-4DDA-9EBA-EFFA653FC506") + ID3D12DeviceRemovedExtendedData1 : public ID3D12DeviceRemovedExtendedData + { + public: + virtual HRESULT STDMETHODCALLTYPE GetAutoBreadcrumbsOutput1( + _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 *pOutput) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPageFaultAllocationOutput1( + _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT1 *pOutput) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DeviceRemovedExtendedData1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceRemovedExtendedData1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceRemovedExtendedData1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceRemovedExtendedData1 * This); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetAutoBreadcrumbsOutput) + HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput )( + ID3D12DeviceRemovedExtendedData1 * This, + _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetPageFaultAllocationOutput) + HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput )( + ID3D12DeviceRemovedExtendedData1 * This, + _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData1, GetAutoBreadcrumbsOutput1) + HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput1 )( + ID3D12DeviceRemovedExtendedData1 * This, + _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 *pOutput); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData1, GetPageFaultAllocationOutput1) + HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput1 )( + ID3D12DeviceRemovedExtendedData1 * This, + _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT1 *pOutput); + + END_INTERFACE + } ID3D12DeviceRemovedExtendedData1Vtbl; + + interface ID3D12DeviceRemovedExtendedData1 + { + CONST_VTBL struct ID3D12DeviceRemovedExtendedData1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DeviceRemovedExtendedData1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DeviceRemovedExtendedData1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DeviceRemovedExtendedData1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DeviceRemovedExtendedData1_GetAutoBreadcrumbsOutput(This,pOutput) \ + ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput(This,pOutput) ) + +#define ID3D12DeviceRemovedExtendedData1_GetPageFaultAllocationOutput(This,pOutput) \ + ( (This)->lpVtbl -> GetPageFaultAllocationOutput(This,pOutput) ) + + +#define ID3D12DeviceRemovedExtendedData1_GetAutoBreadcrumbsOutput1(This,pOutput) \ + ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput1(This,pOutput) ) + +#define ID3D12DeviceRemovedExtendedData1_GetPageFaultAllocationOutput1(This,pOutput) \ + ( (This)->lpVtbl -> GetPageFaultAllocationOutput1(This,pOutput) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DeviceRemovedExtendedData1_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DeviceRemovedExtendedData2_INTERFACE_DEFINED__ +#define __ID3D12DeviceRemovedExtendedData2_INTERFACE_DEFINED__ + +/* interface ID3D12DeviceRemovedExtendedData2 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("67FC5816-E4CA-4915-BF18-42541272DA54") + ID3D12DeviceRemovedExtendedData2 : public ID3D12DeviceRemovedExtendedData1 + { + public: + virtual HRESULT STDMETHODCALLTYPE GetPageFaultAllocationOutput2( + _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT2 *pOutput) = 0; + + virtual D3D12_DRED_DEVICE_STATE STDMETHODCALLTYPE GetDeviceState( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DeviceRemovedExtendedData2Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceRemovedExtendedData2 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceRemovedExtendedData2 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceRemovedExtendedData2 * This); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetAutoBreadcrumbsOutput) + HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput )( + ID3D12DeviceRemovedExtendedData2 * This, + _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetPageFaultAllocationOutput) + HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput )( + ID3D12DeviceRemovedExtendedData2 * This, + _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData1, GetAutoBreadcrumbsOutput1) + HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput1 )( + ID3D12DeviceRemovedExtendedData2 * This, + _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 *pOutput); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData1, GetPageFaultAllocationOutput1) + HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput1 )( + ID3D12DeviceRemovedExtendedData2 * This, + _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT1 *pOutput); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData2, GetPageFaultAllocationOutput2) + HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput2 )( + ID3D12DeviceRemovedExtendedData2 * This, + _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT2 *pOutput); + + DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData2, GetDeviceState) + D3D12_DRED_DEVICE_STATE ( STDMETHODCALLTYPE *GetDeviceState )( + ID3D12DeviceRemovedExtendedData2 * This); + + END_INTERFACE + } ID3D12DeviceRemovedExtendedData2Vtbl; + + interface ID3D12DeviceRemovedExtendedData2 + { + CONST_VTBL struct ID3D12DeviceRemovedExtendedData2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DeviceRemovedExtendedData2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DeviceRemovedExtendedData2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DeviceRemovedExtendedData2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DeviceRemovedExtendedData2_GetAutoBreadcrumbsOutput(This,pOutput) \ + ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput(This,pOutput) ) + +#define ID3D12DeviceRemovedExtendedData2_GetPageFaultAllocationOutput(This,pOutput) \ + ( (This)->lpVtbl -> GetPageFaultAllocationOutput(This,pOutput) ) + + +#define ID3D12DeviceRemovedExtendedData2_GetAutoBreadcrumbsOutput1(This,pOutput) \ + ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput1(This,pOutput) ) + +#define ID3D12DeviceRemovedExtendedData2_GetPageFaultAllocationOutput1(This,pOutput) \ + ( (This)->lpVtbl -> GetPageFaultAllocationOutput1(This,pOutput) ) + + +#define ID3D12DeviceRemovedExtendedData2_GetPageFaultAllocationOutput2(This,pOutput) \ + ( (This)->lpVtbl -> GetPageFaultAllocationOutput2(This,pOutput) ) + +#define ID3D12DeviceRemovedExtendedData2_GetDeviceState(This) \ + ( (This)->lpVtbl -> GetDeviceState(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DeviceRemovedExtendedData2_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0046 */ +/* [local] */ + +typedef +enum D3D12_BACKGROUND_PROCESSING_MODE + { + D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED = 0, + D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS = ( D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED + 1 ) , + D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK = ( D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS + 1 ) , + D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_PROFILING_BY_SYSTEM = ( D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK + 1 ) + } D3D12_BACKGROUND_PROCESSING_MODE; + +typedef +enum D3D12_MEASUREMENTS_ACTION + { + D3D12_MEASUREMENTS_ACTION_KEEP_ALL = 0, + D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS = ( D3D12_MEASUREMENTS_ACTION_KEEP_ALL + 1 ) , + D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY = ( D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS + 1 ) , + D3D12_MEASUREMENTS_ACTION_DISCARD_PREVIOUS = ( D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY + 1 ) + } D3D12_MEASUREMENTS_ACTION; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0046_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0046_v0_0_s_ifspec; + +#ifndef __ID3D12Device6_INTERFACE_DEFINED__ +#define __ID3D12Device6_INTERFACE_DEFINED__ + +/* interface ID3D12Device6 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Device6; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c70b221b-40e4-4a17-89af-025a0727a6dc") + ID3D12Device6 : public ID3D12Device5 + { + public: + virtual HRESULT STDMETHODCALLTYPE SetBackgroundProcessingMode( + D3D12_BACKGROUND_PROCESSING_MODE Mode, + D3D12_MEASUREMENTS_ACTION MeasurementsAction, + _In_opt_ HANDLE hEventToSignalUponCompletion, + _Out_opt_ BOOL *pbFurtherMeasurementsDesired) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Device6Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Device6 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Device6 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Device6 * This); + + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Device6 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Device6 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Device6 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Device6 * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device6 * This); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device6 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device6 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device6 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device6 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device6 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device6 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device6 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device6 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device6 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device6 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device6 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device6 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device6 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device6 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device6 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device6 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device6 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device6 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device6 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) +#if !defined(_WIN32) + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device6 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#else + D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device6 * This, + D3D12_HEAP_PROPERTIES * RetVal, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device6 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device6 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device6 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device6 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device6 * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); + + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device6 * This, + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj); + + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device6 * This, + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle); + + DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device6 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + DECLSPEC_XFGVIRT(ID3D12Device, Evict) + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device6 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device6 * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); + + DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device6 * This); + + DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device6 * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device6 * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device6 * This, + BOOL Enable); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device6 * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); + + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device6 * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + + DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) +#if !defined(_WIN32) + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device6 * This); + +#else + LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device6 * This, + LUID * RetVal); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( + ID3D12Device6 * This, + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary); + + DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) + HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( + ID3D12Device6 * This, + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent); + + DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) + HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( + ID3D12Device6 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + + DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( + ID3D12Device6 * This, + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( + ID3D12Device6 * This, + _In_ const void *pAddress, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( + ID3D12Device6 * This, + _In_ HANDLE hFileMapping, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) + HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( + ID3D12Device6 * This, + D3D12_RESIDENCY_FLAGS Flags, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_ ID3D12Fence *pFenceToSignal, + UINT64 FenceValueToSignal); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( + ID3D12Device6 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ D3D12_COMMAND_LIST_FLAGS flags, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( + ID3D12Device6 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( + ID3D12Device6 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) + HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( + ID3D12Device6 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( + ID3D12Device6 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device6 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device6 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) + HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( + ID3D12Device6 * This, + _In_ ID3D12LifetimeOwner *pOwner, + REFIID riid, + _COM_Outptr_ void **ppvTracker); + + DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) + void ( STDMETHODCALLTYPE *RemoveDevice )( + ID3D12Device6 * This); + + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( + ID3D12Device6 * This, + _Inout_ UINT *pNumMetaCommands, + _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); + + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( + ID3D12Device6 * This, + _In_ REFGUID CommandId, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _Out_opt_ UINT *pTotalStructureSizeInBytes, + _Inout_ UINT *pParameterCount, + _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); + + DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) + HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( + ID3D12Device6 * This, + _In_ REFGUID CommandId, + _In_ UINT NodeMask, + _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, + _In_ SIZE_T CreationParametersDataSizeInBytes, + REFIID riid, + _COM_Outptr_ void **ppMetaCommand); + + DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) + HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( + ID3D12Device6 * This, + const D3D12_STATE_OBJECT_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppStateObject); + + DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) + void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( + ID3D12Device6 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, + _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); + + DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) + D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( + ID3D12Device6 * This, + _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, + _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); + + DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) + HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( + ID3D12Device6 * This, + D3D12_BACKGROUND_PROCESSING_MODE Mode, + D3D12_MEASUREMENTS_ACTION MeasurementsAction, + _In_opt_ HANDLE hEventToSignalUponCompletion, + _Out_opt_ BOOL *pbFurtherMeasurementsDesired); + + END_INTERFACE + } ID3D12Device6Vtbl; + + interface ID3D12Device6 + { + CONST_VTBL struct ID3D12Device6Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Device6_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Device6_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Device6_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Device6_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Device6_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Device6_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Device6_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Device6_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) + +#define ID3D12Device6_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) + +#define ID3D12Device6_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) + +#define ID3D12Device6_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device6_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device6_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) + +#define ID3D12Device6_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) + +#define ID3D12Device6_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) + +#define ID3D12Device6_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) + +#define ID3D12Device6_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) + +#define ID3D12Device6_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) + +#define ID3D12Device6_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device6_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) + +#define ID3D12Device6_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device6_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device6_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) + +#define ID3D12Device6_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) + +#define ID3D12Device6_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) +#if !defined(_WIN32) + +#define ID3D12Device6_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) +#else +#define ID3D12Device6_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) +#endif +#if !defined(_WIN32) + +#define ID3D12Device6_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) +#else +#define ID3D12Device6_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) +#endif + +#define ID3D12Device6_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) + +#define ID3D12Device6_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device6_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device6_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device6_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) + +#define ID3D12Device6_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) + +#define ID3D12Device6_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) + +#define ID3D12Device6_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) + +#define ID3D12Device6_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) + +#define ID3D12Device6_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) + +#define ID3D12Device6_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) + +#define ID3D12Device6_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + +#define ID3D12Device6_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device6_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) + +#define ID3D12Device6_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) + +#define ID3D12Device6_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) +#if !defined(_WIN32) + +#define ID3D12Device6_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) +#else +#define ID3D12Device6_GetAdapterLuid(This,RetVal) \ + ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) +#endif + + +#define ID3D12Device6_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) + +#define ID3D12Device6_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) + +#define ID3D12Device6_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) + + +#define ID3D12Device6_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) + + +#define ID3D12Device6_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) + +#define ID3D12Device6_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) + +#define ID3D12Device6_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ + ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) + + +#define ID3D12Device6_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) + +#define ID3D12Device6_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) + +#define ID3D12Device6_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) + +#define ID3D12Device6_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) + +#define ID3D12Device6_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) +#if !defined(_WIN32) + +#define ID3D12Device6_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device6_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif + + +#define ID3D12Device6_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ + ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) + +#define ID3D12Device6_RemoveDevice(This) \ + ( (This)->lpVtbl -> RemoveDevice(This) ) + +#define ID3D12Device6_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) + +#define ID3D12Device6_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) + +#define ID3D12Device6_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ + ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) + +#define ID3D12Device6_CreateStateObject(This,pDesc,riid,ppStateObject) \ + ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) + +#define ID3D12Device6_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ + ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) + +#define ID3D12Device6_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ + ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) + + +#define ID3D12Device6_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ + ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Device6_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0047 */ +/* [local] */ + +DEFINE_GUID(D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED, 0x62B0084E, 0xC70E, 0x4DAA, 0xA1, 0x09, 0x30, 0xFF, 0x8D, 0x5A, 0x04, 0x82); +typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT + { + UINT NodeIndex; + UINT Count; + } D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT; + +typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES + { + UINT NodeIndex; + UINT Count; + GUID *pTypes; + } D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES; + +typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC1 + { + UINT NodeMask; + D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags; + GUID ProtectionType; + } D3D12_PROTECTED_RESOURCE_SESSION_DESC1; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0047_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0047_v0_0_s_ifspec; + +#ifndef __ID3D12ProtectedResourceSession1_INTERFACE_DEFINED__ +#define __ID3D12ProtectedResourceSession1_INTERFACE_DEFINED__ + +/* interface ID3D12ProtectedResourceSession1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12ProtectedResourceSession1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("D6F12DD6-76FB-406E-8961-4296EEFC0409") + ID3D12ProtectedResourceSession1 : public ID3D12ProtectedResourceSession + { + public: +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) + virtual D3D12_PROTECTED_RESOURCE_SESSION_DESC1 STDMETHODCALLTYPE GetDesc1( void) = 0; +#else + virtual D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *STDMETHODCALLTYPE GetDesc1( + D3D12_PROTECTED_RESOURCE_SESSION_DESC1 * RetVal) = 0; +#endif + + }; + + +#else /* C style interface */ + + typedef struct ID3D12ProtectedResourceSession1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12ProtectedResourceSession1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12ProtectedResourceSession1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12ProtectedResourceSession1 * This); + + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12ProtectedResourceSession1 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12ProtectedResourceSession1 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12ProtectedResourceSession1 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12ProtectedResourceSession1 * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12ProtectedResourceSession1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + DECLSPEC_XFGVIRT(ID3D12ProtectedSession, GetStatusFence) + HRESULT ( STDMETHODCALLTYPE *GetStatusFence )( + ID3D12ProtectedResourceSession1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppFence); + + DECLSPEC_XFGVIRT(ID3D12ProtectedSession, GetSessionStatus) + D3D12_PROTECTED_SESSION_STATUS ( STDMETHODCALLTYPE *GetSessionStatus )( + ID3D12ProtectedResourceSession1 * This); + + DECLSPEC_XFGVIRT(ID3D12ProtectedResourceSession, GetDesc) +#if !defined(_WIN32) + D3D12_PROTECTED_RESOURCE_SESSION_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12ProtectedResourceSession1 * This); + +#else + D3D12_PROTECTED_RESOURCE_SESSION_DESC *( STDMETHODCALLTYPE *GetDesc )( + ID3D12ProtectedResourceSession1 * This, + D3D12_PROTECTED_RESOURCE_SESSION_DESC * RetVal); + +#endif + + DECLSPEC_XFGVIRT(ID3D12ProtectedResourceSession1, GetDesc1) +#if !defined(_WIN32) + D3D12_PROTECTED_RESOURCE_SESSION_DESC1 ( STDMETHODCALLTYPE *GetDesc1 )( + ID3D12ProtectedResourceSession1 * This); + +#else + D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *( STDMETHODCALLTYPE *GetDesc1 )( + ID3D12ProtectedResourceSession1 * This, + D3D12_PROTECTED_RESOURCE_SESSION_DESC1 * RetVal); + +#endif + + END_INTERFACE + } ID3D12ProtectedResourceSession1Vtbl; + + interface ID3D12ProtectedResourceSession1 + { + CONST_VTBL struct ID3D12ProtectedResourceSession1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12ProtectedResourceSession1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12ProtectedResourceSession1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12ProtectedResourceSession1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12ProtectedResourceSession1_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12ProtectedResourceSession1_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12ProtectedResourceSession1_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12ProtectedResourceSession1_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12ProtectedResourceSession1_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12ProtectedResourceSession1_GetStatusFence(This,riid,ppFence) \ + ( (This)->lpVtbl -> GetStatusFence(This,riid,ppFence) ) + +#define ID3D12ProtectedResourceSession1_GetSessionStatus(This) \ + ( (This)->lpVtbl -> GetSessionStatus(This) ) + +#if !defined(_WIN32) + +#define ID3D12ProtectedResourceSession1_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) +#else +#define ID3D12ProtectedResourceSession1_GetDesc(This,RetVal) \ + ( (This)->lpVtbl -> GetDesc(This,RetVal) ) +#endif + +#if !defined(_WIN32) + +#define ID3D12ProtectedResourceSession1_GetDesc1(This) \ + ( (This)->lpVtbl -> GetDesc1(This) ) +#else +#define ID3D12ProtectedResourceSession1_GetDesc1(This,RetVal) \ + ( (This)->lpVtbl -> GetDesc1(This,RetVal) ) +#endif + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12ProtectedResourceSession1_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Device7_INTERFACE_DEFINED__ +#define __ID3D12Device7_INTERFACE_DEFINED__ + +/* interface ID3D12Device7 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Device7; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5c014b53-68a1-4b9b-8bd1-dd6046b9358b") + ID3D12Device7 : public ID3D12Device6 + { + public: + virtual HRESULT STDMETHODCALLTYPE AddToStateObject( + const D3D12_STATE_OBJECT_DESC *pAddition, + ID3D12StateObject *pStateObjectToGrowFrom, + REFIID riid, + _COM_Outptr_ void **ppNewStateObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateProtectedResourceSession1( + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Device7Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Device7 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Device7 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Device7 * This); + + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Device7 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Device7 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Device7 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Device7 * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device7 * This); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device7 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device7 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device7 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device7 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device7 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device7 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device7 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device7 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device7 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device7 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device7 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device7 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device7 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device7 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device7 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device7 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device7 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device7 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device7 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) +#if !defined(_WIN32) + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device7 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#else + D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device7 * This, + D3D12_HEAP_PROPERTIES * RetVal, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device7 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device7 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device7 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device7 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ ID3D12DeviceChild *pObject, _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, DWORD Access, @@ -14197,14 +18809,14 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ HANDLE NTHandle, REFIID riid, _COM_Outptr_opt_ void **ppvObj); DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ LPCWSTR Name, DWORD Access, /* [annotation][out] */ @@ -14212,19 +18824,19 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device5 * This, + ID3D12Device7 * This, UINT NumObjects, _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); DECLSPEC_XFGVIRT(ID3D12Device, Evict) HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device5 * This, + ID3D12Device7 * This, UINT NumObjects, _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device5 * This, + ID3D12Device7 * This, UINT64 InitialValue, D3D12_FENCE_FLAGS Flags, REFIID riid, @@ -14232,11 +18844,11 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device5 * This); + ID3D12Device7 * This); DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ const D3D12_RESOURCE_DESC *pResourceDesc, _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, @@ -14248,19 +18860,19 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ const D3D12_QUERY_HEAP_DESC *pDesc, REFIID riid, _COM_Outptr_opt_ void **ppvHeap); DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device5 * This, + ID3D12Device7 * This, BOOL Enable); DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, _In_opt_ ID3D12RootSignature *pRootSignature, REFIID riid, @@ -14268,7 +18880,7 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ ID3D12Resource *pTiledResource, _Out_opt_ UINT *pNumTilesForEntireResource, _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, @@ -14280,18 +18892,18 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) #if !defined(_WIN32) LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device5 * This); + ID3D12Device7 * This); #else LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device5 * This, + ID3D12Device7 * This, LUID * RetVal); #endif DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_reads_(BlobLength) const void *pLibraryBlob, SIZE_T BlobLength, REFIID riid, @@ -14299,7 +18911,7 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_reads_(NumFences) ID3D12Fence *const *ppFences, _In_reads_(NumFences) const UINT64 *pFenceValues, UINT NumFences, @@ -14308,35 +18920,35 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( - ID3D12Device5 * This, + ID3D12Device7 * This, UINT NumObjects, _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( - ID3D12Device5 * This, + ID3D12Device7 * This, const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, REFIID riid, _COM_Outptr_ void **ppPipelineState); DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ const void *pAddress, REFIID riid, _COM_Outptr_ void **ppvHeap); DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ HANDLE hFileMapping, REFIID riid, _COM_Outptr_ void **ppvHeap); DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( - ID3D12Device5 * This, + ID3D12Device7 * This, D3D12_RESIDENCY_FLAGS Flags, UINT NumObjects, _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, @@ -14345,7 +18957,7 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ UINT nodeMask, _In_ D3D12_COMMAND_LIST_TYPE type, _In_ D3D12_COMMAND_LIST_FLAGS flags, @@ -14354,14 +18966,14 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, _In_ REFIID riid, _COM_Outptr_ void **ppSession); DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, _In_ const D3D12_RESOURCE_DESC *pDesc, @@ -14373,7 +18985,7 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ const D3D12_HEAP_DESC *pDesc, _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, REFIID riid, @@ -14381,7 +18993,7 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ const D3D12_RESOURCE_DESC *pDesc, D3D12_RESOURCE_STATES InitialState, _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, @@ -14392,7 +19004,7 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) #if !defined(_WIN32) D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device5 * This, + ID3D12Device7 * This, UINT visibleMask, UINT numResourceDescs, _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, @@ -14400,7 +19012,7 @@ EXTERN_C const IID IID_ID3D12Device5; #else D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device5 * This, + ID3D12Device7 * This, D3D12_RESOURCE_ALLOCATION_INFO * RetVal, UINT visibleMask, UINT numResourceDescs, @@ -14411,24 +19023,24 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ ID3D12LifetimeOwner *pOwner, REFIID riid, _COM_Outptr_ void **ppvTracker); DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) void ( STDMETHODCALLTYPE *RemoveDevice )( - ID3D12Device5 * This); + ID3D12Device7 * This); DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( - ID3D12Device5 * This, + ID3D12Device7 * This, _Inout_ UINT *pNumMetaCommands, _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ REFGUID CommandId, _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, _Out_opt_ UINT *pTotalStructureSizeInBytes, @@ -14437,7 +19049,7 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ REFGUID CommandId, _In_ UINT NodeMask, _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, @@ -14447,29 +19059,52 @@ EXTERN_C const IID IID_ID3D12Device5; DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( - ID3D12Device5 * This, + ID3D12Device7 * This, const D3D12_STATE_OBJECT_DESC *pDesc, REFIID riid, _COM_Outptr_ void **ppStateObject); DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( - ID3D12Device5 * This, + ID3D12Device7 * This, _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); + DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) + HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( + ID3D12Device7 * This, + D3D12_BACKGROUND_PROCESSING_MODE Mode, + D3D12_MEASUREMENTS_ACTION MeasurementsAction, + _In_opt_ HANDLE hEventToSignalUponCompletion, + _Out_opt_ BOOL *pbFurtherMeasurementsDesired); + + DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject) + HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( + ID3D12Device7 * This, + const D3D12_STATE_OBJECT_DESC *pAddition, + ID3D12StateObject *pStateObjectToGrowFrom, + REFIID riid, + _COM_Outptr_ void **ppNewStateObject); + + DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( + ID3D12Device7 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); + END_INTERFACE - } ID3D12Device5Vtbl; + } ID3D12Device7Vtbl; - interface ID3D12Device5 + interface ID3D12Device7 { - CONST_VTBL struct ID3D12Device5Vtbl *lpVtbl; + CONST_VTBL struct ID3D12Device7Vtbl *lpVtbl; }; @@ -14477,566 +19112,933 @@ EXTERN_C const IID IID_ID3D12Device5; #ifdef COBJMACROS -#define ID3D12Device5_QueryInterface(This,riid,ppvObject) \ +#define ID3D12Device7_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12Device5_AddRef(This) \ +#define ID3D12Device7_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12Device5_Release(This) \ +#define ID3D12Device7_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Device5_GetPrivateData(This,guid,pDataSize,pData) \ +#define ID3D12Device7_GetPrivateData(This,guid,pDataSize,pData) \ ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12Device5_SetPrivateData(This,guid,DataSize,pData) \ +#define ID3D12Device7_SetPrivateData(This,guid,DataSize,pData) \ ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12Device5_SetPrivateDataInterface(This,guid,pData) \ +#define ID3D12Device7_SetPrivateDataInterface(This,guid,pData) \ ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12Device5_SetName(This,Name) \ +#define ID3D12Device7_SetName(This,Name) \ ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12Device5_GetNodeCount(This) \ +#define ID3D12Device7_GetNodeCount(This) \ ( (This)->lpVtbl -> GetNodeCount(This) ) -#define ID3D12Device5_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ +#define ID3D12Device7_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) -#define ID3D12Device5_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ +#define ID3D12Device7_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) -#define ID3D12Device5_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ +#define ID3D12Device7_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12Device5_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ +#define ID3D12Device7_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12Device5_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ +#define ID3D12Device7_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) -#define ID3D12Device5_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ +#define ID3D12Device7_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) -#define ID3D12Device5_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ +#define ID3D12Device7_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) -#define ID3D12Device5_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ +#define ID3D12Device7_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) -#define ID3D12Device5_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ +#define ID3D12Device7_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) -#define ID3D12Device5_CreateConstantBufferView(This,pDesc,DestDescriptor) \ +#define ID3D12Device7_CreateConstantBufferView(This,pDesc,DestDescriptor) \ ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) -#define ID3D12Device5_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ +#define ID3D12Device7_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12Device5_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ +#define ID3D12Device7_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) -#define ID3D12Device5_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ +#define ID3D12Device7_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12Device5_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ +#define ID3D12Device7_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12Device5_CreateSampler(This,pDesc,DestDescriptor) \ +#define ID3D12Device7_CreateSampler(This,pDesc,DestDescriptor) \ ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) -#define ID3D12Device5_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ +#define ID3D12Device7_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) -#define ID3D12Device5_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ +#define ID3D12Device7_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) #if !defined(_WIN32) -#define ID3D12Device5_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ +#define ID3D12Device7_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) #else -#define ID3D12Device5_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ +#define ID3D12Device7_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) #endif #if !defined(_WIN32) -#define ID3D12Device5_GetCustomHeapProperties(This,nodeMask,heapType) \ +#define ID3D12Device7_GetCustomHeapProperties(This,nodeMask,heapType) \ ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) #else -#define ID3D12Device5_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ +#define ID3D12Device7_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) #endif -#define ID3D12Device5_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ +#define ID3D12Device7_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) -#define ID3D12Device5_CreateHeap(This,pDesc,riid,ppvHeap) \ +#define ID3D12Device7_CreateHeap(This,pDesc,riid,ppvHeap) \ ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) -#define ID3D12Device5_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ +#define ID3D12Device7_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) -#define ID3D12Device5_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ +#define ID3D12Device7_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) -#define ID3D12Device5_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ +#define ID3D12Device7_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) -#define ID3D12Device5_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ +#define ID3D12Device7_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) -#define ID3D12Device5_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ +#define ID3D12Device7_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) -#define ID3D12Device5_MakeResident(This,NumObjects,ppObjects) \ +#define ID3D12Device7_MakeResident(This,NumObjects,ppObjects) \ ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) -#define ID3D12Device5_Evict(This,NumObjects,ppObjects) \ +#define ID3D12Device7_Evict(This,NumObjects,ppObjects) \ ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) -#define ID3D12Device5_CreateFence(This,InitialValue,Flags,riid,ppFence) \ +#define ID3D12Device7_CreateFence(This,InitialValue,Flags,riid,ppFence) \ ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) -#define ID3D12Device5_GetDeviceRemovedReason(This) \ +#define ID3D12Device7_GetDeviceRemovedReason(This) \ ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) -#define ID3D12Device5_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ +#define ID3D12Device7_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) -#define ID3D12Device5_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ +#define ID3D12Device7_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) -#define ID3D12Device5_SetStablePowerState(This,Enable) \ +#define ID3D12Device7_SetStablePowerState(This,Enable) \ ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) -#define ID3D12Device5_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ +#define ID3D12Device7_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) -#define ID3D12Device5_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ +#define ID3D12Device7_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) #if !defined(_WIN32) -#define ID3D12Device5_GetAdapterLuid(This) \ +#define ID3D12Device7_GetAdapterLuid(This) \ ( (This)->lpVtbl -> GetAdapterLuid(This) ) #else -#define ID3D12Device5_GetAdapterLuid(This,RetVal) \ +#define ID3D12Device7_GetAdapterLuid(This,RetVal) \ ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) #endif -#define ID3D12Device5_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ +#define ID3D12Device7_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) -#define ID3D12Device5_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ +#define ID3D12Device7_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) -#define ID3D12Device5_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ +#define ID3D12Device7_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) -#define ID3D12Device5_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ +#define ID3D12Device7_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12Device5_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ +#define ID3D12Device7_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) -#define ID3D12Device5_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ +#define ID3D12Device7_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) -#define ID3D12Device5_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ +#define ID3D12Device7_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) -#define ID3D12Device5_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ +#define ID3D12Device7_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) -#define ID3D12Device5_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ +#define ID3D12Device7_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) -#define ID3D12Device5_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ +#define ID3D12Device7_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) -#define ID3D12Device5_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ +#define ID3D12Device7_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) -#define ID3D12Device5_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ +#define ID3D12Device7_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) #if !defined(_WIN32) -#define ID3D12Device5_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ +#define ID3D12Device7_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) #else -#define ID3D12Device5_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ +#define ID3D12Device7_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) #endif -#define ID3D12Device5_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ +#define ID3D12Device7_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) -#define ID3D12Device5_RemoveDevice(This) \ +#define ID3D12Device7_RemoveDevice(This) \ ( (This)->lpVtbl -> RemoveDevice(This) ) -#define ID3D12Device5_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ +#define ID3D12Device7_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) -#define ID3D12Device5_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ +#define ID3D12Device7_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) -#define ID3D12Device5_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ +#define ID3D12Device7_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) -#define ID3D12Device5_CreateStateObject(This,pDesc,riid,ppStateObject) \ +#define ID3D12Device7_CreateStateObject(This,pDesc,riid,ppStateObject) \ ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) -#define ID3D12Device5_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ +#define ID3D12Device7_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) -#define ID3D12Device5_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ - ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Device5_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0035 */ -/* [local] */ - -typedef -enum D3D12_AUTO_BREADCRUMB_OP - { - D3D12_AUTO_BREADCRUMB_OP_SETMARKER = 0, - D3D12_AUTO_BREADCRUMB_OP_BEGINEVENT = 1, - D3D12_AUTO_BREADCRUMB_OP_ENDEVENT = 2, - D3D12_AUTO_BREADCRUMB_OP_DRAWINSTANCED = 3, - D3D12_AUTO_BREADCRUMB_OP_DRAWINDEXEDINSTANCED = 4, - D3D12_AUTO_BREADCRUMB_OP_EXECUTEINDIRECT = 5, - D3D12_AUTO_BREADCRUMB_OP_DISPATCH = 6, - D3D12_AUTO_BREADCRUMB_OP_COPYBUFFERREGION = 7, - D3D12_AUTO_BREADCRUMB_OP_COPYTEXTUREREGION = 8, - D3D12_AUTO_BREADCRUMB_OP_COPYRESOURCE = 9, - D3D12_AUTO_BREADCRUMB_OP_COPYTILES = 10, - D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCE = 11, - D3D12_AUTO_BREADCRUMB_OP_CLEARRENDERTARGETVIEW = 12, - D3D12_AUTO_BREADCRUMB_OP_CLEARUNORDEREDACCESSVIEW = 13, - D3D12_AUTO_BREADCRUMB_OP_CLEARDEPTHSTENCILVIEW = 14, - D3D12_AUTO_BREADCRUMB_OP_RESOURCEBARRIER = 15, - D3D12_AUTO_BREADCRUMB_OP_EXECUTEBUNDLE = 16, - D3D12_AUTO_BREADCRUMB_OP_PRESENT = 17, - D3D12_AUTO_BREADCRUMB_OP_RESOLVEQUERYDATA = 18, - D3D12_AUTO_BREADCRUMB_OP_BEGINSUBMISSION = 19, - D3D12_AUTO_BREADCRUMB_OP_ENDSUBMISSION = 20, - D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME = 21, - D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES = 22, - D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT = 23, - D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT64 = 24, - D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCEREGION = 25, - D3D12_AUTO_BREADCRUMB_OP_WRITEBUFFERIMMEDIATE = 26, - D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME1 = 27, - D3D12_AUTO_BREADCRUMB_OP_SETPROTECTEDRESOURCESESSION = 28, - D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME2 = 29, - D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES1 = 30, - D3D12_AUTO_BREADCRUMB_OP_BUILDRAYTRACINGACCELERATIONSTRUCTURE = 31, - D3D12_AUTO_BREADCRUMB_OP_EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO = 32, - D3D12_AUTO_BREADCRUMB_OP_COPYRAYTRACINGACCELERATIONSTRUCTURE = 33, - D3D12_AUTO_BREADCRUMB_OP_DISPATCHRAYS = 34, - D3D12_AUTO_BREADCRUMB_OP_INITIALIZEMETACOMMAND = 35, - D3D12_AUTO_BREADCRUMB_OP_EXECUTEMETACOMMAND = 36, - D3D12_AUTO_BREADCRUMB_OP_ESTIMATEMOTION = 37, - D3D12_AUTO_BREADCRUMB_OP_RESOLVEMOTIONVECTORHEAP = 38, - D3D12_AUTO_BREADCRUMB_OP_SETPIPELINESTATE1 = 39, - D3D12_AUTO_BREADCRUMB_OP_INITIALIZEEXTENSIONCOMMAND = 40, - D3D12_AUTO_BREADCRUMB_OP_EXECUTEEXTENSIONCOMMAND = 41, - D3D12_AUTO_BREADCRUMB_OP_DISPATCHMESH = 42, - D3D12_AUTO_BREADCRUMB_OP_ENCODEFRAME = 43, - D3D12_AUTO_BREADCRUMB_OP_RESOLVEENCODEROUTPUTMETADATA = 44 - } D3D12_AUTO_BREADCRUMB_OP; - -typedef struct D3D12_AUTO_BREADCRUMB_NODE - { - const char *pCommandListDebugNameA; - const wchar_t *pCommandListDebugNameW; - const char *pCommandQueueDebugNameA; - const wchar_t *pCommandQueueDebugNameW; - ID3D12GraphicsCommandList *pCommandList; - ID3D12CommandQueue *pCommandQueue; - UINT32 BreadcrumbCount; - const UINT32 *pLastBreadcrumbValue; - const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory; - const struct D3D12_AUTO_BREADCRUMB_NODE *pNext; - } D3D12_AUTO_BREADCRUMB_NODE; - -typedef struct D3D12_DRED_BREADCRUMB_CONTEXT - { - UINT BreadcrumbIndex; - const wchar_t *pContextString; - } D3D12_DRED_BREADCRUMB_CONTEXT; - -typedef struct D3D12_AUTO_BREADCRUMB_NODE1 - { - const char *pCommandListDebugNameA; - const wchar_t *pCommandListDebugNameW; - const char *pCommandQueueDebugNameA; - const wchar_t *pCommandQueueDebugNameW; - ID3D12GraphicsCommandList *pCommandList; - ID3D12CommandQueue *pCommandQueue; - UINT BreadcrumbCount; - const UINT *pLastBreadcrumbValue; - const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory; - const struct D3D12_AUTO_BREADCRUMB_NODE1 *pNext; - UINT BreadcrumbContextsCount; - D3D12_DRED_BREADCRUMB_CONTEXT *pBreadcrumbContexts; - } D3D12_AUTO_BREADCRUMB_NODE1; - -typedef -enum D3D12_DRED_VERSION - { - D3D12_DRED_VERSION_1_0 = 0x1, - D3D12_DRED_VERSION_1_1 = 0x2, - D3D12_DRED_VERSION_1_2 = 0x3, - D3D12_DRED_VERSION_1_3 = 0x4 - } D3D12_DRED_VERSION; - -typedef -enum D3D12_DRED_FLAGS - { - D3D12_DRED_FLAG_NONE = 0, - D3D12_DRED_FLAG_FORCE_ENABLE = 1, - D3D12_DRED_FLAG_DISABLE_AUTOBREADCRUMBS = 2 - } D3D12_DRED_FLAGS; - -DEFINE_ENUM_FLAG_OPERATORS( D3D12_DRED_FLAGS ); -typedef -enum D3D12_DRED_ENABLEMENT - { - D3D12_DRED_ENABLEMENT_SYSTEM_CONTROLLED = 0, - D3D12_DRED_ENABLEMENT_FORCED_OFF = 1, - D3D12_DRED_ENABLEMENT_FORCED_ON = 2 - } D3D12_DRED_ENABLEMENT; - -typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA - { - _In_ D3D12_DRED_FLAGS Flags; - _Out_ D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode; - } D3D12_DEVICE_REMOVED_EXTENDED_DATA; - -typedef -enum D3D12_DRED_ALLOCATION_TYPE - { - D3D12_DRED_ALLOCATION_TYPE_COMMAND_QUEUE = 19, - D3D12_DRED_ALLOCATION_TYPE_COMMAND_ALLOCATOR = 20, - D3D12_DRED_ALLOCATION_TYPE_PIPELINE_STATE = 21, - D3D12_DRED_ALLOCATION_TYPE_COMMAND_LIST = 22, - D3D12_DRED_ALLOCATION_TYPE_FENCE = 23, - D3D12_DRED_ALLOCATION_TYPE_DESCRIPTOR_HEAP = 24, - D3D12_DRED_ALLOCATION_TYPE_HEAP = 25, - D3D12_DRED_ALLOCATION_TYPE_QUERY_HEAP = 27, - D3D12_DRED_ALLOCATION_TYPE_COMMAND_SIGNATURE = 28, - D3D12_DRED_ALLOCATION_TYPE_PIPELINE_LIBRARY = 29, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER = 30, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_PROCESSOR = 32, - D3D12_DRED_ALLOCATION_TYPE_RESOURCE = 34, - D3D12_DRED_ALLOCATION_TYPE_PASS = 35, - D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSION = 36, - D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSIONPOLICY = 37, - D3D12_DRED_ALLOCATION_TYPE_PROTECTEDRESOURCESESSION = 38, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER_HEAP = 39, - D3D12_DRED_ALLOCATION_TYPE_COMMAND_POOL = 40, - D3D12_DRED_ALLOCATION_TYPE_COMMAND_RECORDER = 41, - D3D12_DRED_ALLOCATION_TYPE_STATE_OBJECT = 42, - D3D12_DRED_ALLOCATION_TYPE_METACOMMAND = 43, - D3D12_DRED_ALLOCATION_TYPE_SCHEDULINGGROUP = 44, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_ESTIMATOR = 45, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_VECTOR_HEAP = 46, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_EXTENSION_COMMAND = 47, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER = 48, - D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER_HEAP = 49, - D3D12_DRED_ALLOCATION_TYPE_INVALID = 0xffffffff - } D3D12_DRED_ALLOCATION_TYPE; - -typedef struct D3D12_DRED_ALLOCATION_NODE - { - const char *ObjectNameA; - const wchar_t *ObjectNameW; - D3D12_DRED_ALLOCATION_TYPE AllocationType; - const struct D3D12_DRED_ALLOCATION_NODE *pNext; - } D3D12_DRED_ALLOCATION_NODE; - -typedef struct D3D12_DRED_ALLOCATION_NODE1 - { - const char *ObjectNameA; - const wchar_t *ObjectNameW; - D3D12_DRED_ALLOCATION_TYPE AllocationType; - const struct D3D12_DRED_ALLOCATION_NODE1 *pNext; - const IUnknown *pObject; - } D3D12_DRED_ALLOCATION_NODE1; - -typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT - { - _Out_ const D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode; - } D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT; - -typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 - { - _Out_ const D3D12_AUTO_BREADCRUMB_NODE1 *pHeadAutoBreadcrumbNode; - } D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1; +#define ID3D12Device7_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ + ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) -typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT - { - D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA; - _Out_ const D3D12_DRED_ALLOCATION_NODE *pHeadExistingAllocationNode; - _Out_ const D3D12_DRED_ALLOCATION_NODE *pHeadRecentFreedAllocationNode; - } D3D12_DRED_PAGE_FAULT_OUTPUT; -typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT1 - { - D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA; - _Out_ const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode; - _Out_ const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode; - } D3D12_DRED_PAGE_FAULT_OUTPUT1; +#define ID3D12Device7_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ + ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) -typedef -enum D3D12_DRED_PAGE_FAULT_FLAGS - { - D3D12_DRED_PAGE_FAULT_FLAGS_NONE = 0 - } D3D12_DRED_PAGE_FAULT_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_DRED_PAGE_FAULT_FLAGS ); -typedef -enum D3D12_DRED_DEVICE_STATE - { - D3D12_DRED_DEVICE_STATE_UNKNOWN = 0, - D3D12_DRED_DEVICE_STATE_HUNG = 3, - D3D12_DRED_DEVICE_STATE_FAULT = 6, - D3D12_DRED_DEVICE_STATE_PAGEFAULT = 7 - } D3D12_DRED_DEVICE_STATE; +#define ID3D12Device7_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) \ + ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) -typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT2 - { - D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA; - _Out_ const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode; - _Out_ const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode; - D3D12_DRED_PAGE_FAULT_FLAGS PageFaultFlags; - } D3D12_DRED_PAGE_FAULT_OUTPUT2; +#define ID3D12Device7_CreateProtectedResourceSession1(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) -typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA1 - { - HRESULT DeviceRemovedReason; - D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT AutoBreadcrumbsOutput; - D3D12_DRED_PAGE_FAULT_OUTPUT PageFaultOutput; - } D3D12_DEVICE_REMOVED_EXTENDED_DATA1; +#endif /* COBJMACROS */ -typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA2 - { - HRESULT DeviceRemovedReason; - D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput; - D3D12_DRED_PAGE_FAULT_OUTPUT1 PageFaultOutput; - } D3D12_DEVICE_REMOVED_EXTENDED_DATA2; -typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA3 - { - HRESULT DeviceRemovedReason; - D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput; - D3D12_DRED_PAGE_FAULT_OUTPUT2 PageFaultOutput; - D3D12_DRED_DEVICE_STATE DeviceState; - } D3D12_DEVICE_REMOVED_EXTENDED_DATA3; +#endif /* C style interface */ -typedef struct D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA - { - D3D12_DRED_VERSION Version; - union - { - D3D12_DEVICE_REMOVED_EXTENDED_DATA Dred_1_0; - D3D12_DEVICE_REMOVED_EXTENDED_DATA1 Dred_1_1; - D3D12_DEVICE_REMOVED_EXTENDED_DATA2 Dred_1_2; - D3D12_DEVICE_REMOVED_EXTENDED_DATA3 Dred_1_3; - } ; - } D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0035_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0035_v0_0_s_ifspec; +#endif /* __ID3D12Device7_INTERFACE_DEFINED__ */ -#ifndef __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__ -#define __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__ -/* interface ID3D12DeviceRemovedExtendedDataSettings */ +#ifndef __ID3D12Device8_INTERFACE_DEFINED__ +#define __ID3D12Device8_INTERFACE_DEFINED__ + +/* interface ID3D12Device8 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedDataSettings; +EXTERN_C const IID IID_ID3D12Device8; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("82BC481C-6B9B-4030-AEDB-7EE3D1DF1E63") - ID3D12DeviceRemovedExtendedDataSettings : public IUnknown + MIDL_INTERFACE("9218E6BB-F944-4F7E-A75C-B1B2C7B701F3") + ID3D12Device8 : public ID3D12Device7 { public: - virtual void STDMETHODCALLTYPE SetAutoBreadcrumbsEnablement( - D3D12_DRED_ENABLEMENT Enablement) = 0; +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) + virtual D3D12_RESOURCE_ALLOCATION_INFO STDMETHODCALLTYPE GetResourceAllocationInfo2( + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1) = 0; +#else + virtual D3D12_RESOURCE_ALLOCATION_INFO *STDMETHODCALLTYPE GetResourceAllocationInfo2( + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1) = 0; +#endif + + virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource2( + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreatePlacedResource1( + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource) = 0; + + virtual void STDMETHODCALLTYPE CreateSamplerFeedbackUnorderedAccessView( + _In_opt_ ID3D12Resource *pTargetedResource, + _In_opt_ ID3D12Resource *pFeedbackResource, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + + virtual void STDMETHODCALLTYPE GetCopyableFootprints1( + _In_ const D3D12_RESOURCE_DESC1 *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Device8Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Device8 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Device8 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Device8 * This); + + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Device8 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Device8 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Device8 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Device8 * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device8 * This); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device8 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device8 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device8 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device8 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device8 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device8 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device8 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device8 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device8 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device8 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device8 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device8 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device8 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device8 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device8 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device8 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device8 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device8 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device8 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) +#if !defined(_WIN32) + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device8 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#else + D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device8 * This, + D3D12_HEAP_PROPERTIES * RetVal, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device8 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device8 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device8 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device8 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device8 * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); + + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device8 * This, + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj); + + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device8 * This, + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle); + + DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device8 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + DECLSPEC_XFGVIRT(ID3D12Device, Evict) + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device8 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device8 * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); + + DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device8 * This); + + DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device8 * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device8 * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device8 * This, + BOOL Enable); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device8 * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); + + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device8 * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + + DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) +#if !defined(_WIN32) + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device8 * This); + +#else + LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device8 * This, + LUID * RetVal); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( + ID3D12Device8 * This, + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary); + + DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) + HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( + ID3D12Device8 * This, + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent); + + DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) + HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( + ID3D12Device8 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); - virtual void STDMETHODCALLTYPE SetPageFaultEnablement( - D3D12_DRED_ENABLEMENT Enablement) = 0; + DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( + ID3D12Device8 * This, + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); - virtual void STDMETHODCALLTYPE SetWatsonDumpEnablement( - D3D12_DRED_ENABLEMENT Enablement) = 0; + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( + ID3D12Device8 * This, + _In_ const void *pAddress, + REFIID riid, + _COM_Outptr_ void **ppvHeap); - }; - - -#else /* C style interface */ - - typedef struct ID3D12DeviceRemovedExtendedDataSettingsVtbl - { - BEGIN_INTERFACE + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( + ID3D12Device8 * This, + _In_ HANDLE hFileMapping, + REFIID riid, + _COM_Outptr_ void **ppvHeap); - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DeviceRemovedExtendedDataSettings * This, + DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) + HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( + ID3D12Device8 * This, + D3D12_RESIDENCY_FLAGS Flags, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_ ID3D12Fence *pFenceToSignal, + UINT64 FenceValueToSignal); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( + ID3D12Device8 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ D3D12_COMMAND_LIST_FLAGS flags, REFIID riid, - _COM_Outptr_ void **ppvObject); + _COM_Outptr_ void **ppCommandList); - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DeviceRemovedExtendedDataSettings * This); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( + ID3D12Device8 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DeviceRemovedExtendedDataSettings * This); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( + ID3D12Device8 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetAutoBreadcrumbsEnablement) - void ( STDMETHODCALLTYPE *SetAutoBreadcrumbsEnablement )( - ID3D12DeviceRemovedExtendedDataSettings * This, - D3D12_DRED_ENABLEMENT Enablement); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) + HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( + ID3D12Device8 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetPageFaultEnablement) - void ( STDMETHODCALLTYPE *SetPageFaultEnablement )( - ID3D12DeviceRemovedExtendedDataSettings * This, - D3D12_DRED_ENABLEMENT Enablement); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( + ID3D12Device8 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetWatsonDumpEnablement) - void ( STDMETHODCALLTYPE *SetWatsonDumpEnablement )( - ID3D12DeviceRemovedExtendedDataSettings * This, - D3D12_DRED_ENABLEMENT Enablement); + DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device8 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device8 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) + HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( + ID3D12Device8 * This, + _In_ ID3D12LifetimeOwner *pOwner, + REFIID riid, + _COM_Outptr_ void **ppvTracker); + + DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) + void ( STDMETHODCALLTYPE *RemoveDevice )( + ID3D12Device8 * This); + + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( + ID3D12Device8 * This, + _Inout_ UINT *pNumMetaCommands, + _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); + + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( + ID3D12Device8 * This, + _In_ REFGUID CommandId, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _Out_opt_ UINT *pTotalStructureSizeInBytes, + _Inout_ UINT *pParameterCount, + _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); + + DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) + HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( + ID3D12Device8 * This, + _In_ REFGUID CommandId, + _In_ UINT NodeMask, + _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, + _In_ SIZE_T CreationParametersDataSizeInBytes, + REFIID riid, + _COM_Outptr_ void **ppMetaCommand); + + DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) + HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( + ID3D12Device8 * This, + const D3D12_STATE_OBJECT_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppStateObject); + + DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) + void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( + ID3D12Device8 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, + _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); + + DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) + D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( + ID3D12Device8 * This, + _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, + _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); + + DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) + HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( + ID3D12Device8 * This, + D3D12_BACKGROUND_PROCESSING_MODE Mode, + D3D12_MEASUREMENTS_ACTION MeasurementsAction, + _In_opt_ HANDLE hEventToSignalUponCompletion, + _Out_opt_ BOOL *pbFurtherMeasurementsDesired); + + DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject) + HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( + ID3D12Device8 * This, + const D3D12_STATE_OBJECT_DESC *pAddition, + ID3D12StateObject *pStateObjectToGrowFrom, + REFIID riid, + _COM_Outptr_ void **ppNewStateObject); + + DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( + ID3D12Device8 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); + + DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( + ID3D12Device8 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( + ID3D12Device8 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( + ID3D12Device8 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( + ID3D12Device8 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( + ID3D12Device8 * This, + _In_opt_ ID3D12Resource *pTargetedResource, + _In_opt_ ID3D12Resource *pFeedbackResource, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1) + void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( + ID3D12Device8 * This, + _In_ const D3D12_RESOURCE_DESC1 *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); END_INTERFACE - } ID3D12DeviceRemovedExtendedDataSettingsVtbl; + } ID3D12Device8Vtbl; - interface ID3D12DeviceRemovedExtendedDataSettings + interface ID3D12Device8 { - CONST_VTBL struct ID3D12DeviceRemovedExtendedDataSettingsVtbl *lpVtbl; + CONST_VTBL struct ID3D12Device8Vtbl *lpVtbl; }; @@ -15044,249 +20046,259 @@ EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedDataSettings; #ifdef COBJMACROS -#define ID3D12DeviceRemovedExtendedDataSettings_QueryInterface(This,riid,ppvObject) \ +#define ID3D12Device8_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12DeviceRemovedExtendedDataSettings_AddRef(This) \ +#define ID3D12Device8_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12DeviceRemovedExtendedDataSettings_Release(This) \ +#define ID3D12Device8_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12DeviceRemovedExtendedDataSettings_SetAutoBreadcrumbsEnablement(This,Enablement) \ - ( (This)->lpVtbl -> SetAutoBreadcrumbsEnablement(This,Enablement) ) +#define ID3D12Device8_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12DeviceRemovedExtendedDataSettings_SetPageFaultEnablement(This,Enablement) \ - ( (This)->lpVtbl -> SetPageFaultEnablement(This,Enablement) ) +#define ID3D12Device8_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12DeviceRemovedExtendedDataSettings_SetWatsonDumpEnablement(This,Enablement) \ - ( (This)->lpVtbl -> SetWatsonDumpEnablement(This,Enablement) ) +#define ID3D12Device8_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#endif /* COBJMACROS */ +#define ID3D12Device8_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) -#endif /* C style interface */ +#define ID3D12Device8_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) +#define ID3D12Device8_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) +#define ID3D12Device8_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) +#define ID3D12Device8_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) -#endif /* __ID3D12DeviceRemovedExtendedDataSettings_INTERFACE_DEFINED__ */ +#define ID3D12Device8_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) +#define ID3D12Device8_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) -#ifndef __ID3D12DeviceRemovedExtendedDataSettings1_INTERFACE_DEFINED__ -#define __ID3D12DeviceRemovedExtendedDataSettings1_INTERFACE_DEFINED__ +#define ID3D12Device8_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) -/* interface ID3D12DeviceRemovedExtendedDataSettings1 */ -/* [unique][local][object][uuid] */ +#define ID3D12Device8_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) +#define ID3D12Device8_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) -EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedDataSettings1; +#define ID3D12Device8_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("DBD5AE51-3317-4F0A-ADF9-1D7CEDCAAE0B") - ID3D12DeviceRemovedExtendedDataSettings1 : public ID3D12DeviceRemovedExtendedDataSettings - { - public: - virtual void STDMETHODCALLTYPE SetBreadcrumbContextEnablement( - D3D12_DRED_ENABLEMENT Enablement) = 0; - - }; - - -#else /* C style interface */ +#define ID3D12Device8_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) - typedef struct ID3D12DeviceRemovedExtendedDataSettings1Vtbl - { - BEGIN_INTERFACE - - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DeviceRemovedExtendedDataSettings1 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DeviceRemovedExtendedDataSettings1 * This); - - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DeviceRemovedExtendedDataSettings1 * This); - - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetAutoBreadcrumbsEnablement) - void ( STDMETHODCALLTYPE *SetAutoBreadcrumbsEnablement )( - ID3D12DeviceRemovedExtendedDataSettings1 * This, - D3D12_DRED_ENABLEMENT Enablement); - - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetPageFaultEnablement) - void ( STDMETHODCALLTYPE *SetPageFaultEnablement )( - ID3D12DeviceRemovedExtendedDataSettings1 * This, - D3D12_DRED_ENABLEMENT Enablement); - - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetWatsonDumpEnablement) - void ( STDMETHODCALLTYPE *SetWatsonDumpEnablement )( - ID3D12DeviceRemovedExtendedDataSettings1 * This, - D3D12_DRED_ENABLEMENT Enablement); - - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings1, SetBreadcrumbContextEnablement) - void ( STDMETHODCALLTYPE *SetBreadcrumbContextEnablement )( - ID3D12DeviceRemovedExtendedDataSettings1 * This, - D3D12_DRED_ENABLEMENT Enablement); - - END_INTERFACE - } ID3D12DeviceRemovedExtendedDataSettings1Vtbl; +#define ID3D12Device8_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) - interface ID3D12DeviceRemovedExtendedDataSettings1 - { - CONST_VTBL struct ID3D12DeviceRemovedExtendedDataSettings1Vtbl *lpVtbl; - }; +#define ID3D12Device8_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) - +#define ID3D12Device8_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) -#ifdef COBJMACROS +#define ID3D12Device8_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) +#define ID3D12Device8_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) -#define ID3D12DeviceRemovedExtendedDataSettings1_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) +#define ID3D12Device8_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) -#define ID3D12DeviceRemovedExtendedDataSettings1_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) +#define ID3D12Device8_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) +#if !defined(_WIN32) -#define ID3D12DeviceRemovedExtendedDataSettings1_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) +#define ID3D12Device8_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) +#else +#define ID3D12Device8_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) +#endif +#if !defined(_WIN32) +#define ID3D12Device8_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) +#else +#define ID3D12Device8_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) +#endif -#define ID3D12DeviceRemovedExtendedDataSettings1_SetAutoBreadcrumbsEnablement(This,Enablement) \ - ( (This)->lpVtbl -> SetAutoBreadcrumbsEnablement(This,Enablement) ) +#define ID3D12Device8_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) -#define ID3D12DeviceRemovedExtendedDataSettings1_SetPageFaultEnablement(This,Enablement) \ - ( (This)->lpVtbl -> SetPageFaultEnablement(This,Enablement) ) +#define ID3D12Device8_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) -#define ID3D12DeviceRemovedExtendedDataSettings1_SetWatsonDumpEnablement(This,Enablement) \ - ( (This)->lpVtbl -> SetWatsonDumpEnablement(This,Enablement) ) +#define ID3D12Device8_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12Device8_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) -#define ID3D12DeviceRemovedExtendedDataSettings1_SetBreadcrumbContextEnablement(This,Enablement) \ - ( (This)->lpVtbl -> SetBreadcrumbContextEnablement(This,Enablement) ) +#define ID3D12Device8_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) -#endif /* COBJMACROS */ +#define ID3D12Device8_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) +#define ID3D12Device8_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) -#endif /* C style interface */ +#define ID3D12Device8_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) +#define ID3D12Device8_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) +#define ID3D12Device8_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) +#define ID3D12Device8_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) -#endif /* __ID3D12DeviceRemovedExtendedDataSettings1_INTERFACE_DEFINED__ */ +#define ID3D12Device8_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) +#define ID3D12Device8_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) -#ifndef __ID3D12DeviceRemovedExtendedDataSettings2_INTERFACE_DEFINED__ -#define __ID3D12DeviceRemovedExtendedDataSettings2_INTERFACE_DEFINED__ +#define ID3D12Device8_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) + +#define ID3D12Device8_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) + +#define ID3D12Device8_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) +#if !defined(_WIN32) + +#define ID3D12Device8_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) +#else +#define ID3D12Device8_GetAdapterLuid(This,RetVal) \ + ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) +#endif + + +#define ID3D12Device8_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) + +#define ID3D12Device8_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) + +#define ID3D12Device8_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) + + +#define ID3D12Device8_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) + + +#define ID3D12Device8_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) + +#define ID3D12Device8_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) + +#define ID3D12Device8_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ + ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) + + +#define ID3D12Device8_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) + +#define ID3D12Device8_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) + +#define ID3D12Device8_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) + +#define ID3D12Device8_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) + +#define ID3D12Device8_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) +#if !defined(_WIN32) + +#define ID3D12Device8_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device8_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif -/* interface ID3D12DeviceRemovedExtendedDataSettings2 */ -/* [unique][local][object][uuid] */ +#define ID3D12Device8_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ + ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) -EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedDataSettings2; +#define ID3D12Device8_RemoveDevice(This) \ + ( (This)->lpVtbl -> RemoveDevice(This) ) -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("61552388-01ab-4008-a436-83db189566ea") - ID3D12DeviceRemovedExtendedDataSettings2 : public ID3D12DeviceRemovedExtendedDataSettings1 - { - public: - virtual void STDMETHODCALLTYPE UseMarkersOnlyAutoBreadcrumbs( - BOOL MarkersOnly) = 0; - - }; - - -#else /* C style interface */ +#define ID3D12Device8_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) - typedef struct ID3D12DeviceRemovedExtendedDataSettings2Vtbl - { - BEGIN_INTERFACE - - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DeviceRemovedExtendedDataSettings2 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DeviceRemovedExtendedDataSettings2 * This); - - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DeviceRemovedExtendedDataSettings2 * This); - - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetAutoBreadcrumbsEnablement) - void ( STDMETHODCALLTYPE *SetAutoBreadcrumbsEnablement )( - ID3D12DeviceRemovedExtendedDataSettings2 * This, - D3D12_DRED_ENABLEMENT Enablement); - - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetPageFaultEnablement) - void ( STDMETHODCALLTYPE *SetPageFaultEnablement )( - ID3D12DeviceRemovedExtendedDataSettings2 * This, - D3D12_DRED_ENABLEMENT Enablement); - - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings, SetWatsonDumpEnablement) - void ( STDMETHODCALLTYPE *SetWatsonDumpEnablement )( - ID3D12DeviceRemovedExtendedDataSettings2 * This, - D3D12_DRED_ENABLEMENT Enablement); - - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings1, SetBreadcrumbContextEnablement) - void ( STDMETHODCALLTYPE *SetBreadcrumbContextEnablement )( - ID3D12DeviceRemovedExtendedDataSettings2 * This, - D3D12_DRED_ENABLEMENT Enablement); - - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedDataSettings2, UseMarkersOnlyAutoBreadcrumbs) - void ( STDMETHODCALLTYPE *UseMarkersOnlyAutoBreadcrumbs )( - ID3D12DeviceRemovedExtendedDataSettings2 * This, - BOOL MarkersOnly); - - END_INTERFACE - } ID3D12DeviceRemovedExtendedDataSettings2Vtbl; +#define ID3D12Device8_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) - interface ID3D12DeviceRemovedExtendedDataSettings2 - { - CONST_VTBL struct ID3D12DeviceRemovedExtendedDataSettings2Vtbl *lpVtbl; - }; +#define ID3D12Device8_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ + ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) - +#define ID3D12Device8_CreateStateObject(This,pDesc,riid,ppStateObject) \ + ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) -#ifdef COBJMACROS +#define ID3D12Device8_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ + ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) +#define ID3D12Device8_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ + ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) -#define ID3D12DeviceRemovedExtendedDataSettings2_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12DeviceRemovedExtendedDataSettings2_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) +#define ID3D12Device8_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ + ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) -#define ID3D12DeviceRemovedExtendedDataSettings2_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) +#define ID3D12Device8_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) \ + ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) -#define ID3D12DeviceRemovedExtendedDataSettings2_SetAutoBreadcrumbsEnablement(This,Enablement) \ - ( (This)->lpVtbl -> SetAutoBreadcrumbsEnablement(This,Enablement) ) +#define ID3D12Device8_CreateProtectedResourceSession1(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) -#define ID3D12DeviceRemovedExtendedDataSettings2_SetPageFaultEnablement(This,Enablement) \ - ( (This)->lpVtbl -> SetPageFaultEnablement(This,Enablement) ) +#if !defined(_WIN32) -#define ID3D12DeviceRemovedExtendedDataSettings2_SetWatsonDumpEnablement(This,Enablement) \ - ( (This)->lpVtbl -> SetWatsonDumpEnablement(This,Enablement) ) +#define ID3D12Device8_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device8_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif +#define ID3D12Device8_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) -#define ID3D12DeviceRemovedExtendedDataSettings2_SetBreadcrumbContextEnablement(This,Enablement) \ - ( (This)->lpVtbl -> SetBreadcrumbContextEnablement(This,Enablement) ) +#define ID3D12Device8_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12Device8_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) -#define ID3D12DeviceRemovedExtendedDataSettings2_UseMarkersOnlyAutoBreadcrumbs(This,MarkersOnly) \ - ( (This)->lpVtbl -> UseMarkersOnlyAutoBreadcrumbs(This,MarkersOnly) ) +#define ID3D12Device8_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) #endif /* COBJMACROS */ @@ -15296,69 +20308,147 @@ EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedDataSettings2; -#endif /* __ID3D12DeviceRemovedExtendedDataSettings2_INTERFACE_DEFINED__ */ +#endif /* __ID3D12Device8_INTERFACE_DEFINED__ */ -#ifndef __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__ -#define __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__ +#ifndef __ID3D12Resource1_INTERFACE_DEFINED__ +#define __ID3D12Resource1_INTERFACE_DEFINED__ -/* interface ID3D12DeviceRemovedExtendedData */ +/* interface ID3D12Resource1 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData; +EXTERN_C const IID IID_ID3D12Resource1; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("98931D33-5AE8-4791-AA3C-1A73A2934E71") - ID3D12DeviceRemovedExtendedData : public IUnknown + MIDL_INTERFACE("9D5E227A-4430-4161-88B3-3ECA6BB16E19") + ID3D12Resource1 : public ID3D12Resource { public: - virtual HRESULT STDMETHODCALLTYPE GetAutoBreadcrumbsOutput( - _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetPageFaultAllocationOutput( - _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput) = 0; + virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( + REFIID riid, + _COM_Outptr_opt_ void **ppProtectedSession) = 0; }; #else /* C style interface */ - typedef struct ID3D12DeviceRemovedExtendedDataVtbl + typedef struct ID3D12Resource1Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DeviceRemovedExtendedData * This, + ID3D12Resource1 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DeviceRemovedExtendedData * This); + ID3D12Resource1 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DeviceRemovedExtendedData * This); + ID3D12Resource1 * This); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetAutoBreadcrumbsOutput) - HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput )( - ID3D12DeviceRemovedExtendedData * This, - _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput); + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Resource1 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetPageFaultAllocationOutput) - HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput )( - ID3D12DeviceRemovedExtendedData * This, - _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput); + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Resource1 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Resource1 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Resource1 * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12Resource1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + DECLSPEC_XFGVIRT(ID3D12Resource, Map) + HRESULT ( STDMETHODCALLTYPE *Map )( + ID3D12Resource1 * This, + UINT Subresource, + _In_opt_ const D3D12_RANGE *pReadRange, + _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource")) void **ppData); + + DECLSPEC_XFGVIRT(ID3D12Resource, Unmap) + void ( STDMETHODCALLTYPE *Unmap )( + ID3D12Resource1 * This, + UINT Subresource, + _In_opt_ const D3D12_RANGE *pWrittenRange); + + DECLSPEC_XFGVIRT(ID3D12Resource, GetDesc) +#if !defined(_WIN32) + D3D12_RESOURCE_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12Resource1 * This); + +#else + D3D12_RESOURCE_DESC *( STDMETHODCALLTYPE *GetDesc )( + ID3D12Resource1 * This, + D3D12_RESOURCE_DESC * RetVal); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Resource, GetGPUVirtualAddress) + D3D12_GPU_VIRTUAL_ADDRESS ( STDMETHODCALLTYPE *GetGPUVirtualAddress )( + ID3D12Resource1 * This); + + DECLSPEC_XFGVIRT(ID3D12Resource, WriteToSubresource) + HRESULT ( STDMETHODCALLTYPE *WriteToSubresource )( + ID3D12Resource1 * This, + UINT DstSubresource, + _In_opt_ const D3D12_BOX *pDstBox, + _In_ const void *pSrcData, + UINT SrcRowPitch, + UINT SrcDepthPitch); + + DECLSPEC_XFGVIRT(ID3D12Resource, ReadFromSubresource) + HRESULT ( STDMETHODCALLTYPE *ReadFromSubresource )( + ID3D12Resource1 * This, + _Out_ void *pDstData, + UINT DstRowPitch, + UINT DstDepthPitch, + UINT SrcSubresource, + _In_opt_ const D3D12_BOX *pSrcBox); + + DECLSPEC_XFGVIRT(ID3D12Resource, GetHeapProperties) + HRESULT ( STDMETHODCALLTYPE *GetHeapProperties )( + ID3D12Resource1 * This, + _Out_opt_ D3D12_HEAP_PROPERTIES *pHeapProperties, + _Out_opt_ D3D12_HEAP_FLAGS *pHeapFlags); + + DECLSPEC_XFGVIRT(ID3D12Resource1, GetProtectedResourceSession) + HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( + ID3D12Resource1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppProtectedSession); END_INTERFACE - } ID3D12DeviceRemovedExtendedDataVtbl; + } ID3D12Resource1Vtbl; - interface ID3D12DeviceRemovedExtendedData + interface ID3D12Resource1 { - CONST_VTBL struct ID3D12DeviceRemovedExtendedDataVtbl *lpVtbl; + CONST_VTBL struct ID3D12Resource1Vtbl *lpVtbl; }; @@ -15366,21 +20456,63 @@ EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData; #ifdef COBJMACROS -#define ID3D12DeviceRemovedExtendedData_QueryInterface(This,riid,ppvObject) \ +#define ID3D12Resource1_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12DeviceRemovedExtendedData_AddRef(This) \ +#define ID3D12Resource1_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12DeviceRemovedExtendedData_Release(This) \ +#define ID3D12Resource1_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12DeviceRemovedExtendedData_GetAutoBreadcrumbsOutput(This,pOutput) \ - ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput(This,pOutput) ) +#define ID3D12Resource1_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12DeviceRemovedExtendedData_GetPageFaultAllocationOutput(This,pOutput) \ - ( (This)->lpVtbl -> GetPageFaultAllocationOutput(This,pOutput) ) +#define ID3D12Resource1_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Resource1_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Resource1_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Resource1_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12Resource1_Map(This,Subresource,pReadRange,ppData) \ + ( (This)->lpVtbl -> Map(This,Subresource,pReadRange,ppData) ) + +#define ID3D12Resource1_Unmap(This,Subresource,pWrittenRange) \ + ( (This)->lpVtbl -> Unmap(This,Subresource,pWrittenRange) ) +#if !defined(_WIN32) + +#define ID3D12Resource1_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) +#else +#define ID3D12Resource1_GetDesc(This,RetVal) \ + ( (This)->lpVtbl -> GetDesc(This,RetVal) ) +#endif + +#define ID3D12Resource1_GetGPUVirtualAddress(This) \ + ( (This)->lpVtbl -> GetGPUVirtualAddress(This) ) + +#define ID3D12Resource1_WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) \ + ( (This)->lpVtbl -> WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) ) + +#define ID3D12Resource1_ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) \ + ( (This)->lpVtbl -> ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) ) + +#define ID3D12Resource1_GetHeapProperties(This,pHeapProperties,pHeapFlags) \ + ( (This)->lpVtbl -> GetHeapProperties(This,pHeapProperties,pHeapFlags) ) + + +#define ID3D12Resource1_GetProtectedResourceSession(This,riid,ppProtectedSession) \ + ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) #endif /* COBJMACROS */ @@ -15390,79 +20522,162 @@ EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData; -#endif /* __ID3D12DeviceRemovedExtendedData_INTERFACE_DEFINED__ */ +#endif /* __ID3D12Resource1_INTERFACE_DEFINED__ */ -#ifndef __ID3D12DeviceRemovedExtendedData1_INTERFACE_DEFINED__ -#define __ID3D12DeviceRemovedExtendedData1_INTERFACE_DEFINED__ +#ifndef __ID3D12Resource2_INTERFACE_DEFINED__ +#define __ID3D12Resource2_INTERFACE_DEFINED__ -/* interface ID3D12DeviceRemovedExtendedData1 */ +/* interface ID3D12Resource2 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData1; +EXTERN_C const IID IID_ID3D12Resource2; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("9727A022-CF1D-4DDA-9EBA-EFFA653FC506") - ID3D12DeviceRemovedExtendedData1 : public ID3D12DeviceRemovedExtendedData + MIDL_INTERFACE("BE36EC3B-EA85-4AEB-A45A-E9D76404A495") + ID3D12Resource2 : public ID3D12Resource1 { public: - virtual HRESULT STDMETHODCALLTYPE GetAutoBreadcrumbsOutput1( - _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 *pOutput) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetPageFaultAllocationOutput1( - _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT1 *pOutput) = 0; +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) + virtual D3D12_RESOURCE_DESC1 STDMETHODCALLTYPE GetDesc1( void) = 0; +#else + virtual D3D12_RESOURCE_DESC1 *STDMETHODCALLTYPE GetDesc1( + D3D12_RESOURCE_DESC1 * RetVal) = 0; +#endif }; #else /* C style interface */ - typedef struct ID3D12DeviceRemovedExtendedData1Vtbl + typedef struct ID3D12Resource2Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DeviceRemovedExtendedData1 * This, + ID3D12Resource2 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DeviceRemovedExtendedData1 * This); + ID3D12Resource2 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DeviceRemovedExtendedData1 * This); + ID3D12Resource2 * This); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetAutoBreadcrumbsOutput) - HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput )( - ID3D12DeviceRemovedExtendedData1 * This, - _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput); + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Resource2 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetPageFaultAllocationOutput) - HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput )( - ID3D12DeviceRemovedExtendedData1 * This, - _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput); + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Resource2 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData1, GetAutoBreadcrumbsOutput1) - HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput1 )( - ID3D12DeviceRemovedExtendedData1 * This, - _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 *pOutput); + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Resource2 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData1, GetPageFaultAllocationOutput1) - HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput1 )( - ID3D12DeviceRemovedExtendedData1 * This, - _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT1 *pOutput); + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Resource2 * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12Resource2 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + DECLSPEC_XFGVIRT(ID3D12Resource, Map) + HRESULT ( STDMETHODCALLTYPE *Map )( + ID3D12Resource2 * This, + UINT Subresource, + _In_opt_ const D3D12_RANGE *pReadRange, + _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource")) void **ppData); + + DECLSPEC_XFGVIRT(ID3D12Resource, Unmap) + void ( STDMETHODCALLTYPE *Unmap )( + ID3D12Resource2 * This, + UINT Subresource, + _In_opt_ const D3D12_RANGE *pWrittenRange); + + DECLSPEC_XFGVIRT(ID3D12Resource, GetDesc) +#if !defined(_WIN32) + D3D12_RESOURCE_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12Resource2 * This); + +#else + D3D12_RESOURCE_DESC *( STDMETHODCALLTYPE *GetDesc )( + ID3D12Resource2 * This, + D3D12_RESOURCE_DESC * RetVal); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Resource, GetGPUVirtualAddress) + D3D12_GPU_VIRTUAL_ADDRESS ( STDMETHODCALLTYPE *GetGPUVirtualAddress )( + ID3D12Resource2 * This); + + DECLSPEC_XFGVIRT(ID3D12Resource, WriteToSubresource) + HRESULT ( STDMETHODCALLTYPE *WriteToSubresource )( + ID3D12Resource2 * This, + UINT DstSubresource, + _In_opt_ const D3D12_BOX *pDstBox, + _In_ const void *pSrcData, + UINT SrcRowPitch, + UINT SrcDepthPitch); + + DECLSPEC_XFGVIRT(ID3D12Resource, ReadFromSubresource) + HRESULT ( STDMETHODCALLTYPE *ReadFromSubresource )( + ID3D12Resource2 * This, + _Out_ void *pDstData, + UINT DstRowPitch, + UINT DstDepthPitch, + UINT SrcSubresource, + _In_opt_ const D3D12_BOX *pSrcBox); + + DECLSPEC_XFGVIRT(ID3D12Resource, GetHeapProperties) + HRESULT ( STDMETHODCALLTYPE *GetHeapProperties )( + ID3D12Resource2 * This, + _Out_opt_ D3D12_HEAP_PROPERTIES *pHeapProperties, + _Out_opt_ D3D12_HEAP_FLAGS *pHeapFlags); + + DECLSPEC_XFGVIRT(ID3D12Resource1, GetProtectedResourceSession) + HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( + ID3D12Resource2 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppProtectedSession); + + DECLSPEC_XFGVIRT(ID3D12Resource2, GetDesc1) +#if !defined(_WIN32) + D3D12_RESOURCE_DESC1 ( STDMETHODCALLTYPE *GetDesc1 )( + ID3D12Resource2 * This); + +#else + D3D12_RESOURCE_DESC1 *( STDMETHODCALLTYPE *GetDesc1 )( + ID3D12Resource2 * This, + D3D12_RESOURCE_DESC1 * RetVal); + +#endif END_INTERFACE - } ID3D12DeviceRemovedExtendedData1Vtbl; + } ID3D12Resource2Vtbl; - interface ID3D12DeviceRemovedExtendedData1 + interface ID3D12Resource2 { - CONST_VTBL struct ID3D12DeviceRemovedExtendedData1Vtbl *lpVtbl; + CONST_VTBL struct ID3D12Resource2Vtbl *lpVtbl; }; @@ -15470,28 +20685,72 @@ EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData1; #ifdef COBJMACROS -#define ID3D12DeviceRemovedExtendedData1_QueryInterface(This,riid,ppvObject) \ +#define ID3D12Resource2_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12DeviceRemovedExtendedData1_AddRef(This) \ +#define ID3D12Resource2_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12DeviceRemovedExtendedData1_Release(This) \ +#define ID3D12Resource2_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12DeviceRemovedExtendedData1_GetAutoBreadcrumbsOutput(This,pOutput) \ - ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput(This,pOutput) ) +#define ID3D12Resource2_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Resource2_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Resource2_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Resource2_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Resource2_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12Resource2_Map(This,Subresource,pReadRange,ppData) \ + ( (This)->lpVtbl -> Map(This,Subresource,pReadRange,ppData) ) + +#define ID3D12Resource2_Unmap(This,Subresource,pWrittenRange) \ + ( (This)->lpVtbl -> Unmap(This,Subresource,pWrittenRange) ) +#if !defined(_WIN32) + +#define ID3D12Resource2_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) +#else +#define ID3D12Resource2_GetDesc(This,RetVal) \ + ( (This)->lpVtbl -> GetDesc(This,RetVal) ) +#endif + +#define ID3D12Resource2_GetGPUVirtualAddress(This) \ + ( (This)->lpVtbl -> GetGPUVirtualAddress(This) ) + +#define ID3D12Resource2_WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) \ + ( (This)->lpVtbl -> WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) ) + +#define ID3D12Resource2_ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) \ + ( (This)->lpVtbl -> ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) ) -#define ID3D12DeviceRemovedExtendedData1_GetPageFaultAllocationOutput(This,pOutput) \ - ( (This)->lpVtbl -> GetPageFaultAllocationOutput(This,pOutput) ) +#define ID3D12Resource2_GetHeapProperties(This,pHeapProperties,pHeapFlags) \ + ( (This)->lpVtbl -> GetHeapProperties(This,pHeapProperties,pHeapFlags) ) -#define ID3D12DeviceRemovedExtendedData1_GetAutoBreadcrumbsOutput1(This,pOutput) \ - ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput1(This,pOutput) ) +#define ID3D12Resource2_GetProtectedResourceSession(This,riid,ppProtectedSession) \ + ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) -#define ID3D12DeviceRemovedExtendedData1_GetPageFaultAllocationOutput1(This,pOutput) \ - ( (This)->lpVtbl -> GetPageFaultAllocationOutput1(This,pOutput) ) +#if !defined(_WIN32) + +#define ID3D12Resource2_GetDesc1(This) \ + ( (This)->lpVtbl -> GetDesc1(This) ) +#else +#define ID3D12Resource2_GetDesc1(This,RetVal) \ + ( (This)->lpVtbl -> GetDesc1(This,RetVal) ) +#endif #endif /* COBJMACROS */ @@ -15501,87 +20760,106 @@ EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData1; -#endif /* __ID3D12DeviceRemovedExtendedData1_INTERFACE_DEFINED__ */ +#endif /* __ID3D12Resource2_INTERFACE_DEFINED__ */ -#ifndef __ID3D12DeviceRemovedExtendedData2_INTERFACE_DEFINED__ -#define __ID3D12DeviceRemovedExtendedData2_INTERFACE_DEFINED__ +#ifndef __ID3D12Heap1_INTERFACE_DEFINED__ +#define __ID3D12Heap1_INTERFACE_DEFINED__ -/* interface ID3D12DeviceRemovedExtendedData2 */ +/* interface ID3D12Heap1 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData2; +EXTERN_C const IID IID_ID3D12Heap1; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("67FC5816-E4CA-4915-BF18-42541272DA54") - ID3D12DeviceRemovedExtendedData2 : public ID3D12DeviceRemovedExtendedData1 + MIDL_INTERFACE("572F7389-2168-49E3-9693-D6DF5871BF6D") + ID3D12Heap1 : public ID3D12Heap { public: - virtual HRESULT STDMETHODCALLTYPE GetPageFaultAllocationOutput2( - _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT2 *pOutput) = 0; - - virtual D3D12_DRED_DEVICE_STATE STDMETHODCALLTYPE GetDeviceState( void) = 0; + virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( + REFIID riid, + _COM_Outptr_opt_ void **ppProtectedSession) = 0; }; #else /* C style interface */ - typedef struct ID3D12DeviceRemovedExtendedData2Vtbl + typedef struct ID3D12Heap1Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DeviceRemovedExtendedData2 * This, + ID3D12Heap1 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DeviceRemovedExtendedData2 * This); + ID3D12Heap1 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DeviceRemovedExtendedData2 * This); + ID3D12Heap1 * This); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetAutoBreadcrumbsOutput) - HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput )( - ID3D12DeviceRemovedExtendedData2 * This, - _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *pOutput); + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Heap1 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData, GetPageFaultAllocationOutput) - HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput )( - ID3D12DeviceRemovedExtendedData2 * This, - _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT *pOutput); + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Heap1 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData1, GetAutoBreadcrumbsOutput1) - HRESULT ( STDMETHODCALLTYPE *GetAutoBreadcrumbsOutput1 )( - ID3D12DeviceRemovedExtendedData2 * This, - _Out_ D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 *pOutput); + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Heap1 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData1, GetPageFaultAllocationOutput1) - HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput1 )( - ID3D12DeviceRemovedExtendedData2 * This, - _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT1 *pOutput); + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Heap1 * This, + _In_z_ LPCWSTR Name); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData2, GetPageFaultAllocationOutput2) - HRESULT ( STDMETHODCALLTYPE *GetPageFaultAllocationOutput2 )( - ID3D12DeviceRemovedExtendedData2 * This, - _Out_ D3D12_DRED_PAGE_FAULT_OUTPUT2 *pOutput); + DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12Heap1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); - DECLSPEC_XFGVIRT(ID3D12DeviceRemovedExtendedData2, GetDeviceState) - D3D12_DRED_DEVICE_STATE ( STDMETHODCALLTYPE *GetDeviceState )( - ID3D12DeviceRemovedExtendedData2 * This); + DECLSPEC_XFGVIRT(ID3D12Heap, GetDesc) +#if !defined(_WIN32) + D3D12_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12Heap1 * This); + +#else + D3D12_HEAP_DESC *( STDMETHODCALLTYPE *GetDesc )( + ID3D12Heap1 * This, + D3D12_HEAP_DESC * RetVal); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Heap1, GetProtectedResourceSession) + HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( + ID3D12Heap1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppProtectedSession); END_INTERFACE - } ID3D12DeviceRemovedExtendedData2Vtbl; + } ID3D12Heap1Vtbl; - interface ID3D12DeviceRemovedExtendedData2 + interface ID3D12Heap1 { - CONST_VTBL struct ID3D12DeviceRemovedExtendedData2Vtbl *lpVtbl; + CONST_VTBL struct ID3D12Heap1Vtbl *lpVtbl; }; @@ -15589,636 +20867,554 @@ EXTERN_C const IID IID_ID3D12DeviceRemovedExtendedData2; #ifdef COBJMACROS -#define ID3D12DeviceRemovedExtendedData2_QueryInterface(This,riid,ppvObject) \ +#define ID3D12Heap1_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12DeviceRemovedExtendedData2_AddRef(This) \ +#define ID3D12Heap1_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12DeviceRemovedExtendedData2_Release(This) \ +#define ID3D12Heap1_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12DeviceRemovedExtendedData2_GetAutoBreadcrumbsOutput(This,pOutput) \ - ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput(This,pOutput) ) - -#define ID3D12DeviceRemovedExtendedData2_GetPageFaultAllocationOutput(This,pOutput) \ - ( (This)->lpVtbl -> GetPageFaultAllocationOutput(This,pOutput) ) - - -#define ID3D12DeviceRemovedExtendedData2_GetAutoBreadcrumbsOutput1(This,pOutput) \ - ( (This)->lpVtbl -> GetAutoBreadcrumbsOutput1(This,pOutput) ) +#define ID3D12Heap1_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12DeviceRemovedExtendedData2_GetPageFaultAllocationOutput1(This,pOutput) \ - ( (This)->lpVtbl -> GetPageFaultAllocationOutput1(This,pOutput) ) +#define ID3D12Heap1_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) +#define ID3D12Heap1_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12DeviceRemovedExtendedData2_GetPageFaultAllocationOutput2(This,pOutput) \ - ( (This)->lpVtbl -> GetPageFaultAllocationOutput2(This,pOutput) ) +#define ID3D12Heap1_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12DeviceRemovedExtendedData2_GetDeviceState(This) \ - ( (This)->lpVtbl -> GetDeviceState(This) ) -#endif /* COBJMACROS */ +#define ID3D12Heap1_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) -#endif /* C style interface */ +#if !defined(_WIN32) +#define ID3D12Heap1_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) +#else +#define ID3D12Heap1_GetDesc(This,RetVal) \ + ( (This)->lpVtbl -> GetDesc(This,RetVal) ) +#endif +#define ID3D12Heap1_GetProtectedResourceSession(This,riid,ppProtectedSession) \ + ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) -#endif /* __ID3D12DeviceRemovedExtendedData2_INTERFACE_DEFINED__ */ +#endif /* COBJMACROS */ -/* interface __MIDL_itf_d3d12_0000_0041 */ -/* [local] */ +#endif /* C style interface */ -typedef -enum D3D12_BACKGROUND_PROCESSING_MODE - { - D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED = 0, - D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS = ( D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED + 1 ) , - D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK = ( D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS + 1 ) , - D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_PROFILING_BY_SYSTEM = ( D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK + 1 ) - } D3D12_BACKGROUND_PROCESSING_MODE; -typedef -enum D3D12_MEASUREMENTS_ACTION - { - D3D12_MEASUREMENTS_ACTION_KEEP_ALL = 0, - D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS = ( D3D12_MEASUREMENTS_ACTION_KEEP_ALL + 1 ) , - D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY = ( D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS + 1 ) , - D3D12_MEASUREMENTS_ACTION_DISCARD_PREVIOUS = ( D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY + 1 ) - } D3D12_MEASUREMENTS_ACTION; +#endif /* __ID3D12Heap1_INTERFACE_DEFINED__ */ -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0041_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0041_v0_0_s_ifspec; -#ifndef __ID3D12Device6_INTERFACE_DEFINED__ -#define __ID3D12Device6_INTERFACE_DEFINED__ +#ifndef __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__ -/* interface ID3D12Device6 */ +/* interface ID3D12GraphicsCommandList3 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12Device6; +EXTERN_C const IID IID_ID3D12GraphicsCommandList3; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("c70b221b-40e4-4a17-89af-025a0727a6dc") - ID3D12Device6 : public ID3D12Device5 + MIDL_INTERFACE("6FDA83A7-B84C-4E38-9AC8-C7BD22016B3D") + ID3D12GraphicsCommandList3 : public ID3D12GraphicsCommandList2 { public: - virtual HRESULT STDMETHODCALLTYPE SetBackgroundProcessingMode( - D3D12_BACKGROUND_PROCESSING_MODE Mode, - D3D12_MEASUREMENTS_ACTION MeasurementsAction, - _In_opt_ HANDLE hEventToSignalUponCompletion, - _Out_opt_ BOOL *pbFurtherMeasurementsDesired) = 0; + virtual void STDMETHODCALLTYPE SetProtectedResourceSession( + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0; }; #else /* C style interface */ - typedef struct ID3D12Device6Vtbl + typedef struct ID3D12GraphicsCommandList3Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device6 * This, + ID3D12GraphicsCommandList3 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device6 * This); + ID3D12GraphicsCommandList3 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device6 * This); + ID3D12GraphicsCommandList3 * This); DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device6 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device6 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device6 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetName) - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device6 * This, - _In_z_ LPCWSTR Name); - - DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) - UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device6 * This); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device6 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) - HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device6 * This, - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) - HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device6 * This, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); + ID3D12GraphicsCommandList3 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); - DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) - HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device6 * This, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12GraphicsCommandList3 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) - HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device6 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, - REFIID riid, - _COM_Outptr_ void **ppCommandList); + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12GraphicsCommandList3 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); - DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) - HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device6 * This, - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize); + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12GraphicsCommandList3 * This, + _In_z_ LPCWSTR Name); - DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) - HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device6 * This, - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12GraphicsCommandList3 * This, REFIID riid, - _COM_Outptr_ void **ppvHeap); + _COM_Outptr_opt_ void **ppvDevice); - DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) - UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device6 * This, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + DECLSPEC_XFGVIRT(ID3D12CommandList, GetType) + D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( + ID3D12GraphicsCommandList3 * This); - DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) - HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device6 * This, - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, - REFIID riid, - _COM_Outptr_ void **ppvRootSignature); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close) + HRESULT ( STDMETHODCALLTYPE *Close )( + ID3D12GraphicsCommandList3 * This); - DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) - void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device6 * This, - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset) + HRESULT ( STDMETHODCALLTYPE *Reset )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12CommandAllocator *pAllocator, + _In_opt_ ID3D12PipelineState *pInitialState); - DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) - void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device6 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState) + void ( STDMETHODCALLTYPE *ClearState )( + ID3D12GraphicsCommandList3 * This, + _In_opt_ ID3D12PipelineState *pPipelineState); - DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) - void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device6 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced) + void ( STDMETHODCALLTYPE *DrawInstanced )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT VertexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartVertexLocation, + _In_ UINT StartInstanceLocation); - DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) - void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device6 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced) + void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT IndexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartIndexLocation, + _In_ INT BaseVertexLocation, + _In_ UINT StartInstanceLocation); - DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) - void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device6 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch) + void ( STDMETHODCALLTYPE *Dispatch )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ); - DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) - void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device6 * This, - _In_ const D3D12_SAMPLER_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion) + void ( STDMETHODCALLTYPE *CopyBufferRegion )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT64 NumBytes); - DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) - void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device6 * This, - _In_ UINT NumDestDescriptorRanges, - _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, - _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, - _In_ UINT NumSrcDescriptorRanges, - _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, - _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion) + void ( STDMETHODCALLTYPE *CopyTextureRegion )( + ID3D12GraphicsCommandList3 * This, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, + UINT DstX, + UINT DstY, + UINT DstZ, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, + _In_opt_ const D3D12_BOX *pSrcBox); - DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) - void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device6 * This, - _In_ UINT NumDescriptors, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource) + void ( STDMETHODCALLTYPE *CopyResource )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pDstResource, + _In_ ID3D12Resource *pSrcResource); - DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) -#if !defined(_WIN32) - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device6 * This, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles) + void ( STDMETHODCALLTYPE *CopyTiles )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pTiledResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, + _In_ ID3D12Resource *pBuffer, + UINT64 BufferStartOffsetInBytes, + D3D12_TILE_COPY_FLAGS Flags); -#else - D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device6 * This, - D3D12_RESOURCE_ALLOCATION_INFO * RetVal, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource) + void ( STDMETHODCALLTYPE *ResolveSubresource )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_ DXGI_FORMAT Format); -#endif + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology) + void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( + ID3D12GraphicsCommandList3 * This, + _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); - DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) -#if !defined(_WIN32) - D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device6 * This, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports) + void ( STDMETHODCALLTYPE *RSSetViewports )( + ID3D12GraphicsCommandList3 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, + _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); -#else - D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device6 * This, - D3D12_HEAP_PROPERTIES * RetVal, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects) + void ( STDMETHODCALLTYPE *RSSetScissorRects )( + ID3D12GraphicsCommandList3 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, + _In_reads_( NumRects) const D3D12_RECT *pRects); -#endif + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor) + void ( STDMETHODCALLTYPE *OMSetBlendFactor )( + ID3D12GraphicsCommandList3 * This, + _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device6 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef) + void ( STDMETHODCALLTYPE *OMSetStencilRef )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT StencilRef); - DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) - HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device6 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState) + void ( STDMETHODCALLTYPE *SetPipelineState )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12PipelineState *pPipelineState); - DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device6 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier) + void ( STDMETHODCALLTYPE *ResourceBarrier )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT NumBarriers, + _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); - DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device6 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle) + void ( STDMETHODCALLTYPE *ExecuteBundle )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12GraphicsCommandList *pCommandList); - DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) - HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device6 * This, - _In_ ID3D12DeviceChild *pObject, - _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, - DWORD Access, - _In_opt_ LPCWSTR Name, - _Out_ HANDLE *pHandle); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps) + void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT NumDescriptorHeaps, + _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); - DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device6 * This, - _In_ HANDLE NTHandle, - REFIID riid, - _COM_Outptr_opt_ void **ppvObj); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature) + void ( STDMETHODCALLTYPE *SetComputeRootSignature )( + ID3D12GraphicsCommandList3 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); - DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device6 * This, - _In_ LPCWSTR Name, - DWORD Access, - /* [annotation][out] */ - _Out_ HANDLE *pNTHandle); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature) + void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( + ID3D12GraphicsCommandList3 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); - DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) - HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device6 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable) + void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - DECLSPEC_XFGVIRT(ID3D12Device, Evict) - HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device6 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable) + void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) - HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device6 * This, - UINT64 InitialValue, - D3D12_FENCE_FLAGS Flags, - REFIID riid, - _COM_Outptr_ void **ppFence); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant) + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); - DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) - HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device6 * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant) + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); - DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) - void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device6 * This, - _In_ const D3D12_RESOURCE_DESC *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants) + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); - DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) - HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device6 * This, - _In_ const D3D12_QUERY_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants) + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); - DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) - HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device6 * This, - BOOL Enable); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView) + void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) - HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device6 * This, - _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, - _In_opt_ ID3D12RootSignature *pRootSignature, - REFIID riid, - _COM_Outptr_opt_ void **ppvCommandSignature); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView) + void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) - void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device6 * This, - _In_ ID3D12Resource *pTiledResource, - _Out_opt_ UINT *pNumTilesForEntireResource, - _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, - _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, - _Inout_opt_ UINT *pNumSubresourceTilings, - _In_ UINT FirstSubresourceTilingToGet, - _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView) + void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) -#if !defined(_WIN32) - LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device6 * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView) + void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); -#else - LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device6 * This, - LUID * RetVal); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView) + void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); -#endif + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView) + void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) - HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( - ID3D12Device6 * This, - _In_reads_(BlobLength) const void *pLibraryBlob, - SIZE_T BlobLength, - REFIID riid, - _COM_Outptr_ void **ppPipelineLibrary); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer) + void ( STDMETHODCALLTYPE *IASetIndexBuffer )( + ID3D12GraphicsCommandList3 * This, + _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); - DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) - HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( - ID3D12Device6 * This, - _In_reads_(NumFences) ID3D12Fence *const *ppFences, - _In_reads_(NumFences) const UINT64 *pFenceValues, - UINT NumFences, - D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, - HANDLE hEvent); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers) + void ( STDMETHODCALLTYPE *IASetVertexBuffers )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); - DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) - HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( - ID3D12Device6 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets) + void ( STDMETHODCALLTYPE *SOSetTargets )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); - DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) - HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( - ID3D12Device6 * This, - const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets) + void ( STDMETHODCALLTYPE *OMSetRenderTargets )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT NumRenderTargetDescriptors, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, + _In_ BOOL RTsSingleHandleToDescriptorRange, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView) + void ( STDMETHODCALLTYPE *ClearDepthStencilView )( + ID3D12GraphicsCommandList3 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, + _In_ D3D12_CLEAR_FLAGS ClearFlags, + _In_ FLOAT Depth, + _In_ UINT8 Stencil, + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( - ID3D12Device6 * This, - _In_ const void *pAddress, - REFIID riid, - _COM_Outptr_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView) + void ( STDMETHODCALLTYPE *ClearRenderTargetView )( + ID3D12GraphicsCommandList3 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, + _In_ const FLOAT ColorRGBA[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( - ID3D12Device6 * This, - _In_ HANDLE hFileMapping, - REFIID riid, - _COM_Outptr_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint) + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( + ID3D12GraphicsCommandList3 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const UINT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) - HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( - ID3D12Device6 * This, - D3D12_RESIDENCY_FLAGS Flags, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_ ID3D12Fence *pFenceToSignal, - UINT64 FenceValueToSignal); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat) + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( + ID3D12GraphicsCommandList3 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const FLOAT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) - HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( - ID3D12Device6 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ D3D12_COMMAND_LIST_FLAGS flags, - REFIID riid, - _COM_Outptr_ void **ppCommandList); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource) + void ( STDMETHODCALLTYPE *DiscardResource )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DISCARD_REGION *pRegion); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) - HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( - ID3D12Device6 * This, - _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, - _In_ REFIID riid, - _COM_Outptr_ void **ppSession); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery) + void ( STDMETHODCALLTYPE *BeginQuery )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( - ID3D12Device6 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery) + void ( STDMETHODCALLTYPE *EndQuery )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) - HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( - ID3D12Device6 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData) + void ( STDMETHODCALLTYPE *ResolveQueryData )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT StartIndex, + _In_ UINT NumQueries, + _In_ ID3D12Resource *pDestinationBuffer, + _In_ UINT64 AlignedDestinationBufferOffset); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( - ID3D12Device6 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication) + void ( STDMETHODCALLTYPE *SetPredication )( + ID3D12GraphicsCommandList3 * This, + _In_opt_ ID3D12Resource *pBuffer, + _In_ UINT64 AlignedBufferOffset, + _In_ D3D12_PREDICATION_OP Operation); - DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) -#if !defined(_WIN32) - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device6 * This, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker) + void ( STDMETHODCALLTYPE *SetMarker )( + ID3D12GraphicsCommandList3 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); -#else - D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device6 * This, - D3D12_RESOURCE_ALLOCATION_INFO * RetVal, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent) + void ( STDMETHODCALLTYPE *BeginEvent )( + ID3D12GraphicsCommandList3 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); -#endif + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent) + void ( STDMETHODCALLTYPE *EndEvent )( + ID3D12GraphicsCommandList3 * This); - DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) - HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( - ID3D12Device6 * This, - _In_ ID3D12LifetimeOwner *pOwner, - REFIID riid, - _COM_Outptr_ void **ppvTracker); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect) + void ( STDMETHODCALLTYPE *ExecuteIndirect )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12CommandSignature *pCommandSignature, + _In_ UINT MaxCommandCount, + _In_ ID3D12Resource *pArgumentBuffer, + _In_ UINT64 ArgumentBufferOffset, + _In_opt_ ID3D12Resource *pCountBuffer, + _In_ UINT64 CountBufferOffset); - DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) - void ( STDMETHODCALLTYPE *RemoveDevice )( - ID3D12Device6 * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT) + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( - ID3D12Device6 * This, - _Inout_ UINT *pNumMetaCommands, - _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64) + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( - ID3D12Device6 * This, - _In_ REFGUID CommandId, - _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, - _Out_opt_ UINT *pTotalStructureSizeInBytes, - _Inout_ UINT *pParameterCount, - _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds) + void ( STDMETHODCALLTYPE *OMSetDepthBounds )( + ID3D12GraphicsCommandList3 * This, + _In_ FLOAT Min, + _In_ FLOAT Max); - DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) - HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( - ID3D12Device6 * This, - _In_ REFGUID CommandId, - _In_ UINT NodeMask, - _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, - _In_ SIZE_T CreationParametersDataSizeInBytes, - REFIID riid, - _COM_Outptr_ void **ppMetaCommand); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions) + void ( STDMETHODCALLTYPE *SetSamplePositions )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT NumSamplesPerPixel, + _In_ UINT NumPixels, + _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); - DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) - HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( - ID3D12Device6 * This, - const D3D12_STATE_OBJECT_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppStateObject); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion) + void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( + ID3D12GraphicsCommandList3 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ UINT DstX, + _In_ UINT DstY, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_opt_ D3D12_RECT *pSrcRect, + _In_ DXGI_FORMAT Format, + _In_ D3D12_RESOLVE_MODE ResolveMode); - DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) - void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( - ID3D12Device6 * This, - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, - _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask) + void ( STDMETHODCALLTYPE *SetViewInstanceMask )( + ID3D12GraphicsCommandList3 * This, + _In_ UINT Mask); - DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) - D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( - ID3D12Device6 * This, - _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, - _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate) + void ( STDMETHODCALLTYPE *WriteBufferImmediate )( + ID3D12GraphicsCommandList3 * This, + UINT Count, + _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, + _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); - DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) - HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( - ID3D12Device6 * This, - D3D12_BACKGROUND_PROCESSING_MODE Mode, - D3D12_MEASUREMENTS_ACTION MeasurementsAction, - _In_opt_ HANDLE hEventToSignalUponCompletion, - _Out_opt_ BOOL *pbFurtherMeasurementsDesired); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession) + void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( + ID3D12GraphicsCommandList3 * This, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); END_INTERFACE - } ID3D12Device6Vtbl; + } ID3D12GraphicsCommandList3Vtbl; - interface ID3D12Device6 + interface ID3D12GraphicsCommandList3 { - CONST_VTBL struct ID3D12Device6Vtbl *lpVtbl; + CONST_VTBL struct ID3D12GraphicsCommandList3Vtbl *lpVtbl; }; @@ -16226,388 +21422,430 @@ EXTERN_C const IID IID_ID3D12Device6; #ifdef COBJMACROS -#define ID3D12Device6_QueryInterface(This,riid,ppvObject) \ +#define ID3D12GraphicsCommandList3_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12Device6_AddRef(This) \ +#define ID3D12GraphicsCommandList3_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12Device6_Release(This) \ +#define ID3D12GraphicsCommandList3_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Device6_GetPrivateData(This,guid,pDataSize,pData) \ +#define ID3D12GraphicsCommandList3_GetPrivateData(This,guid,pDataSize,pData) \ ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12Device6_SetPrivateData(This,guid,DataSize,pData) \ +#define ID3D12GraphicsCommandList3_SetPrivateData(This,guid,DataSize,pData) \ ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12Device6_SetPrivateDataInterface(This,guid,pData) \ +#define ID3D12GraphicsCommandList3_SetPrivateDataInterface(This,guid,pData) \ ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12Device6_SetName(This,Name) \ +#define ID3D12GraphicsCommandList3_SetName(This,Name) \ ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12Device6_GetNodeCount(This) \ - ( (This)->lpVtbl -> GetNodeCount(This) ) +#define ID3D12GraphicsCommandList3_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) -#define ID3D12Device6_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) -#define ID3D12Device6_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ - ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) +#define ID3D12GraphicsCommandList3_GetType(This) \ + ( (This)->lpVtbl -> GetType(This) ) -#define ID3D12Device6_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12Device6_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) +#define ID3D12GraphicsCommandList3_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) -#define ID3D12Device6_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) +#define ID3D12GraphicsCommandList3_Reset(This,pAllocator,pInitialState) \ + ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) -#define ID3D12Device6_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ - ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) +#define ID3D12GraphicsCommandList3_ClearState(This,pPipelineState) \ + ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) -#define ID3D12Device6_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) +#define ID3D12GraphicsCommandList3_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) -#define ID3D12Device6_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ - ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) +#define ID3D12GraphicsCommandList3_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) -#define ID3D12Device6_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ - ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) +#define ID3D12GraphicsCommandList3_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ + ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) -#define ID3D12Device6_CreateConstantBufferView(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) +#define ID3D12GraphicsCommandList3_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ + ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) -#define ID3D12Device6_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) +#define ID3D12GraphicsCommandList3_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ + ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) -#define ID3D12Device6_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) +#define ID3D12GraphicsCommandList3_CopyResource(This,pDstResource,pSrcResource) \ + ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) -#define ID3D12Device6_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) +#define ID3D12GraphicsCommandList3_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ + ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) -#define ID3D12Device6_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) +#define ID3D12GraphicsCommandList3_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ + ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) -#define ID3D12Device6_CreateSampler(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) +#define ID3D12GraphicsCommandList3_IASetPrimitiveTopology(This,PrimitiveTopology) \ + ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) -#define ID3D12Device6_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) +#define ID3D12GraphicsCommandList3_RSSetViewports(This,NumViewports,pViewports) \ + ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) -#define ID3D12Device6_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) -#if !defined(_WIN32) +#define ID3D12GraphicsCommandList3_RSSetScissorRects(This,NumRects,pRects) \ + ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) -#define ID3D12Device6_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) -#else -#define ID3D12Device6_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) -#endif -#if !defined(_WIN32) +#define ID3D12GraphicsCommandList3_OMSetBlendFactor(This,BlendFactor) \ + ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) -#define ID3D12Device6_GetCustomHeapProperties(This,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) -#else -#define ID3D12Device6_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) -#endif +#define ID3D12GraphicsCommandList3_OMSetStencilRef(This,StencilRef) \ + ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) -#define ID3D12Device6_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) +#define ID3D12GraphicsCommandList3_SetPipelineState(This,pPipelineState) \ + ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) -#define ID3D12Device6_CreateHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) +#define ID3D12GraphicsCommandList3_ResourceBarrier(This,NumBarriers,pBarriers) \ + ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) -#define ID3D12Device6_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12GraphicsCommandList3_ExecuteBundle(This,pCommandList) \ + ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) -#define ID3D12Device6_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12GraphicsCommandList3_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ + ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) -#define ID3D12Device6_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ - ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) +#define ID3D12GraphicsCommandList3_SetComputeRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) -#define ID3D12Device6_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ - ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) +#define ID3D12GraphicsCommandList3_SetGraphicsRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) -#define ID3D12Device6_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ - ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) +#define ID3D12GraphicsCommandList3_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12Device6_MakeResident(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) +#define ID3D12GraphicsCommandList3_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12Device6_Evict(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) +#define ID3D12GraphicsCommandList3_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12Device6_CreateFence(This,InitialValue,Flags,riid,ppFence) \ - ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) +#define ID3D12GraphicsCommandList3_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12Device6_GetDeviceRemovedReason(This) \ - ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) +#define ID3D12GraphicsCommandList3_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) -#define ID3D12Device6_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) +#define ID3D12GraphicsCommandList3_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) -#define ID3D12Device6_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) +#define ID3D12GraphicsCommandList3_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12Device6_SetStablePowerState(This,Enable) \ - ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) +#define ID3D12GraphicsCommandList3_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12Device6_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ - ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) +#define ID3D12GraphicsCommandList3_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12Device6_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ - ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) -#if !defined(_WIN32) +#define ID3D12GraphicsCommandList3_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12Device6_GetAdapterLuid(This) \ - ( (This)->lpVtbl -> GetAdapterLuid(This) ) -#else -#define ID3D12Device6_GetAdapterLuid(This,RetVal) \ - ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) -#endif +#define ID3D12GraphicsCommandList3_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) +#define ID3D12GraphicsCommandList3_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12Device6_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ - ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) +#define ID3D12GraphicsCommandList3_IASetIndexBuffer(This,pView) \ + ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) -#define ID3D12Device6_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ - ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) +#define ID3D12GraphicsCommandList3_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) -#define ID3D12Device6_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ - ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) +#define ID3D12GraphicsCommandList3_SOSetTargets(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) +#define ID3D12GraphicsCommandList3_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ + ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) -#define ID3D12Device6_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) +#define ID3D12GraphicsCommandList3_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) +#define ID3D12GraphicsCommandList3_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) -#define ID3D12Device6_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) +#define ID3D12GraphicsCommandList3_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) -#define ID3D12Device6_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) +#define ID3D12GraphicsCommandList3_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) -#define ID3D12Device6_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ - ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) +#define ID3D12GraphicsCommandList3_DiscardResource(This,pResource,pRegion) \ + ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) + +#define ID3D12GraphicsCommandList3_BeginQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList3_EndQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList3_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ + ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) + +#define ID3D12GraphicsCommandList3_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ + ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) + +#define ID3D12GraphicsCommandList3_SetMarker(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList3_BeginEvent(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList3_EndEvent(This) \ + ( (This)->lpVtbl -> EndEvent(This) ) +#define ID3D12GraphicsCommandList3_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ + ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) + + +#define ID3D12GraphicsCommandList3_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) + +#define ID3D12GraphicsCommandList3_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -#define ID3D12Device6_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) +#define ID3D12GraphicsCommandList3_OMSetDepthBounds(This,Min,Max) \ + ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) -#define ID3D12Device6_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ - ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) +#define ID3D12GraphicsCommandList3_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ + ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) -#define ID3D12Device6_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) +#define ID3D12GraphicsCommandList3_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ + ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) -#define ID3D12Device6_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) +#define ID3D12GraphicsCommandList3_SetViewInstanceMask(This,Mask) \ + ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) -#define ID3D12Device6_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) -#if !defined(_WIN32) -#define ID3D12Device6_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) -#else -#define ID3D12Device6_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) -#endif +#define ID3D12GraphicsCommandList3_WriteBufferImmediate(This,Count,pParams,pModes) \ + ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) -#define ID3D12Device6_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ - ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) +#define ID3D12GraphicsCommandList3_SetProtectedResourceSession(This,pProtectedResourceSession) \ + ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) -#define ID3D12Device6_RemoveDevice(This) \ - ( (This)->lpVtbl -> RemoveDevice(This) ) +#endif /* COBJMACROS */ -#define ID3D12Device6_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) -#define ID3D12Device6_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) +#endif /* C style interface */ -#define ID3D12Device6_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ - ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) -#define ID3D12Device6_CreateStateObject(This,pDesc,riid,ppStateObject) \ - ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) -#define ID3D12Device6_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ - ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) -#define ID3D12Device6_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ - ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) +#endif /* __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__ */ -#define ID3D12Device6_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ - ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) +/* interface __MIDL_itf_d3d12_0000_0054 */ +/* [local] */ -#endif /* COBJMACROS */ +typedef +enum D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE + { + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD = 0, + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD + 1 ) , + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE + 1 ) , + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR + 1 ) , + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE_LOCAL_RENDER = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS + 1 ) , + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE_LOCAL_SRV = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE_LOCAL_RENDER + 1 ) , + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE_LOCAL_UAV = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE_LOCAL_SRV + 1 ) + } D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE; +typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS + { + D3D12_CLEAR_VALUE ClearValue; + } D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS; -#endif /* C style interface */ +typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS_PRESERVE_LOCAL_PARAMETERS + { + UINT AdditionalWidth; + UINT AdditionalHeight; + } D3D12_RENDER_PASS_BEGINNING_ACCESS_PRESERVE_LOCAL_PARAMETERS; +typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS + { + D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE Type; + union + { + D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS Clear; + D3D12_RENDER_PASS_BEGINNING_ACCESS_PRESERVE_LOCAL_PARAMETERS PreserveLocal; + } ; + } D3D12_RENDER_PASS_BEGINNING_ACCESS; +typedef +enum D3D12_RENDER_PASS_ENDING_ACCESS_TYPE + { + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD = 0, + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD + 1 ) , + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE + 1 ) , + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE + 1 ) , + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE_LOCAL_RENDER = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS + 1 ) , + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE_LOCAL_SRV = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE_LOCAL_RENDER + 1 ) , + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE_LOCAL_UAV = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE_LOCAL_SRV + 1 ) + } D3D12_RENDER_PASS_ENDING_ACCESS_TYPE; +typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS + { + UINT SrcSubresource; + UINT DstSubresource; + UINT DstX; + UINT DstY; + D3D12_RECT SrcRect; + } D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS; -#endif /* __ID3D12Device6_INTERFACE_DEFINED__ */ +typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS + { + ID3D12Resource *pSrcResource; + ID3D12Resource *pDstResource; + UINT SubresourceCount; + _Field_size_full_(SubresourceCount) const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS *pSubresourceParameters; + DXGI_FORMAT Format; + D3D12_RESOLVE_MODE ResolveMode; + BOOL PreserveResolveSource; + } D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS; +typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_PRESERVE_LOCAL_PARAMETERS + { + UINT AdditionalWidth; + UINT AdditionalHeight; + } D3D12_RENDER_PASS_ENDING_ACCESS_PRESERVE_LOCAL_PARAMETERS; -/* interface __MIDL_itf_d3d12_0000_0042 */ -/* [local] */ +typedef struct D3D12_RENDER_PASS_ENDING_ACCESS + { + D3D12_RENDER_PASS_ENDING_ACCESS_TYPE Type; + union + { + D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS Resolve; + D3D12_RENDER_PASS_ENDING_ACCESS_PRESERVE_LOCAL_PARAMETERS PreserveLocal; + } ; + } D3D12_RENDER_PASS_ENDING_ACCESS; -DEFINE_GUID(D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED, 0x62B0084E, 0xC70E, 0x4DAA, 0xA1, 0x09, 0x30, 0xFF, 0x8D, 0x5A, 0x04, 0x82); -typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT +typedef struct D3D12_RENDER_PASS_RENDER_TARGET_DESC { - UINT NodeIndex; - UINT Count; - } D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT; + D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor; + D3D12_RENDER_PASS_BEGINNING_ACCESS BeginningAccess; + D3D12_RENDER_PASS_ENDING_ACCESS EndingAccess; + } D3D12_RENDER_PASS_RENDER_TARGET_DESC; -typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES +typedef struct D3D12_RENDER_PASS_DEPTH_STENCIL_DESC { - UINT NodeIndex; - UINT Count; - GUID *pTypes; - } D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES; + D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor; + D3D12_RENDER_PASS_BEGINNING_ACCESS DepthBeginningAccess; + D3D12_RENDER_PASS_BEGINNING_ACCESS StencilBeginningAccess; + D3D12_RENDER_PASS_ENDING_ACCESS DepthEndingAccess; + D3D12_RENDER_PASS_ENDING_ACCESS StencilEndingAccess; + } D3D12_RENDER_PASS_DEPTH_STENCIL_DESC; -typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC1 +typedef +enum D3D12_RENDER_PASS_FLAGS { - UINT NodeMask; - D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags; - GUID ProtectionType; - } D3D12_PROTECTED_RESOURCE_SESSION_DESC1; + D3D12_RENDER_PASS_FLAG_NONE = 0, + D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES = 0x1, + D3D12_RENDER_PASS_FLAG_SUSPENDING_PASS = 0x2, + D3D12_RENDER_PASS_FLAG_RESUMING_PASS = 0x4, + D3D12_RENDER_PASS_FLAG_BIND_READ_ONLY_DEPTH = 0x8, + D3D12_RENDER_PASS_FLAG_BIND_READ_ONLY_STENCIL = 0x10 + } D3D12_RENDER_PASS_FLAGS; +DEFINE_ENUM_FLAG_OPERATORS( D3D12_RENDER_PASS_FLAGS ) -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0042_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0042_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0054_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0054_v0_0_s_ifspec; -#ifndef __ID3D12ProtectedResourceSession1_INTERFACE_DEFINED__ -#define __ID3D12ProtectedResourceSession1_INTERFACE_DEFINED__ +#ifndef __ID3D12MetaCommand_INTERFACE_DEFINED__ +#define __ID3D12MetaCommand_INTERFACE_DEFINED__ -/* interface ID3D12ProtectedResourceSession1 */ +/* interface ID3D12MetaCommand */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12ProtectedResourceSession1; +EXTERN_C const IID IID_ID3D12MetaCommand; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("D6F12DD6-76FB-406E-8961-4296EEFC0409") - ID3D12ProtectedResourceSession1 : public ID3D12ProtectedResourceSession + MIDL_INTERFACE("DBB84C27-36CE-4FC9-B801-F048C46AC570") + ID3D12MetaCommand : public ID3D12Pageable { public: -#if defined(_MSC_VER) - virtual D3D12_PROTECTED_RESOURCE_SESSION_DESC1 STDMETHODCALLTYPE GetDesc1( void) = 0; -#else - virtual D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *STDMETHODCALLTYPE GetDesc1( - D3D12_PROTECTED_RESOURCE_SESSION_DESC1 * RetVal) = 0; -#endif + virtual UINT64 STDMETHODCALLTYPE GetRequiredParameterResourceSize( + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _In_ UINT ParameterIndex) = 0; }; #else /* C style interface */ - typedef struct ID3D12ProtectedResourceSession1Vtbl + typedef struct ID3D12MetaCommandVtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12ProtectedResourceSession1 * This, + ID3D12MetaCommand * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12ProtectedResourceSession1 * This); + ID3D12MetaCommand * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12ProtectedResourceSession1 * This); + ID3D12MetaCommand * This); DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12ProtectedResourceSession1 * This, + ID3D12MetaCommand * This, _In_ REFGUID guid, _Inout_ UINT *pDataSize, _Out_writes_bytes_opt_( *pDataSize ) void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12ProtectedResourceSession1 * This, + ID3D12MetaCommand * This, _In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_( DataSize ) const void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12ProtectedResourceSession1 * This, + ID3D12MetaCommand * This, _In_ REFGUID guid, _In_opt_ const IUnknown *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetName) HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12ProtectedResourceSession1 * This, + ID3D12MetaCommand * This, _In_z_ LPCWSTR Name); DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12ProtectedResourceSession1 * This, + ID3D12MetaCommand * This, REFIID riid, _COM_Outptr_opt_ void **ppvDevice); - DECLSPEC_XFGVIRT(ID3D12ProtectedSession, GetStatusFence) - HRESULT ( STDMETHODCALLTYPE *GetStatusFence )( - ID3D12ProtectedResourceSession1 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppFence); - - DECLSPEC_XFGVIRT(ID3D12ProtectedSession, GetSessionStatus) - D3D12_PROTECTED_SESSION_STATUS ( STDMETHODCALLTYPE *GetSessionStatus )( - ID3D12ProtectedResourceSession1 * This); - - DECLSPEC_XFGVIRT(ID3D12ProtectedResourceSession, GetDesc) -#if !defined(_WIN32) - D3D12_PROTECTED_RESOURCE_SESSION_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12ProtectedResourceSession1 * This); - -#else - D3D12_PROTECTED_RESOURCE_SESSION_DESC *( STDMETHODCALLTYPE *GetDesc )( - ID3D12ProtectedResourceSession1 * This, - D3D12_PROTECTED_RESOURCE_SESSION_DESC * RetVal); - -#endif - - DECLSPEC_XFGVIRT(ID3D12ProtectedResourceSession1, GetDesc1) -#if !defined(_WIN32) - D3D12_PROTECTED_RESOURCE_SESSION_DESC1 ( STDMETHODCALLTYPE *GetDesc1 )( - ID3D12ProtectedResourceSession1 * This); - -#else - D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *( STDMETHODCALLTYPE *GetDesc1 )( - ID3D12ProtectedResourceSession1 * This, - D3D12_PROTECTED_RESOURCE_SESSION_DESC1 * RetVal); - -#endif + DECLSPEC_XFGVIRT(ID3D12MetaCommand, GetRequiredParameterResourceSize) + UINT64 ( STDMETHODCALLTYPE *GetRequiredParameterResourceSize )( + ID3D12MetaCommand * This, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _In_ UINT ParameterIndex); END_INTERFACE - } ID3D12ProtectedResourceSession1Vtbl; + } ID3D12MetaCommandVtbl; - interface ID3D12ProtectedResourceSession1 + interface ID3D12MetaCommand { - CONST_VTBL struct ID3D12ProtectedResourceSession1Vtbl *lpVtbl; + CONST_VTBL struct ID3D12MetaCommandVtbl *lpVtbl; }; @@ -16615,1049 +21853,1551 @@ EXTERN_C const IID IID_ID3D12ProtectedResourceSession1; #ifdef COBJMACROS -#define ID3D12ProtectedResourceSession1_QueryInterface(This,riid,ppvObject) \ +#define ID3D12MetaCommand_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12ProtectedResourceSession1_AddRef(This) \ +#define ID3D12MetaCommand_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12ProtectedResourceSession1_Release(This) \ +#define ID3D12MetaCommand_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12ProtectedResourceSession1_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) +#define ID3D12MetaCommand_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12MetaCommand_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12MetaCommand_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12MetaCommand_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12MetaCommand_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12MetaCommand_GetRequiredParameterResourceSize(This,Stage,ParameterIndex) \ + ( (This)->lpVtbl -> GetRequiredParameterResourceSize(This,Stage,ParameterIndex) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + -#define ID3D12ProtectedResourceSession1_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12ProtectedResourceSession1_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12ProtectedResourceSession1_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) +#endif /* __ID3D12MetaCommand_INTERFACE_DEFINED__ */ -#define ID3D12ProtectedResourceSession1_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) +/* interface __MIDL_itf_d3d12_0000_0055 */ +/* [local] */ +typedef struct D3D12_DISPATCH_RAYS_DESC + { + D3D12_GPU_VIRTUAL_ADDRESS_RANGE RayGenerationShaderRecord; + D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE MissShaderTable; + D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE HitGroupTable; + D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE CallableShaderTable; + UINT Width; + UINT Height; + UINT Depth; + } D3D12_DISPATCH_RAYS_DESC; -#define ID3D12ProtectedResourceSession1_GetStatusFence(This,riid,ppFence) \ - ( (This)->lpVtbl -> GetStatusFence(This,riid,ppFence) ) +typedef +enum D3D12_SET_WORK_GRAPH_FLAGS + { + D3D12_SET_WORK_GRAPH_FLAG_NONE = 0, + D3D12_SET_WORK_GRAPH_FLAG_INITIALIZE = 0x1 + } D3D12_SET_WORK_GRAPH_FLAGS; -#define ID3D12ProtectedResourceSession1_GetSessionStatus(This) \ - ( (This)->lpVtbl -> GetSessionStatus(This) ) +DEFINE_ENUM_FLAG_OPERATORS( D3D12_SET_WORK_GRAPH_FLAGS ) +typedef struct D3D12_SET_WORK_GRAPH_DESC + { + D3D12_PROGRAM_IDENTIFIER ProgramIdentifier; + D3D12_SET_WORK_GRAPH_FLAGS Flags; + D3D12_GPU_VIRTUAL_ADDRESS_RANGE BackingMemory; + D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE NodeLocalRootArgumentsTable; + } D3D12_SET_WORK_GRAPH_DESC; -#if !defined(_WIN32) +typedef struct D3D12_SET_RAYTRACING_PIPELINE_DESC + { + D3D12_PROGRAM_IDENTIFIER ProgramIdentifier; + } D3D12_SET_RAYTRACING_PIPELINE_DESC; -#define ID3D12ProtectedResourceSession1_GetDesc(This) \ - ( (This)->lpVtbl -> GetDesc(This) ) -#else -#define ID3D12ProtectedResourceSession1_GetDesc(This,RetVal) \ - ( (This)->lpVtbl -> GetDesc(This,RetVal) ) -#endif +typedef struct D3D12_SET_GENERIC_PIPELINE_DESC + { + D3D12_PROGRAM_IDENTIFIER ProgramIdentifier; + } D3D12_SET_GENERIC_PIPELINE_DESC; -#if !defined(_WIN32) +typedef +enum D3D12_PROGRAM_TYPE + { + D3D12_PROGRAM_TYPE_GENERIC_PIPELINE = 1, + D3D12_PROGRAM_TYPE_RAYTRACING_PIPELINE = 4, + D3D12_PROGRAM_TYPE_WORK_GRAPH = 5 + } D3D12_PROGRAM_TYPE; -#define ID3D12ProtectedResourceSession1_GetDesc1(This) \ - ( (This)->lpVtbl -> GetDesc1(This) ) -#else -#define ID3D12ProtectedResourceSession1_GetDesc1(This,RetVal) \ - ( (This)->lpVtbl -> GetDesc1(This,RetVal) ) -#endif +typedef struct D3D12_SET_PROGRAM_DESC + { + D3D12_PROGRAM_TYPE Type; + union + { + D3D12_SET_GENERIC_PIPELINE_DESC GenericPipeline; + D3D12_SET_RAYTRACING_PIPELINE_DESC RaytracingPipeline; + D3D12_SET_WORK_GRAPH_DESC WorkGraph; + } ; + } D3D12_SET_PROGRAM_DESC; -#endif /* COBJMACROS */ +typedef +enum D3D12_DISPATCH_MODE + { + D3D12_DISPATCH_MODE_NODE_CPU_INPUT = 0, + D3D12_DISPATCH_MODE_NODE_GPU_INPUT = 1, + D3D12_DISPATCH_MODE_MULTI_NODE_CPU_INPUT = 2, + D3D12_DISPATCH_MODE_MULTI_NODE_GPU_INPUT = 3 + } D3D12_DISPATCH_MODE; + +typedef struct D3D12_NODE_CPU_INPUT + { + UINT EntrypointIndex; + UINT NumRecords; + const void *pRecords; + UINT64 RecordStrideInBytes; + } D3D12_NODE_CPU_INPUT; +typedef struct D3D12_NODE_GPU_INPUT + { + UINT EntrypointIndex; + UINT NumRecords; + D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE Records; + } D3D12_NODE_GPU_INPUT; -#endif /* C style interface */ +typedef struct D3D12_MULTI_NODE_CPU_INPUT + { + UINT NumNodeInputs; + const D3D12_NODE_CPU_INPUT *pNodeInputs; + UINT64 NodeInputStrideInBytes; + } D3D12_MULTI_NODE_CPU_INPUT; +typedef struct D3D12_MULTI_NODE_GPU_INPUT + { + UINT NumNodeInputs; + D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE NodeInputs; + } D3D12_MULTI_NODE_GPU_INPUT; +typedef struct D3D12_DISPATCH_GRAPH_DESC + { + D3D12_DISPATCH_MODE Mode; + union + { + D3D12_NODE_CPU_INPUT NodeCPUInput; + D3D12_GPU_VIRTUAL_ADDRESS NodeGPUInput; + D3D12_MULTI_NODE_CPU_INPUT MultiNodeCPUInput; + D3D12_GPU_VIRTUAL_ADDRESS MultiNodeGPUInput; + } ; + } D3D12_DISPATCH_GRAPH_DESC; -#endif /* __ID3D12ProtectedResourceSession1_INTERFACE_DEFINED__ */ +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0055_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0055_v0_0_s_ifspec; -#ifndef __ID3D12Device7_INTERFACE_DEFINED__ -#define __ID3D12Device7_INTERFACE_DEFINED__ +#ifndef __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__ -/* interface ID3D12Device7 */ +/* interface ID3D12GraphicsCommandList4 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12Device7; +EXTERN_C const IID IID_ID3D12GraphicsCommandList4; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("5c014b53-68a1-4b9b-8bd1-dd6046b9358b") - ID3D12Device7 : public ID3D12Device6 + MIDL_INTERFACE("8754318e-d3a9-4541-98cf-645b50dc4874") + ID3D12GraphicsCommandList4 : public ID3D12GraphicsCommandList3 { public: - virtual HRESULT STDMETHODCALLTYPE AddToStateObject( - const D3D12_STATE_OBJECT_DESC *pAddition, - ID3D12StateObject *pStateObjectToGrowFrom, - REFIID riid, - _COM_Outptr_ void **ppNewStateObject) = 0; + virtual void STDMETHODCALLTYPE BeginRenderPass( + _In_ UINT NumRenderTargets, + _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, + _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, + D3D12_RENDER_PASS_FLAGS Flags) = 0; - virtual HRESULT STDMETHODCALLTYPE CreateProtectedResourceSession1( - _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, - _In_ REFIID riid, - _COM_Outptr_ void **ppSession) = 0; + virtual void STDMETHODCALLTYPE EndRenderPass( void) = 0; + + virtual void STDMETHODCALLTYPE InitializeMetaCommand( + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, + _In_ SIZE_T InitializationParametersDataSizeInBytes) = 0; + + virtual void STDMETHODCALLTYPE ExecuteMetaCommand( + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, + _In_ SIZE_T ExecutionParametersDataSizeInBytes) = 0; + + virtual void STDMETHODCALLTYPE BuildRaytracingAccelerationStructure( + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, + _In_ UINT NumPostbuildInfoDescs, + _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs) = 0; + + virtual void STDMETHODCALLTYPE EmitRaytracingAccelerationStructurePostbuildInfo( + _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, + _In_ UINT NumSourceAccelerationStructures, + _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData) = 0; + + virtual void STDMETHODCALLTYPE CopyRaytracingAccelerationStructure( + _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, + _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, + _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode) = 0; + + virtual void STDMETHODCALLTYPE SetPipelineState1( + _In_ ID3D12StateObject *pStateObject) = 0; + + virtual void STDMETHODCALLTYPE DispatchRays( + _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc) = 0; }; #else /* C style interface */ - typedef struct ID3D12Device7Vtbl + typedef struct ID3D12GraphicsCommandList4Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device7 * This, + ID3D12GraphicsCommandList4 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device7 * This); + ID3D12GraphicsCommandList4 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device7 * This); + ID3D12GraphicsCommandList4 * This); DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device7 * This, + ID3D12GraphicsCommandList4 * This, _In_ REFGUID guid, _Inout_ UINT *pDataSize, _Out_writes_bytes_opt_( *pDataSize ) void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device7 * This, + ID3D12GraphicsCommandList4 * This, _In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_( DataSize ) const void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device7 * This, + ID3D12GraphicsCommandList4 * This, _In_ REFGUID guid, _In_opt_ const IUnknown *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetName) HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device7 * This, + ID3D12GraphicsCommandList4 * This, _In_z_ LPCWSTR Name); - DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) - UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device7 * This); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device7 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12GraphicsCommandList4 * This, REFIID riid, - _COM_Outptr_ void **ppCommandQueue); + _COM_Outptr_opt_ void **ppvDevice); - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) - HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device7 * This, - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator); + DECLSPEC_XFGVIRT(ID3D12CommandList, GetType) + D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( + ID3D12GraphicsCommandList4 * This); - DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) - HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device7 * This, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close) + HRESULT ( STDMETHODCALLTYPE *Close )( + ID3D12GraphicsCommandList4 * This); - DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) - HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device7 * This, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset) + HRESULT ( STDMETHODCALLTYPE *Reset )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12CommandAllocator *pAllocator, + _In_opt_ ID3D12PipelineState *pInitialState); - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) - HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device7 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, - REFIID riid, - _COM_Outptr_ void **ppCommandList); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState) + void ( STDMETHODCALLTYPE *ClearState )( + ID3D12GraphicsCommandList4 * This, + _In_opt_ ID3D12PipelineState *pPipelineState); - DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) - HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device7 * This, - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced) + void ( STDMETHODCALLTYPE *DrawInstanced )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT VertexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartVertexLocation, + _In_ UINT StartInstanceLocation); - DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) - HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device7 * This, - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, - REFIID riid, - _COM_Outptr_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced) + void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT IndexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartIndexLocation, + _In_ INT BaseVertexLocation, + _In_ UINT StartInstanceLocation); - DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) - UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device7 * This, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch) + void ( STDMETHODCALLTYPE *Dispatch )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ); - DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) - HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device7 * This, - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, - REFIID riid, - _COM_Outptr_ void **ppvRootSignature); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion) + void ( STDMETHODCALLTYPE *CopyBufferRegion )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT64 NumBytes); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion) + void ( STDMETHODCALLTYPE *CopyTextureRegion )( + ID3D12GraphicsCommandList4 * This, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, + UINT DstX, + UINT DstY, + UINT DstZ, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, + _In_opt_ const D3D12_BOX *pSrcBox); - DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) - void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device7 * This, - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource) + void ( STDMETHODCALLTYPE *CopyResource )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pDstResource, + _In_ ID3D12Resource *pSrcResource); - DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) - void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device7 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles) + void ( STDMETHODCALLTYPE *CopyTiles )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pTiledResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, + _In_ ID3D12Resource *pBuffer, + UINT64 BufferStartOffsetInBytes, + D3D12_TILE_COPY_FLAGS Flags); - DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) - void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device7 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource) + void ( STDMETHODCALLTYPE *ResolveSubresource )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_ DXGI_FORMAT Format); - DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) - void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device7 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology) + void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( + ID3D12GraphicsCommandList4 * This, + _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); - DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) - void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device7 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports) + void ( STDMETHODCALLTYPE *RSSetViewports )( + ID3D12GraphicsCommandList4 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, + _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); - DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) - void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device7 * This, - _In_ const D3D12_SAMPLER_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects) + void ( STDMETHODCALLTYPE *RSSetScissorRects )( + ID3D12GraphicsCommandList4 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, + _In_reads_( NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) - void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device7 * This, - _In_ UINT NumDestDescriptorRanges, - _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, - _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, - _In_ UINT NumSrcDescriptorRanges, - _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, - _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor) + void ( STDMETHODCALLTYPE *OMSetBlendFactor )( + ID3D12GraphicsCommandList4 * This, + _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); - DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) - void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device7 * This, - _In_ UINT NumDescriptors, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef) + void ( STDMETHODCALLTYPE *OMSetStencilRef )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT StencilRef); - DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) -#if !defined(_WIN32) - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device7 * This, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState) + void ( STDMETHODCALLTYPE *SetPipelineState )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12PipelineState *pPipelineState); -#else - D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device7 * This, - D3D12_RESOURCE_ALLOCATION_INFO * RetVal, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier) + void ( STDMETHODCALLTYPE *ResourceBarrier )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT NumBarriers, + _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); -#endif + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle) + void ( STDMETHODCALLTYPE *ExecuteBundle )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12GraphicsCommandList *pCommandList); - DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) -#if !defined(_WIN32) - D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device7 * This, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps) + void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT NumDescriptorHeaps, + _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); -#else - D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device7 * This, - D3D12_HEAP_PROPERTIES * RetVal, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature) + void ( STDMETHODCALLTYPE *SetComputeRootSignature )( + ID3D12GraphicsCommandList4 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); -#endif + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature) + void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( + ID3D12GraphicsCommandList4 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device7 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable) + void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) - HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device7 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable) + void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device7 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant) + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); - DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device7 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant) + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); - DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) - HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device7 * This, - _In_ ID3D12DeviceChild *pObject, - _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, - DWORD Access, - _In_opt_ LPCWSTR Name, - _Out_ HANDLE *pHandle); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants) + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); - DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device7 * This, - _In_ HANDLE NTHandle, - REFIID riid, - _COM_Outptr_opt_ void **ppvObj); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants) + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); - DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device7 * This, - _In_ LPCWSTR Name, - DWORD Access, - /* [annotation][out] */ - _Out_ HANDLE *pNTHandle); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView) + void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) - HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device7 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView) + void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device, Evict) - HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device7 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView) + void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) - HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device7 * This, - UINT64 InitialValue, - D3D12_FENCE_FLAGS Flags, - REFIID riid, - _COM_Outptr_ void **ppFence); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView) + void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) - HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device7 * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView) + void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) - void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device7 * This, - _In_ const D3D12_RESOURCE_DESC *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView) + void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) - HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device7 * This, - _In_ const D3D12_QUERY_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer) + void ( STDMETHODCALLTYPE *IASetIndexBuffer )( + ID3D12GraphicsCommandList4 * This, + _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); - DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) - HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device7 * This, - BOOL Enable); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers) + void ( STDMETHODCALLTYPE *IASetVertexBuffers )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) - HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device7 * This, - _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, - _In_opt_ ID3D12RootSignature *pRootSignature, - REFIID riid, - _COM_Outptr_opt_ void **ppvCommandSignature); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets) + void ( STDMETHODCALLTYPE *SOSetTargets )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); - DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) - void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device7 * This, - _In_ ID3D12Resource *pTiledResource, - _Out_opt_ UINT *pNumTilesForEntireResource, - _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, - _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, - _Inout_opt_ UINT *pNumSubresourceTilings, - _In_ UINT FirstSubresourceTilingToGet, - _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets) + void ( STDMETHODCALLTYPE *OMSetRenderTargets )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT NumRenderTargetDescriptors, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, + _In_ BOOL RTsSingleHandleToDescriptorRange, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); - DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) -#if !defined(_WIN32) - LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device7 * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView) + void ( STDMETHODCALLTYPE *ClearDepthStencilView )( + ID3D12GraphicsCommandList4 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, + _In_ D3D12_CLEAR_FLAGS ClearFlags, + _In_ FLOAT Depth, + _In_ UINT8 Stencil, + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); -#else - LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device7 * This, - LUID * RetVal); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView) + void ( STDMETHODCALLTYPE *ClearRenderTargetView )( + ID3D12GraphicsCommandList4 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, + _In_ const FLOAT ColorRGBA[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); -#endif + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint) + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( + ID3D12GraphicsCommandList4 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const UINT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) - HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( - ID3D12Device7 * This, - _In_reads_(BlobLength) const void *pLibraryBlob, - SIZE_T BlobLength, - REFIID riid, - _COM_Outptr_ void **ppPipelineLibrary); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat) + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( + ID3D12GraphicsCommandList4 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const FLOAT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) - HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( - ID3D12Device7 * This, - _In_reads_(NumFences) ID3D12Fence *const *ppFences, - _In_reads_(NumFences) const UINT64 *pFenceValues, - UINT NumFences, - D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, - HANDLE hEvent); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource) + void ( STDMETHODCALLTYPE *DiscardResource )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DISCARD_REGION *pRegion); - DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) - HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( - ID3D12Device7 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery) + void ( STDMETHODCALLTYPE *BeginQuery )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); - DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) - HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( - ID3D12Device7 * This, - const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery) + void ( STDMETHODCALLTYPE *EndQuery )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); - DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( - ID3D12Device7 * This, - _In_ const void *pAddress, - REFIID riid, - _COM_Outptr_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData) + void ( STDMETHODCALLTYPE *ResolveQueryData )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT StartIndex, + _In_ UINT NumQueries, + _In_ ID3D12Resource *pDestinationBuffer, + _In_ UINT64 AlignedDestinationBufferOffset); - DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( - ID3D12Device7 * This, - _In_ HANDLE hFileMapping, - REFIID riid, - _COM_Outptr_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication) + void ( STDMETHODCALLTYPE *SetPredication )( + ID3D12GraphicsCommandList4 * This, + _In_opt_ ID3D12Resource *pBuffer, + _In_ UINT64 AlignedBufferOffset, + _In_ D3D12_PREDICATION_OP Operation); - DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) - HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( - ID3D12Device7 * This, - D3D12_RESIDENCY_FLAGS Flags, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_ ID3D12Fence *pFenceToSignal, - UINT64 FenceValueToSignal); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker) + void ( STDMETHODCALLTYPE *SetMarker )( + ID3D12GraphicsCommandList4 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) - HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( - ID3D12Device7 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ D3D12_COMMAND_LIST_FLAGS flags, - REFIID riid, - _COM_Outptr_ void **ppCommandList); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent) + void ( STDMETHODCALLTYPE *BeginEvent )( + ID3D12GraphicsCommandList4 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) - HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( - ID3D12Device7 * This, - _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, - _In_ REFIID riid, - _COM_Outptr_ void **ppSession); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent) + void ( STDMETHODCALLTYPE *EndEvent )( + ID3D12GraphicsCommandList4 * This); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect) + void ( STDMETHODCALLTYPE *ExecuteIndirect )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12CommandSignature *pCommandSignature, + _In_ UINT MaxCommandCount, + _In_ ID3D12Resource *pArgumentBuffer, + _In_ UINT64 ArgumentBufferOffset, + _In_opt_ ID3D12Resource *pCountBuffer, + _In_ UINT64 CountBufferOffset); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( - ID3D12Device7 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT) + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) - HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( - ID3D12Device7 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64) + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( - ID3D12Device7 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds) + void ( STDMETHODCALLTYPE *OMSetDepthBounds )( + ID3D12GraphicsCommandList4 * This, + _In_ FLOAT Min, + _In_ FLOAT Max); - DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) -#if !defined(_WIN32) - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device7 * This, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions) + void ( STDMETHODCALLTYPE *SetSamplePositions )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT NumSamplesPerPixel, + _In_ UINT NumPixels, + _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); -#else - D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device7 * This, - D3D12_RESOURCE_ALLOCATION_INFO * RetVal, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion) + void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ UINT DstX, + _In_ UINT DstY, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_opt_ D3D12_RECT *pSrcRect, + _In_ DXGI_FORMAT Format, + _In_ D3D12_RESOLVE_MODE ResolveMode); -#endif + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask) + void ( STDMETHODCALLTYPE *SetViewInstanceMask )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT Mask); - DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) - HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( - ID3D12Device7 * This, - _In_ ID3D12LifetimeOwner *pOwner, - REFIID riid, - _COM_Outptr_ void **ppvTracker); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate) + void ( STDMETHODCALLTYPE *WriteBufferImmediate )( + ID3D12GraphicsCommandList4 * This, + UINT Count, + _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, + _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); - DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) - void ( STDMETHODCALLTYPE *RemoveDevice )( - ID3D12Device7 * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession) + void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( + ID3D12GraphicsCommandList4 * This, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); - DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( - ID3D12Device7 * This, - _Inout_ UINT *pNumMetaCommands, - _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BeginRenderPass) + void ( STDMETHODCALLTYPE *BeginRenderPass )( + ID3D12GraphicsCommandList4 * This, + _In_ UINT NumRenderTargets, + _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, + _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, + D3D12_RENDER_PASS_FLAGS Flags); - DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( - ID3D12Device7 * This, - _In_ REFGUID CommandId, - _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, - _Out_opt_ UINT *pTotalStructureSizeInBytes, - _Inout_ UINT *pParameterCount, - _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EndRenderPass) + void ( STDMETHODCALLTYPE *EndRenderPass )( + ID3D12GraphicsCommandList4 * This); - DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) - HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( - ID3D12Device7 * This, - _In_ REFGUID CommandId, - _In_ UINT NodeMask, - _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, - _In_ SIZE_T CreationParametersDataSizeInBytes, - REFIID riid, - _COM_Outptr_ void **ppMetaCommand); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, InitializeMetaCommand) + void ( STDMETHODCALLTYPE *InitializeMetaCommand )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, + _In_ SIZE_T InitializationParametersDataSizeInBytes); - DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) - HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( - ID3D12Device7 * This, - const D3D12_STATE_OBJECT_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppStateObject); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, ExecuteMetaCommand) + void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, + _In_ SIZE_T ExecutionParametersDataSizeInBytes); - DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) - void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( - ID3D12Device7 * This, - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, - _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BuildRaytracingAccelerationStructure) + void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( + ID3D12GraphicsCommandList4 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, + _In_ UINT NumPostbuildInfoDescs, + _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs); - DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) - D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( - ID3D12Device7 * This, - _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, - _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EmitRaytracingAccelerationStructurePostbuildInfo) + void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( + ID3D12GraphicsCommandList4 * This, + _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, + _In_ UINT NumSourceAccelerationStructures, + _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData); - DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) - HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( - ID3D12Device7 * This, - D3D12_BACKGROUND_PROCESSING_MODE Mode, - D3D12_MEASUREMENTS_ACTION MeasurementsAction, - _In_opt_ HANDLE hEventToSignalUponCompletion, - _Out_opt_ BOOL *pbFurtherMeasurementsDesired); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, CopyRaytracingAccelerationStructure) + void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( + ID3D12GraphicsCommandList4 * This, + _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, + _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, + _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode); - DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject) - HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( - ID3D12Device7 * This, - const D3D12_STATE_OBJECT_DESC *pAddition, - ID3D12StateObject *pStateObjectToGrowFrom, - REFIID riid, - _COM_Outptr_ void **ppNewStateObject); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, SetPipelineState1) + void ( STDMETHODCALLTYPE *SetPipelineState1 )( + ID3D12GraphicsCommandList4 * This, + _In_ ID3D12StateObject *pStateObject); - DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1) - HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( - ID3D12Device7 * This, - _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, - _In_ REFIID riid, - _COM_Outptr_ void **ppSession); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, DispatchRays) + void ( STDMETHODCALLTYPE *DispatchRays )( + ID3D12GraphicsCommandList4 * This, + _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc); END_INTERFACE - } ID3D12Device7Vtbl; + } ID3D12GraphicsCommandList4Vtbl; + + interface ID3D12GraphicsCommandList4 + { + CONST_VTBL struct ID3D12GraphicsCommandList4Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12GraphicsCommandList4_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12GraphicsCommandList4_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12GraphicsCommandList4_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12GraphicsCommandList4_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12GraphicsCommandList4_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12GraphicsCommandList4_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12GraphicsCommandList4_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12GraphicsCommandList4_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - interface ID3D12Device7 - { - CONST_VTBL struct ID3D12Device7Vtbl *lpVtbl; - }; - +#define ID3D12GraphicsCommandList4_GetType(This) \ + ( (This)->lpVtbl -> GetType(This) ) -#ifdef COBJMACROS +#define ID3D12GraphicsCommandList4_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) -#define ID3D12Device7_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) +#define ID3D12GraphicsCommandList4_Reset(This,pAllocator,pInitialState) \ + ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) -#define ID3D12Device7_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) +#define ID3D12GraphicsCommandList4_ClearState(This,pPipelineState) \ + ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) -#define ID3D12Device7_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) +#define ID3D12GraphicsCommandList4_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) +#define ID3D12GraphicsCommandList4_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) -#define ID3D12Device7_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) +#define ID3D12GraphicsCommandList4_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ + ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) -#define ID3D12Device7_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) +#define ID3D12GraphicsCommandList4_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ + ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) -#define ID3D12Device7_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) +#define ID3D12GraphicsCommandList4_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ + ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) -#define ID3D12Device7_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) +#define ID3D12GraphicsCommandList4_CopyResource(This,pDstResource,pSrcResource) \ + ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) +#define ID3D12GraphicsCommandList4_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ + ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) -#define ID3D12Device7_GetNodeCount(This) \ - ( (This)->lpVtbl -> GetNodeCount(This) ) +#define ID3D12GraphicsCommandList4_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ + ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) + +#define ID3D12GraphicsCommandList4_IASetPrimitiveTopology(This,PrimitiveTopology) \ + ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) + +#define ID3D12GraphicsCommandList4_RSSetViewports(This,NumViewports,pViewports) \ + ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) + +#define ID3D12GraphicsCommandList4_RSSetScissorRects(This,NumRects,pRects) \ + ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList4_OMSetBlendFactor(This,BlendFactor) \ + ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) + +#define ID3D12GraphicsCommandList4_OMSetStencilRef(This,StencilRef) \ + ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) + +#define ID3D12GraphicsCommandList4_SetPipelineState(This,pPipelineState) \ + ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) + +#define ID3D12GraphicsCommandList4_ResourceBarrier(This,NumBarriers,pBarriers) \ + ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) + +#define ID3D12GraphicsCommandList4_ExecuteBundle(This,pCommandList) \ + ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) + +#define ID3D12GraphicsCommandList4_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ + ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) + +#define ID3D12GraphicsCommandList4_SetComputeRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList4_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) + +#define ID3D12GraphicsCommandList4_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList4_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList4_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList4_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList4_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList4_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList4_IASetIndexBuffer(This,pView) \ + ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) + +#define ID3D12GraphicsCommandList4_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList4_SOSetTargets(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) + +#define ID3D12GraphicsCommandList4_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ + ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) + +#define ID3D12GraphicsCommandList4_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList4_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList4_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList4_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) + +#define ID3D12GraphicsCommandList4_DiscardResource(This,pResource,pRegion) \ + ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) + +#define ID3D12GraphicsCommandList4_BeginQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList4_EndQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12GraphicsCommandList4_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ + ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) + +#define ID3D12GraphicsCommandList4_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ + ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) + +#define ID3D12GraphicsCommandList4_SetMarker(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList4_BeginEvent(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) + +#define ID3D12GraphicsCommandList4_EndEvent(This) \ + ( (This)->lpVtbl -> EndEvent(This) ) + +#define ID3D12GraphicsCommandList4_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ + ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) + + +#define ID3D12GraphicsCommandList4_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) + +#define ID3D12GraphicsCommandList4_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) + +#define ID3D12GraphicsCommandList4_OMSetDepthBounds(This,Min,Max) \ + ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) + +#define ID3D12GraphicsCommandList4_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ + ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) + +#define ID3D12GraphicsCommandList4_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ + ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) + +#define ID3D12GraphicsCommandList4_SetViewInstanceMask(This,Mask) \ + ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) + + +#define ID3D12GraphicsCommandList4_WriteBufferImmediate(This,Count,pParams,pModes) \ + ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) + + +#define ID3D12GraphicsCommandList4_SetProtectedResourceSession(This,pProtectedResourceSession) \ + ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) + + +#define ID3D12GraphicsCommandList4_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ + ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) + +#define ID3D12GraphicsCommandList4_EndRenderPass(This) \ + ( (This)->lpVtbl -> EndRenderPass(This) ) + +#define ID3D12GraphicsCommandList4_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ + ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) + +#define ID3D12GraphicsCommandList4_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ + ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) + +#define ID3D12GraphicsCommandList4_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ + ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) + +#define ID3D12GraphicsCommandList4_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ + ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) + +#define ID3D12GraphicsCommandList4_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ + ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) + +#define ID3D12GraphicsCommandList4_SetPipelineState1(This,pStateObject) \ + ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) + +#define ID3D12GraphicsCommandList4_DispatchRays(This,pDesc) \ + ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0056 */ +/* [local] */ + +typedef +enum D3D12_SHADER_CACHE_MODE + { + D3D12_SHADER_CACHE_MODE_MEMORY = 0, + D3D12_SHADER_CACHE_MODE_DISK = ( D3D12_SHADER_CACHE_MODE_MEMORY + 1 ) + } D3D12_SHADER_CACHE_MODE; + +typedef +enum D3D12_SHADER_CACHE_FLAGS + { + D3D12_SHADER_CACHE_FLAG_NONE = 0, + D3D12_SHADER_CACHE_FLAG_DRIVER_VERSIONED = 0x1, + D3D12_SHADER_CACHE_FLAG_USE_WORKING_DIR = 0x2 + } D3D12_SHADER_CACHE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_FLAGS ) +typedef struct D3D12_SHADER_CACHE_SESSION_DESC + { + GUID Identifier; + D3D12_SHADER_CACHE_MODE Mode; + D3D12_SHADER_CACHE_FLAGS Flags; + UINT MaximumInMemoryCacheSizeBytes; + UINT MaximumInMemoryCacheEntries; + UINT MaximumValueFileSizeBytes; + UINT64 Version; + } D3D12_SHADER_CACHE_SESSION_DESC; -#define ID3D12Device7_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) +typedef +enum D3D12_BARRIER_LAYOUT + { + D3D12_BARRIER_LAYOUT_UNDEFINED = 0xffffffff, + D3D12_BARRIER_LAYOUT_COMMON = 0, + D3D12_BARRIER_LAYOUT_PRESENT = 0, + D3D12_BARRIER_LAYOUT_GENERIC_READ = 1, + D3D12_BARRIER_LAYOUT_RENDER_TARGET = 2, + D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS = 3, + D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE = 4, + D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ = 5, + D3D12_BARRIER_LAYOUT_SHADER_RESOURCE = 6, + D3D12_BARRIER_LAYOUT_COPY_SOURCE = 7, + D3D12_BARRIER_LAYOUT_COPY_DEST = 8, + D3D12_BARRIER_LAYOUT_RESOLVE_SOURCE = 9, + D3D12_BARRIER_LAYOUT_RESOLVE_DEST = 10, + D3D12_BARRIER_LAYOUT_SHADING_RATE_SOURCE = 11, + D3D12_BARRIER_LAYOUT_VIDEO_DECODE_READ = 12, + D3D12_BARRIER_LAYOUT_VIDEO_DECODE_WRITE = 13, + D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_READ = 14, + D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_WRITE = 15, + D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_READ = 16, + D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_WRITE = 17, + D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON = 18, + D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ = 19, + D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS = 20, + D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE = 21, + D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE = 22, + D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST = 23, + D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON = 24, + D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ = 25, + D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS = 26, + D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE = 27, + D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE = 28, + D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST = 29, + D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ_COMPUTE_QUEUE_ACCESSIBLE = 31 + } D3D12_BARRIER_LAYOUT; -#define ID3D12Device7_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ - ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) +typedef +enum D3D12_BARRIER_SYNC + { + D3D12_BARRIER_SYNC_NONE = 0, + D3D12_BARRIER_SYNC_ALL = 0x1, + D3D12_BARRIER_SYNC_DRAW = 0x2, + D3D12_BARRIER_SYNC_INDEX_INPUT = 0x4, + D3D12_BARRIER_SYNC_VERTEX_SHADING = 0x8, + D3D12_BARRIER_SYNC_PIXEL_SHADING = 0x10, + D3D12_BARRIER_SYNC_DEPTH_STENCIL = 0x20, + D3D12_BARRIER_SYNC_RENDER_TARGET = 0x40, + D3D12_BARRIER_SYNC_COMPUTE_SHADING = 0x80, + D3D12_BARRIER_SYNC_RAYTRACING = 0x100, + D3D12_BARRIER_SYNC_COPY = 0x200, + D3D12_BARRIER_SYNC_RESOLVE = 0x400, + D3D12_BARRIER_SYNC_EXECUTE_INDIRECT = 0x800, + D3D12_BARRIER_SYNC_PREDICATION = 0x800, + D3D12_BARRIER_SYNC_ALL_SHADING = 0x1000, + D3D12_BARRIER_SYNC_NON_PIXEL_SHADING = 0x2000, + D3D12_BARRIER_SYNC_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO = 0x4000, + D3D12_BARRIER_SYNC_CLEAR_UNORDERED_ACCESS_VIEW = 0x8000, + D3D12_BARRIER_SYNC_VIDEO_DECODE = 0x100000, + D3D12_BARRIER_SYNC_VIDEO_PROCESS = 0x200000, + D3D12_BARRIER_SYNC_VIDEO_ENCODE = 0x400000, + D3D12_BARRIER_SYNC_BUILD_RAYTRACING_ACCELERATION_STRUCTURE = 0x800000, + D3D12_BARRIER_SYNC_COPY_RAYTRACING_ACCELERATION_STRUCTURE = 0x1000000, + D3D12_BARRIER_SYNC_SPLIT = 0x80000000 + } D3D12_BARRIER_SYNC; -#define ID3D12Device7_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) +DEFINE_ENUM_FLAG_OPERATORS( D3D12_BARRIER_SYNC ) +typedef +enum D3D12_BARRIER_ACCESS + { + D3D12_BARRIER_ACCESS_COMMON = 0, + D3D12_BARRIER_ACCESS_VERTEX_BUFFER = 0x1, + D3D12_BARRIER_ACCESS_CONSTANT_BUFFER = 0x2, + D3D12_BARRIER_ACCESS_INDEX_BUFFER = 0x4, + D3D12_BARRIER_ACCESS_RENDER_TARGET = 0x8, + D3D12_BARRIER_ACCESS_UNORDERED_ACCESS = 0x10, + D3D12_BARRIER_ACCESS_DEPTH_STENCIL_WRITE = 0x20, + D3D12_BARRIER_ACCESS_DEPTH_STENCIL_READ = 0x40, + D3D12_BARRIER_ACCESS_SHADER_RESOURCE = 0x80, + D3D12_BARRIER_ACCESS_STREAM_OUTPUT = 0x100, + D3D12_BARRIER_ACCESS_INDIRECT_ARGUMENT = 0x200, + D3D12_BARRIER_ACCESS_PREDICATION = 0x200, + D3D12_BARRIER_ACCESS_COPY_DEST = 0x400, + D3D12_BARRIER_ACCESS_COPY_SOURCE = 0x800, + D3D12_BARRIER_ACCESS_RESOLVE_DEST = 0x1000, + D3D12_BARRIER_ACCESS_RESOLVE_SOURCE = 0x2000, + D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_READ = 0x4000, + D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_WRITE = 0x8000, + D3D12_BARRIER_ACCESS_SHADING_RATE_SOURCE = 0x10000, + D3D12_BARRIER_ACCESS_VIDEO_DECODE_READ = 0x20000, + D3D12_BARRIER_ACCESS_VIDEO_DECODE_WRITE = 0x40000, + D3D12_BARRIER_ACCESS_VIDEO_PROCESS_READ = 0x80000, + D3D12_BARRIER_ACCESS_VIDEO_PROCESS_WRITE = 0x100000, + D3D12_BARRIER_ACCESS_VIDEO_ENCODE_READ = 0x200000, + D3D12_BARRIER_ACCESS_VIDEO_ENCODE_WRITE = 0x400000, + D3D12_BARRIER_ACCESS_NO_ACCESS = 0x80000000 + } D3D12_BARRIER_ACCESS; -#define ID3D12Device7_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) +DEFINE_ENUM_FLAG_OPERATORS( D3D12_BARRIER_ACCESS ) +typedef +enum D3D12_BARRIER_TYPE + { + D3D12_BARRIER_TYPE_GLOBAL = 0, + D3D12_BARRIER_TYPE_TEXTURE = ( D3D12_BARRIER_TYPE_GLOBAL + 1 ) , + D3D12_BARRIER_TYPE_BUFFER = ( D3D12_BARRIER_TYPE_TEXTURE + 1 ) + } D3D12_BARRIER_TYPE; -#define ID3D12Device7_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) +typedef +enum D3D12_TEXTURE_BARRIER_FLAGS + { + D3D12_TEXTURE_BARRIER_FLAG_NONE = 0, + D3D12_TEXTURE_BARRIER_FLAG_DISCARD = 0x1 + } D3D12_TEXTURE_BARRIER_FLAGS; -#define ID3D12Device7_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ - ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) +DEFINE_ENUM_FLAG_OPERATORS( D3D12_TEXTURE_BARRIER_FLAGS ) +typedef struct D3D12_BARRIER_SUBRESOURCE_RANGE + { + UINT IndexOrFirstMipLevel; + UINT NumMipLevels; + UINT FirstArraySlice; + UINT NumArraySlices; + UINT FirstPlane; + UINT NumPlanes; + } D3D12_BARRIER_SUBRESOURCE_RANGE; -#define ID3D12Device7_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) +typedef struct D3D12_GLOBAL_BARRIER + { + D3D12_BARRIER_SYNC SyncBefore; + D3D12_BARRIER_SYNC SyncAfter; + D3D12_BARRIER_ACCESS AccessBefore; + D3D12_BARRIER_ACCESS AccessAfter; + } D3D12_GLOBAL_BARRIER; -#define ID3D12Device7_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ - ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) +typedef struct D3D12_TEXTURE_BARRIER + { + D3D12_BARRIER_SYNC SyncBefore; + D3D12_BARRIER_SYNC SyncAfter; + D3D12_BARRIER_ACCESS AccessBefore; + D3D12_BARRIER_ACCESS AccessAfter; + D3D12_BARRIER_LAYOUT LayoutBefore; + D3D12_BARRIER_LAYOUT LayoutAfter; + _In_ ID3D12Resource *pResource; + D3D12_BARRIER_SUBRESOURCE_RANGE Subresources; + D3D12_TEXTURE_BARRIER_FLAGS Flags; + } D3D12_TEXTURE_BARRIER; -#define ID3D12Device7_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ - ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) +typedef struct D3D12_BUFFER_BARRIER + { + D3D12_BARRIER_SYNC SyncBefore; + D3D12_BARRIER_SYNC SyncAfter; + D3D12_BARRIER_ACCESS AccessBefore; + D3D12_BARRIER_ACCESS AccessAfter; + _In_ ID3D12Resource *pResource; + UINT64 Offset; + UINT64 Size; + } D3D12_BUFFER_BARRIER; -#define ID3D12Device7_CreateConstantBufferView(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) +typedef struct D3D12_BARRIER_GROUP + { + D3D12_BARRIER_TYPE Type; + UINT32 NumBarriers; + union + { + _In_reads_(NumBarriers) const D3D12_GLOBAL_BARRIER *pGlobalBarriers; + _In_reads_(NumBarriers) const D3D12_TEXTURE_BARRIER *pTextureBarriers; + _In_reads_(NumBarriers) const D3D12_BUFFER_BARRIER *pBufferBarriers; + } ; + } D3D12_BARRIER_GROUP; -#define ID3D12Device7_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12Device7_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) -#define ID3D12Device7_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0056_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0056_v0_0_s_ifspec; -#define ID3D12Device7_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) +#ifndef __ID3D12ShaderCacheSession_INTERFACE_DEFINED__ +#define __ID3D12ShaderCacheSession_INTERFACE_DEFINED__ -#define ID3D12Device7_CreateSampler(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) +/* interface ID3D12ShaderCacheSession */ +/* [unique][local][object][uuid] */ -#define ID3D12Device7_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) -#define ID3D12Device7_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) -#if !defined(_WIN32) +EXTERN_C const IID IID_ID3D12ShaderCacheSession; -#define ID3D12Device7_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("28e2495d-0f64-4ae4-a6ec-129255dc49a8") + ID3D12ShaderCacheSession : public ID3D12DeviceChild + { + public: + virtual HRESULT STDMETHODCALLTYPE FindValue( + /* [annotation][in] */ + _In_reads_bytes_(KeySize) const void *pKey, + UINT KeySize, + /* [annotation][out] */ + _Out_writes_bytes_(*pValueSize) void *pValue, + _Inout_ UINT *pValueSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE StoreValue( + /* [annotation][in] */ + _In_reads_bytes_(KeySize) const void *pKey, + UINT KeySize, + /* [annotation][in] */ + _In_reads_bytes_(ValueSize) const void *pValue, + UINT ValueSize) = 0; + + virtual void STDMETHODCALLTYPE SetDeleteOnDestroy( void) = 0; + +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) + virtual D3D12_SHADER_CACHE_SESSION_DESC STDMETHODCALLTYPE GetDesc( void) = 0; #else -#define ID3D12Device7_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) + virtual D3D12_SHADER_CACHE_SESSION_DESC *STDMETHODCALLTYPE GetDesc( + D3D12_SHADER_CACHE_SESSION_DESC * RetVal) = 0; #endif + + }; + + +#else /* C style interface */ + + typedef struct ID3D12ShaderCacheSessionVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12ShaderCacheSession * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12ShaderCacheSession * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12ShaderCacheSession * This); + + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12ShaderCacheSession * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12ShaderCacheSession * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12ShaderCacheSession * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12ShaderCacheSession * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12ShaderCacheSession * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + DECLSPEC_XFGVIRT(ID3D12ShaderCacheSession, FindValue) + HRESULT ( STDMETHODCALLTYPE *FindValue )( + ID3D12ShaderCacheSession * This, + /* [annotation][in] */ + _In_reads_bytes_(KeySize) const void *pKey, + UINT KeySize, + /* [annotation][out] */ + _Out_writes_bytes_(*pValueSize) void *pValue, + _Inout_ UINT *pValueSize); + + DECLSPEC_XFGVIRT(ID3D12ShaderCacheSession, StoreValue) + HRESULT ( STDMETHODCALLTYPE *StoreValue )( + ID3D12ShaderCacheSession * This, + /* [annotation][in] */ + _In_reads_bytes_(KeySize) const void *pKey, + UINT KeySize, + /* [annotation][in] */ + _In_reads_bytes_(ValueSize) const void *pValue, + UINT ValueSize); + + DECLSPEC_XFGVIRT(ID3D12ShaderCacheSession, SetDeleteOnDestroy) + void ( STDMETHODCALLTYPE *SetDeleteOnDestroy )( + ID3D12ShaderCacheSession * This); + + DECLSPEC_XFGVIRT(ID3D12ShaderCacheSession, GetDesc) #if !defined(_WIN32) - -#define ID3D12Device7_GetCustomHeapProperties(This,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) + D3D12_SHADER_CACHE_SESSION_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12ShaderCacheSession * This); + #else -#define ID3D12Device7_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) + D3D12_SHADER_CACHE_SESSION_DESC *( STDMETHODCALLTYPE *GetDesc )( + ID3D12ShaderCacheSession * This, + D3D12_SHADER_CACHE_SESSION_DESC * RetVal); + #endif + + END_INTERFACE + } ID3D12ShaderCacheSessionVtbl; -#define ID3D12Device7_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) - -#define ID3D12Device7_CreateHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device7_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device7_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device7_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ - ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) - -#define ID3D12Device7_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ - ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) - -#define ID3D12Device7_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ - ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) - -#define ID3D12Device7_MakeResident(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) - -#define ID3D12Device7_Evict(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) - -#define ID3D12Device7_CreateFence(This,InitialValue,Flags,riid,ppFence) \ - ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) - -#define ID3D12Device7_GetDeviceRemovedReason(This) \ - ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) - -#define ID3D12Device7_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) - -#define ID3D12Device7_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) - -#define ID3D12Device7_SetStablePowerState(This,Enable) \ - ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) - -#define ID3D12Device7_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ - ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) - -#define ID3D12Device7_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ - ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) -#if !defined(_WIN32) + interface ID3D12ShaderCacheSession + { + CONST_VTBL struct ID3D12ShaderCacheSessionVtbl *lpVtbl; + }; -#define ID3D12Device7_GetAdapterLuid(This) \ - ( (This)->lpVtbl -> GetAdapterLuid(This) ) -#else -#define ID3D12Device7_GetAdapterLuid(This,RetVal) \ - ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) -#endif + +#ifdef COBJMACROS -#define ID3D12Device7_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ - ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) -#define ID3D12Device7_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ - ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) +#define ID3D12ShaderCacheSession_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12Device7_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ - ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) +#define ID3D12ShaderCacheSession_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) +#define ID3D12ShaderCacheSession_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Device7_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) +#define ID3D12ShaderCacheSession_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12Device7_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) +#define ID3D12ShaderCacheSession_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12Device7_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) +#define ID3D12ShaderCacheSession_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12Device7_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ - ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) +#define ID3D12ShaderCacheSession_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12Device7_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) +#define ID3D12ShaderCacheSession_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) -#define ID3D12Device7_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ - ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) -#define ID3D12Device7_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) +#define ID3D12ShaderCacheSession_FindValue(This,pKey,KeySize,pValue,pValueSize) \ + ( (This)->lpVtbl -> FindValue(This,pKey,KeySize,pValue,pValueSize) ) -#define ID3D12Device7_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) +#define ID3D12ShaderCacheSession_StoreValue(This,pKey,KeySize,pValue,ValueSize) \ + ( (This)->lpVtbl -> StoreValue(This,pKey,KeySize,pValue,ValueSize) ) -#define ID3D12Device7_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) +#define ID3D12ShaderCacheSession_SetDeleteOnDestroy(This) \ + ( (This)->lpVtbl -> SetDeleteOnDestroy(This) ) #if !defined(_WIN32) -#define ID3D12Device7_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#define ID3D12ShaderCacheSession_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) #else -#define ID3D12Device7_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#define ID3D12ShaderCacheSession_GetDesc(This,RetVal) \ + ( (This)->lpVtbl -> GetDesc(This,RetVal) ) #endif - -#define ID3D12Device7_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ - ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) - -#define ID3D12Device7_RemoveDevice(This) \ - ( (This)->lpVtbl -> RemoveDevice(This) ) - -#define ID3D12Device7_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) - -#define ID3D12Device7_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) - -#define ID3D12Device7_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ - ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) - -#define ID3D12Device7_CreateStateObject(This,pDesc,riid,ppStateObject) \ - ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) - -#define ID3D12Device7_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ - ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) - -#define ID3D12Device7_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ - ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) +#endif /* COBJMACROS */ -#define ID3D12Device7_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ - ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) +#endif /* C style interface */ -#define ID3D12Device7_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) \ - ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) -#define ID3D12Device7_CreateProtectedResourceSession1(This,pDesc,riid,ppSession) \ - ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) -#endif /* COBJMACROS */ +#endif /* __ID3D12ShaderCacheSession_INTERFACE_DEFINED__ */ -#endif /* C style interface */ +/* interface __MIDL_itf_d3d12_0000_0057 */ +/* [local] */ +typedef +enum D3D12_SHADER_CACHE_KIND_FLAGS + { + D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CACHE_FOR_DRIVER = 0x1, + D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CONVERSIONS = 0x2, + D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_DRIVER_MANAGED = 0x4, + D3D12_SHADER_CACHE_KIND_FLAG_APPLICATION_MANAGED = 0x8 + } D3D12_SHADER_CACHE_KIND_FLAGS; +DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_KIND_FLAGS ) +typedef +enum D3D12_SHADER_CACHE_CONTROL_FLAGS + { + D3D12_SHADER_CACHE_CONTROL_FLAG_DISABLE = 0x1, + D3D12_SHADER_CACHE_CONTROL_FLAG_ENABLE = 0x2, + D3D12_SHADER_CACHE_CONTROL_FLAG_CLEAR = 0x4 + } D3D12_SHADER_CACHE_CONTROL_FLAGS; +DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_CONTROL_FLAGS ) -#endif /* __ID3D12Device7_INTERFACE_DEFINED__ */ +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0057_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0057_v0_0_s_ifspec; -#ifndef __ID3D12Device8_INTERFACE_DEFINED__ -#define __ID3D12Device8_INTERFACE_DEFINED__ +#ifndef __ID3D12Device9_INTERFACE_DEFINED__ +#define __ID3D12Device9_INTERFACE_DEFINED__ -/* interface ID3D12Device8 */ +/* interface ID3D12Device9 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12Device8; +EXTERN_C const IID IID_ID3D12Device9; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("9218E6BB-F944-4F7E-A75C-B1B2C7B701F3") - ID3D12Device8 : public ID3D12Device7 + MIDL_INTERFACE("4c80e962-f032-4f60-bc9e-ebc2cfa1d83c") + ID3D12Device9 : public ID3D12Device8 { public: -#if defined(_MSC_VER) - virtual D3D12_RESOURCE_ALLOCATION_INFO STDMETHODCALLTYPE GetResourceAllocationInfo2( - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1) = 0; -#else - virtual D3D12_RESOURCE_ALLOCATION_INFO *STDMETHODCALLTYPE GetResourceAllocationInfo2( - D3D12_RESOURCE_ALLOCATION_INFO * RetVal, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1) = 0; -#endif - - virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource2( - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreatePlacedResource1( - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + virtual HRESULT STDMETHODCALLTYPE CreateShaderCacheSession( + _In_ const D3D12_SHADER_CACHE_SESSION_DESC *pDesc, REFIID riid, - _COM_Outptr_opt_ void **ppvResource) = 0; + _COM_Outptr_opt_ void **ppvSession) = 0; - virtual void STDMETHODCALLTYPE CreateSamplerFeedbackUnorderedAccessView( - _In_opt_ ID3D12Resource *pTargetedResource, - _In_opt_ ID3D12Resource *pFeedbackResource, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + virtual HRESULT STDMETHODCALLTYPE ShaderCacheControl( + D3D12_SHADER_CACHE_KIND_FLAGS Kinds, + D3D12_SHADER_CACHE_CONTROL_FLAGS Control) = 0; - virtual void STDMETHODCALLTYPE GetCopyableFootprints1( - _In_ const D3D12_RESOURCE_DESC1 *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes) = 0; + virtual HRESULT STDMETHODCALLTYPE CreateCommandQueue1( + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID CreatorID, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue) = 0; }; #else /* C style interface */ - typedef struct ID3D12Device8Vtbl + typedef struct ID3D12Device9Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device8 * This, + ID3D12Device9 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device8 * This); + ID3D12Device9 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device8 * This); + ID3D12Device9 * This); DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ REFGUID guid, _Inout_ UINT *pDataSize, _Out_writes_bytes_opt_( *pDataSize ) void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_( DataSize ) const void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ REFGUID guid, _In_opt_ const IUnknown *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetName) HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_z_ LPCWSTR Name); DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device8 * This); + ID3D12Device9 * This); DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, REFIID riid, _COM_Outptr_ void **ppCommandQueue); DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ D3D12_COMMAND_LIST_TYPE type, REFIID riid, _COM_Outptr_ void **ppCommandAllocator); DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, REFIID riid, _COM_Outptr_ void **ppPipelineState); DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, REFIID riid, _COM_Outptr_ void **ppPipelineState); DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ UINT nodeMask, _In_ D3D12_COMMAND_LIST_TYPE type, _In_ ID3D12CommandAllocator *pCommandAllocator, @@ -17667,26 +23407,26 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device8 * This, + ID3D12Device9 * This, D3D12_FEATURE Feature, _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, UINT FeatureSupportDataSize); DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, REFIID riid, _COM_Outptr_ void **ppvHeap); DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ UINT nodeMask, _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, _In_ SIZE_T blobLengthInBytes, @@ -17695,20 +23435,20 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_opt_ ID3D12Resource *pResource, _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_opt_ ID3D12Resource *pResource, _In_opt_ ID3D12Resource *pCounterResource, _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, @@ -17716,27 +23456,27 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_opt_ ID3D12Resource *pResource, _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_opt_ ID3D12Resource *pResource, _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_SAMPLER_DESC *pDesc, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ UINT NumDestDescriptorRanges, _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, @@ -17747,7 +23487,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ UINT NumDescriptors, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, @@ -17756,14 +23496,14 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) #if !defined(_WIN32) D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ UINT visibleMask, _In_ UINT numResourceDescs, _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); #else D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device8 * This, + ID3D12Device9 * This, D3D12_RESOURCE_ALLOCATION_INFO * RetVal, _In_ UINT visibleMask, _In_ UINT numResourceDescs, @@ -17774,13 +23514,13 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) #if !defined(_WIN32) D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ UINT nodeMask, D3D12_HEAP_TYPE heapType); #else D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device8 * This, + ID3D12Device9 * This, D3D12_HEAP_PROPERTIES * RetVal, _In_ UINT nodeMask, D3D12_HEAP_TYPE heapType); @@ -17789,7 +23529,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, _In_ const D3D12_RESOURCE_DESC *pDesc, @@ -17800,14 +23540,14 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_HEAP_DESC *pDesc, REFIID riid, _COM_Outptr_opt_ void **ppvHeap); DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ ID3D12Heap *pHeap, UINT64 HeapOffset, _In_ const D3D12_RESOURCE_DESC *pDesc, @@ -17818,7 +23558,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_RESOURCE_DESC *pDesc, D3D12_RESOURCE_STATES InitialState, _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, @@ -17827,7 +23567,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ ID3D12DeviceChild *pObject, _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, DWORD Access, @@ -17836,14 +23576,14 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ HANDLE NTHandle, REFIID riid, _COM_Outptr_opt_ void **ppvObj); DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ LPCWSTR Name, DWORD Access, /* [annotation][out] */ @@ -17851,19 +23591,19 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device8 * This, + ID3D12Device9 * This, UINT NumObjects, _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); DECLSPEC_XFGVIRT(ID3D12Device, Evict) HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device8 * This, + ID3D12Device9 * This, UINT NumObjects, _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device8 * This, + ID3D12Device9 * This, UINT64 InitialValue, D3D12_FENCE_FLAGS Flags, REFIID riid, @@ -17871,11 +23611,11 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device8 * This); + ID3D12Device9 * This); DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_RESOURCE_DESC *pResourceDesc, _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, @@ -17887,19 +23627,19 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_QUERY_HEAP_DESC *pDesc, REFIID riid, _COM_Outptr_opt_ void **ppvHeap); DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device8 * This, + ID3D12Device9 * This, BOOL Enable); DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, _In_opt_ ID3D12RootSignature *pRootSignature, REFIID riid, @@ -17907,7 +23647,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ ID3D12Resource *pTiledResource, _Out_opt_ UINT *pNumTilesForEntireResource, _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, @@ -17919,18 +23659,18 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) #if !defined(_WIN32) LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device8 * This); + ID3D12Device9 * This); #else LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device8 * This, + ID3D12Device9 * This, LUID * RetVal); #endif DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_reads_(BlobLength) const void *pLibraryBlob, SIZE_T BlobLength, REFIID riid, @@ -17938,7 +23678,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_reads_(NumFences) ID3D12Fence *const *ppFences, _In_reads_(NumFences) const UINT64 *pFenceValues, UINT NumFences, @@ -17947,35 +23687,35 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( - ID3D12Device8 * This, + ID3D12Device9 * This, UINT NumObjects, _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( - ID3D12Device8 * This, + ID3D12Device9 * This, const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, REFIID riid, _COM_Outptr_ void **ppPipelineState); DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const void *pAddress, REFIID riid, _COM_Outptr_ void **ppvHeap); DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ HANDLE hFileMapping, REFIID riid, _COM_Outptr_ void **ppvHeap); DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( - ID3D12Device8 * This, + ID3D12Device9 * This, D3D12_RESIDENCY_FLAGS Flags, UINT NumObjects, _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, @@ -17984,7 +23724,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ UINT nodeMask, _In_ D3D12_COMMAND_LIST_TYPE type, _In_ D3D12_COMMAND_LIST_FLAGS flags, @@ -17993,14 +23733,14 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, _In_ REFIID riid, _COM_Outptr_ void **ppSession); DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, _In_ const D3D12_RESOURCE_DESC *pDesc, @@ -18012,7 +23752,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_HEAP_DESC *pDesc, _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, REFIID riid, @@ -18020,7 +23760,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_RESOURCE_DESC *pDesc, D3D12_RESOURCE_STATES InitialState, _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, @@ -18031,7 +23771,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) #if !defined(_WIN32) D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device8 * This, + ID3D12Device9 * This, UINT visibleMask, UINT numResourceDescs, _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, @@ -18039,7 +23779,7 @@ EXTERN_C const IID IID_ID3D12Device8; #else D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device8 * This, + ID3D12Device9 * This, D3D12_RESOURCE_ALLOCATION_INFO * RetVal, UINT visibleMask, UINT numResourceDescs, @@ -18050,24 +23790,24 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ ID3D12LifetimeOwner *pOwner, REFIID riid, _COM_Outptr_ void **ppvTracker); DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) void ( STDMETHODCALLTYPE *RemoveDevice )( - ID3D12Device8 * This); + ID3D12Device9 * This); DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( - ID3D12Device8 * This, + ID3D12Device9 * This, _Inout_ UINT *pNumMetaCommands, _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ REFGUID CommandId, _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, _Out_opt_ UINT *pTotalStructureSizeInBytes, @@ -18076,7 +23816,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ REFGUID CommandId, _In_ UINT NodeMask, _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, @@ -18086,26 +23826,26 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( - ID3D12Device8 * This, + ID3D12Device9 * This, const D3D12_STATE_OBJECT_DESC *pDesc, REFIID riid, _COM_Outptr_ void **ppStateObject); DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( - ID3D12Device8 * This, + ID3D12Device9 * This, D3D12_BACKGROUND_PROCESSING_MODE Mode, D3D12_MEASUREMENTS_ACTION MeasurementsAction, _In_opt_ HANDLE hEventToSignalUponCompletion, @@ -18113,7 +23853,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject) HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( - ID3D12Device8 * This, + ID3D12Device9 * This, const D3D12_STATE_OBJECT_DESC *pAddition, ID3D12StateObject *pStateObjectToGrowFrom, REFIID riid, @@ -18121,7 +23861,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1) HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, _In_ REFIID riid, _COM_Outptr_ void **ppSession); @@ -18129,7 +23869,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2) #if !defined(_WIN32) D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( - ID3D12Device8 * This, + ID3D12Device9 * This, UINT visibleMask, UINT numResourceDescs, _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, @@ -18137,7 +23877,7 @@ EXTERN_C const IID IID_ID3D12Device8; #else D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( - ID3D12Device8 * This, + ID3D12Device9 * This, D3D12_RESOURCE_ALLOCATION_INFO * RetVal, UINT visibleMask, UINT numResourceDescs, @@ -18148,7 +23888,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2) HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, _In_ const D3D12_RESOURCE_DESC1 *pDesc, @@ -18160,7 +23900,7 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1) HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ ID3D12Heap *pHeap, UINT64 HeapOffset, _In_ const D3D12_RESOURCE_DESC1 *pDesc, @@ -18171,14 +23911,14 @@ EXTERN_C const IID IID_ID3D12Device8; DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView) void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_opt_ ID3D12Resource *pTargetedResource, _In_opt_ ID3D12Resource *pFeedbackResource, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1) void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( - ID3D12Device8 * This, + ID3D12Device9 * This, _In_ const D3D12_RESOURCE_DESC1 *pResourceDesc, _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, @@ -18188,12 +23928,33 @@ EXTERN_C const IID IID_ID3D12Device8; _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, _Out_opt_ UINT64 *pTotalBytes); + DECLSPEC_XFGVIRT(ID3D12Device9, CreateShaderCacheSession) + HRESULT ( STDMETHODCALLTYPE *CreateShaderCacheSession )( + ID3D12Device9 * This, + _In_ const D3D12_SHADER_CACHE_SESSION_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvSession); + + DECLSPEC_XFGVIRT(ID3D12Device9, ShaderCacheControl) + HRESULT ( STDMETHODCALLTYPE *ShaderCacheControl )( + ID3D12Device9 * This, + D3D12_SHADER_CACHE_KIND_FLAGS Kinds, + D3D12_SHADER_CACHE_CONTROL_FLAGS Control); + + DECLSPEC_XFGVIRT(ID3D12Device9, CreateCommandQueue1) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue1 )( + ID3D12Device9 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID CreatorID, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + END_INTERFACE - } ID3D12Device8Vtbl; + } ID3D12Device9Vtbl; - interface ID3D12Device8 + interface ID3D12Device9 { - CONST_VTBL struct ID3D12Device8Vtbl *lpVtbl; + CONST_VTBL struct ID3D12Device9Vtbl *lpVtbl; }; @@ -18201,638 +23962,1008 @@ EXTERN_C const IID IID_ID3D12Device8; #ifdef COBJMACROS -#define ID3D12Device8_QueryInterface(This,riid,ppvObject) \ +#define ID3D12Device9_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12Device8_AddRef(This) \ +#define ID3D12Device9_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12Device8_Release(This) \ +#define ID3D12Device9_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Device8_GetPrivateData(This,guid,pDataSize,pData) \ +#define ID3D12Device9_GetPrivateData(This,guid,pDataSize,pData) \ ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12Device8_SetPrivateData(This,guid,DataSize,pData) \ +#define ID3D12Device9_SetPrivateData(This,guid,DataSize,pData) \ ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12Device8_SetPrivateDataInterface(This,guid,pData) \ +#define ID3D12Device9_SetPrivateDataInterface(This,guid,pData) \ ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12Device8_SetName(This,Name) \ +#define ID3D12Device9_SetName(This,Name) \ ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12Device8_GetNodeCount(This) \ +#define ID3D12Device9_GetNodeCount(This) \ ( (This)->lpVtbl -> GetNodeCount(This) ) -#define ID3D12Device8_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ +#define ID3D12Device9_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) -#define ID3D12Device8_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ +#define ID3D12Device9_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) -#define ID3D12Device8_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ +#define ID3D12Device9_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12Device8_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ +#define ID3D12Device9_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12Device8_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ +#define ID3D12Device9_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) -#define ID3D12Device8_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ +#define ID3D12Device9_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) -#define ID3D12Device8_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ +#define ID3D12Device9_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) -#define ID3D12Device8_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ +#define ID3D12Device9_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) -#define ID3D12Device8_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ +#define ID3D12Device9_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) -#define ID3D12Device8_CreateConstantBufferView(This,pDesc,DestDescriptor) \ +#define ID3D12Device9_CreateConstantBufferView(This,pDesc,DestDescriptor) \ ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) -#define ID3D12Device8_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ +#define ID3D12Device9_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12Device8_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ +#define ID3D12Device9_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) -#define ID3D12Device8_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ +#define ID3D12Device9_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12Device8_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ +#define ID3D12Device9_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12Device8_CreateSampler(This,pDesc,DestDescriptor) \ +#define ID3D12Device9_CreateSampler(This,pDesc,DestDescriptor) \ ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) -#define ID3D12Device8_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ +#define ID3D12Device9_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) -#define ID3D12Device8_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ +#define ID3D12Device9_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) #if !defined(_WIN32) -#define ID3D12Device8_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ +#define ID3D12Device9_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) #else -#define ID3D12Device8_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ +#define ID3D12Device9_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) #endif #if !defined(_WIN32) -#define ID3D12Device8_GetCustomHeapProperties(This,nodeMask,heapType) \ +#define ID3D12Device9_GetCustomHeapProperties(This,nodeMask,heapType) \ ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) #else -#define ID3D12Device8_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ +#define ID3D12Device9_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) #endif -#define ID3D12Device8_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ +#define ID3D12Device9_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) -#define ID3D12Device8_CreateHeap(This,pDesc,riid,ppvHeap) \ +#define ID3D12Device9_CreateHeap(This,pDesc,riid,ppvHeap) \ ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) -#define ID3D12Device8_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ +#define ID3D12Device9_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) -#define ID3D12Device8_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ +#define ID3D12Device9_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) -#define ID3D12Device8_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ +#define ID3D12Device9_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) -#define ID3D12Device8_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ +#define ID3D12Device9_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) -#define ID3D12Device8_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ +#define ID3D12Device9_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) -#define ID3D12Device8_MakeResident(This,NumObjects,ppObjects) \ +#define ID3D12Device9_MakeResident(This,NumObjects,ppObjects) \ ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) -#define ID3D12Device8_Evict(This,NumObjects,ppObjects) \ +#define ID3D12Device9_Evict(This,NumObjects,ppObjects) \ ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) -#define ID3D12Device8_CreateFence(This,InitialValue,Flags,riid,ppFence) \ +#define ID3D12Device9_CreateFence(This,InitialValue,Flags,riid,ppFence) \ ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) -#define ID3D12Device8_GetDeviceRemovedReason(This) \ +#define ID3D12Device9_GetDeviceRemovedReason(This) \ ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) -#define ID3D12Device8_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ +#define ID3D12Device9_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) -#define ID3D12Device8_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ +#define ID3D12Device9_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) -#define ID3D12Device8_SetStablePowerState(This,Enable) \ +#define ID3D12Device9_SetStablePowerState(This,Enable) \ ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) -#define ID3D12Device8_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ +#define ID3D12Device9_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) -#define ID3D12Device8_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ +#define ID3D12Device9_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) #if !defined(_WIN32) -#define ID3D12Device8_GetAdapterLuid(This) \ +#define ID3D12Device9_GetAdapterLuid(This) \ ( (This)->lpVtbl -> GetAdapterLuid(This) ) #else -#define ID3D12Device8_GetAdapterLuid(This,RetVal) \ +#define ID3D12Device9_GetAdapterLuid(This,RetVal) \ ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) #endif -#define ID3D12Device8_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ +#define ID3D12Device9_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) -#define ID3D12Device8_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ +#define ID3D12Device9_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) -#define ID3D12Device8_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ +#define ID3D12Device9_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) -#define ID3D12Device8_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ +#define ID3D12Device9_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12Device8_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ +#define ID3D12Device9_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) -#define ID3D12Device8_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ +#define ID3D12Device9_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) -#define ID3D12Device8_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ +#define ID3D12Device9_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) -#define ID3D12Device8_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ +#define ID3D12Device9_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) -#define ID3D12Device8_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ +#define ID3D12Device9_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) -#define ID3D12Device8_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ +#define ID3D12Device9_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) -#define ID3D12Device8_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ +#define ID3D12Device9_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) -#define ID3D12Device8_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ +#define ID3D12Device9_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) #if !defined(_WIN32) - -#define ID3D12Device8_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) + +#define ID3D12Device9_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device9_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif + + +#define ID3D12Device9_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ + ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) + +#define ID3D12Device9_RemoveDevice(This) \ + ( (This)->lpVtbl -> RemoveDevice(This) ) + +#define ID3D12Device9_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) + +#define ID3D12Device9_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) + +#define ID3D12Device9_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ + ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) + +#define ID3D12Device9_CreateStateObject(This,pDesc,riid,ppStateObject) \ + ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) + +#define ID3D12Device9_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ + ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) + +#define ID3D12Device9_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ + ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) + + +#define ID3D12Device9_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ + ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) + + +#define ID3D12Device9_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) \ + ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) + +#define ID3D12Device9_CreateProtectedResourceSession1(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) + +#if !defined(_WIN32) + +#define ID3D12Device9_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device9_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif + +#define ID3D12Device9_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) + +#define ID3D12Device9_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device9_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) + +#define ID3D12Device9_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + + +#define ID3D12Device9_CreateShaderCacheSession(This,pDesc,riid,ppvSession) \ + ( (This)->lpVtbl -> CreateShaderCacheSession(This,pDesc,riid,ppvSession) ) + +#define ID3D12Device9_ShaderCacheControl(This,Kinds,Control) \ + ( (This)->lpVtbl -> ShaderCacheControl(This,Kinds,Control) ) + +#define ID3D12Device9_CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Device9_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Device10_INTERFACE_DEFINED__ +#define __ID3D12Device10_INTERFACE_DEFINED__ + +/* interface ID3D12Device10 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Device10; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("517f8718-aa66-49f9-b02b-a7ab89c06031") + ID3D12Device10 : public ID3D12Device9 + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource3( + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreatePlacedResource2( + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateReservedResource2( + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Device10Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Device10 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Device10 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Device10 * This); + + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Device10 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Device10 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Device10 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Device10 * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device10 * This); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device10 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device10 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device10 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device10 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device10 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device10 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device10 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device10 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device10 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device10 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device10 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device10 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device10 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device10 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device10 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device10 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device10 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device10 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + #else -#define ID3D12Device8_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device10 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + #endif - - -#define ID3D12Device8_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ - ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) - -#define ID3D12Device8_RemoveDevice(This) \ - ( (This)->lpVtbl -> RemoveDevice(This) ) - -#define ID3D12Device8_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) - -#define ID3D12Device8_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) - -#define ID3D12Device8_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ - ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) - -#define ID3D12Device8_CreateStateObject(This,pDesc,riid,ppStateObject) \ - ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) - -#define ID3D12Device8_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ - ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) - -#define ID3D12Device8_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ - ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) - - -#define ID3D12Device8_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ - ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) - - -#define ID3D12Device8_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) \ - ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) - -#define ID3D12Device8_CreateProtectedResourceSession1(This,pDesc,riid,ppSession) \ - ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) - + + DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) #if !defined(_WIN32) - -#define ID3D12Device8_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device10 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + #else -#define ID3D12Device8_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) + D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device10 * This, + D3D12_HEAP_PROPERTIES * RetVal, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + #endif - -#define ID3D12Device8_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) - -#define ID3D12Device8_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) - -#define ID3D12Device8_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) - -#define ID3D12Device8_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Device8_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Resource1_INTERFACE_DEFINED__ -#define __ID3D12Resource1_INTERFACE_DEFINED__ - -/* interface ID3D12Resource1 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Resource1; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("9D5E227A-4430-4161-88B3-3ECA6BB16E19") - ID3D12Resource1 : public ID3D12Resource - { - public: - virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device10 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device10 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device10 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, REFIID riid, - _COM_Outptr_opt_ void **ppProtectedSession) = 0; + _COM_Outptr_opt_ void **ppvResource); - }; - - -#else /* C style interface */ - - typedef struct ID3D12Resource1Vtbl - { - BEGIN_INTERFACE + DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device10 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Resource1 * This, + DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device10 * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); + + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device10 * This, + _In_ HANDLE NTHandle, REFIID riid, - _COM_Outptr_ void **ppvObject); + _COM_Outptr_opt_ void **ppvObj); - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Resource1 * This); + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device10 * This, + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle); - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Resource1 * This); + DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device10 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Resource1 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); + DECLSPEC_XFGVIRT(ID3D12Device, Evict) + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device10 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Resource1 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); + DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device10 * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Resource1 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); + DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device10 * This); - DECLSPEC_XFGVIRT(ID3D12Object, SetName) - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Resource1 * This, - _In_z_ LPCWSTR Name); + DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device10 * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); - DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12Resource1 * This, + DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device10 * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); + _COM_Outptr_opt_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12Resource, Map) - HRESULT ( STDMETHODCALLTYPE *Map )( - ID3D12Resource1 * This, - UINT Subresource, - _In_opt_ const D3D12_RANGE *pReadRange, - _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource")) void **ppData); + DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device10 * This, + BOOL Enable); - DECLSPEC_XFGVIRT(ID3D12Resource, Unmap) - void ( STDMETHODCALLTYPE *Unmap )( - ID3D12Resource1 * This, - UINT Subresource, - _In_opt_ const D3D12_RANGE *pWrittenRange); + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device10 * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); - DECLSPEC_XFGVIRT(ID3D12Resource, GetDesc) + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device10 * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + + DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) #if !defined(_WIN32) - D3D12_RESOURCE_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12Resource1 * This); + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device10 * This); #else - D3D12_RESOURCE_DESC *( STDMETHODCALLTYPE *GetDesc )( - ID3D12Resource1 * This, - D3D12_RESOURCE_DESC * RetVal); + LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device10 * This, + LUID * RetVal); #endif - DECLSPEC_XFGVIRT(ID3D12Resource, GetGPUVirtualAddress) - D3D12_GPU_VIRTUAL_ADDRESS ( STDMETHODCALLTYPE *GetGPUVirtualAddress )( - ID3D12Resource1 * This); + DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( + ID3D12Device10 * This, + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary); - DECLSPEC_XFGVIRT(ID3D12Resource, WriteToSubresource) - HRESULT ( STDMETHODCALLTYPE *WriteToSubresource )( - ID3D12Resource1 * This, - UINT DstSubresource, - _In_opt_ const D3D12_BOX *pDstBox, - _In_ const void *pSrcData, - UINT SrcRowPitch, - UINT SrcDepthPitch); + DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) + HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( + ID3D12Device10 * This, + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent); - DECLSPEC_XFGVIRT(ID3D12Resource, ReadFromSubresource) - HRESULT ( STDMETHODCALLTYPE *ReadFromSubresource )( - ID3D12Resource1 * This, - _Out_ void *pDstData, - UINT DstRowPitch, - UINT DstDepthPitch, - UINT SrcSubresource, - _In_opt_ const D3D12_BOX *pSrcBox); + DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) + HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( + ID3D12Device10 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + + DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( + ID3D12Device10 * This, + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( + ID3D12Device10 * This, + _In_ const void *pAddress, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( + ID3D12Device10 * This, + _In_ HANDLE hFileMapping, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) + HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( + ID3D12Device10 * This, + D3D12_RESIDENCY_FLAGS Flags, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_ ID3D12Fence *pFenceToSignal, + UINT64 FenceValueToSignal); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( + ID3D12Device10 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ D3D12_COMMAND_LIST_FLAGS flags, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( + ID3D12Device10 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( + ID3D12Device10 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12Resource, GetHeapProperties) - HRESULT ( STDMETHODCALLTYPE *GetHeapProperties )( - ID3D12Resource1 * This, - _Out_opt_ D3D12_HEAP_PROPERTIES *pHeapProperties, - _Out_opt_ D3D12_HEAP_FLAGS *pHeapFlags); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) + HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( + ID3D12Device10 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12Resource1, GetProtectedResourceSession) - HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( - ID3D12Resource1 * This, + DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( + ID3D12Device10 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, REFIID riid, - _COM_Outptr_opt_ void **ppProtectedSession); + _COM_Outptr_opt_ void **ppvResource); - END_INTERFACE - } ID3D12Resource1Vtbl; - - interface ID3D12Resource1 - { - CONST_VTBL struct ID3D12Resource1Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Resource1_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Resource1_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Resource1_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Resource1_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Resource1_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12Resource1_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12Resource1_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12Resource1_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - - -#define ID3D12Resource1_Map(This,Subresource,pReadRange,ppData) \ - ( (This)->lpVtbl -> Map(This,Subresource,pReadRange,ppData) ) - -#define ID3D12Resource1_Unmap(This,Subresource,pWrittenRange) \ - ( (This)->lpVtbl -> Unmap(This,Subresource,pWrittenRange) ) + DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) #if !defined(_WIN32) - -#define ID3D12Resource1_GetDesc(This) \ - ( (This)->lpVtbl -> GetDesc(This) ) -#else -#define ID3D12Resource1_GetDesc(This,RetVal) \ - ( (This)->lpVtbl -> GetDesc(This,RetVal) ) -#endif - -#define ID3D12Resource1_GetGPUVirtualAddress(This) \ - ( (This)->lpVtbl -> GetGPUVirtualAddress(This) ) - -#define ID3D12Resource1_WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) \ - ( (This)->lpVtbl -> WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) ) - -#define ID3D12Resource1_ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) \ - ( (This)->lpVtbl -> ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) ) - -#define ID3D12Resource1_GetHeapProperties(This,pHeapProperties,pHeapFlags) \ - ( (This)->lpVtbl -> GetHeapProperties(This,pHeapProperties,pHeapFlags) ) - - -#define ID3D12Resource1_GetProtectedResourceSession(This,riid,ppProtectedSession) \ - ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Resource1_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Resource2_INTERFACE_DEFINED__ -#define __ID3D12Resource2_INTERFACE_DEFINED__ - -/* interface ID3D12Resource2 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Resource2; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("BE36EC3B-EA85-4AEB-A45A-E9D76404A495") - ID3D12Resource2 : public ID3D12Resource1 - { - public: -#if defined(_MSC_VER) - virtual D3D12_RESOURCE_DESC1 STDMETHODCALLTYPE GetDesc1( void) = 0; + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device10 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + #else - virtual D3D12_RESOURCE_DESC1 *STDMETHODCALLTYPE GetDesc1( - D3D12_RESOURCE_DESC1 * RetVal) = 0; -#endif + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device10 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - }; - - -#else /* C style interface */ - - typedef struct ID3D12Resource2Vtbl - { - BEGIN_INTERFACE +#endif - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Resource2 * This, + DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) + HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( + ID3D12Device10 * This, + _In_ ID3D12LifetimeOwner *pOwner, REFIID riid, - _COM_Outptr_ void **ppvObject); + _COM_Outptr_ void **ppvTracker); - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Resource2 * This); + DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) + void ( STDMETHODCALLTYPE *RemoveDevice )( + ID3D12Device10 * This); - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Resource2 * This); + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( + ID3D12Device10 * This, + _Inout_ UINT *pNumMetaCommands, + _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); - DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Resource2 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( + ID3D12Device10 * This, + _In_ REFGUID CommandId, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _Out_opt_ UINT *pTotalStructureSizeInBytes, + _Inout_ UINT *pParameterCount, + _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Resource2 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); + DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) + HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( + ID3D12Device10 * This, + _In_ REFGUID CommandId, + _In_ UINT NodeMask, + _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, + _In_ SIZE_T CreationParametersDataSizeInBytes, + REFIID riid, + _COM_Outptr_ void **ppMetaCommand); - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Resource2 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); + DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) + HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( + ID3D12Device10 * This, + const D3D12_STATE_OBJECT_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppStateObject); - DECLSPEC_XFGVIRT(ID3D12Object, SetName) - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Resource2 * This, - _In_z_ LPCWSTR Name); + DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) + void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( + ID3D12Device10 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, + _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); - DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12Resource2 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); + DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) + D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( + ID3D12Device10 * This, + _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, + _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); - DECLSPEC_XFGVIRT(ID3D12Resource, Map) - HRESULT ( STDMETHODCALLTYPE *Map )( - ID3D12Resource2 * This, - UINT Subresource, - _In_opt_ const D3D12_RANGE *pReadRange, - _Outptr_opt_result_bytebuffer_(_Inexpressible_("Dependent on resource")) void **ppData); + DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) + HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( + ID3D12Device10 * This, + D3D12_BACKGROUND_PROCESSING_MODE Mode, + D3D12_MEASUREMENTS_ACTION MeasurementsAction, + _In_opt_ HANDLE hEventToSignalUponCompletion, + _Out_opt_ BOOL *pbFurtherMeasurementsDesired); - DECLSPEC_XFGVIRT(ID3D12Resource, Unmap) - void ( STDMETHODCALLTYPE *Unmap )( - ID3D12Resource2 * This, - UINT Subresource, - _In_opt_ const D3D12_RANGE *pWrittenRange); + DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject) + HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( + ID3D12Device10 * This, + const D3D12_STATE_OBJECT_DESC *pAddition, + ID3D12StateObject *pStateObjectToGrowFrom, + REFIID riid, + _COM_Outptr_ void **ppNewStateObject); - DECLSPEC_XFGVIRT(ID3D12Resource, GetDesc) + DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( + ID3D12Device10 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); + + DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2) #if !defined(_WIN32) - D3D12_RESOURCE_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12Resource2 * This); + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( + ID3D12Device10 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); #else - D3D12_RESOURCE_DESC *( STDMETHODCALLTYPE *GetDesc )( - ID3D12Resource2 * This, - D3D12_RESOURCE_DESC * RetVal); + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( + ID3D12Device10 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); #endif - DECLSPEC_XFGVIRT(ID3D12Resource, GetGPUVirtualAddress) - D3D12_GPU_VIRTUAL_ADDRESS ( STDMETHODCALLTYPE *GetGPUVirtualAddress )( - ID3D12Resource2 * This); + DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( + ID3D12Device10 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12Resource, WriteToSubresource) - HRESULT ( STDMETHODCALLTYPE *WriteToSubresource )( - ID3D12Resource2 * This, - UINT DstSubresource, - _In_opt_ const D3D12_BOX *pDstBox, - _In_ const void *pSrcData, - UINT SrcRowPitch, - UINT SrcDepthPitch); + DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( + ID3D12Device10 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12Resource, ReadFromSubresource) - HRESULT ( STDMETHODCALLTYPE *ReadFromSubresource )( - ID3D12Resource2 * This, - _Out_ void *pDstData, - UINT DstRowPitch, - UINT DstDepthPitch, - UINT SrcSubresource, - _In_opt_ const D3D12_BOX *pSrcBox); + DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( + ID3D12Device10 * This, + _In_opt_ ID3D12Resource *pTargetedResource, + _In_opt_ ID3D12Resource *pFeedbackResource, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - DECLSPEC_XFGVIRT(ID3D12Resource, GetHeapProperties) - HRESULT ( STDMETHODCALLTYPE *GetHeapProperties )( - ID3D12Resource2 * This, - _Out_opt_ D3D12_HEAP_PROPERTIES *pHeapProperties, - _Out_opt_ D3D12_HEAP_FLAGS *pHeapFlags); + DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1) + void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( + ID3D12Device10 * This, + _In_ const D3D12_RESOURCE_DESC1 *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); - DECLSPEC_XFGVIRT(ID3D12Resource1, GetProtectedResourceSession) - HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( - ID3D12Resource2 * This, + DECLSPEC_XFGVIRT(ID3D12Device9, CreateShaderCacheSession) + HRESULT ( STDMETHODCALLTYPE *CreateShaderCacheSession )( + ID3D12Device10 * This, + _In_ const D3D12_SHADER_CACHE_SESSION_DESC *pDesc, REFIID riid, - _COM_Outptr_opt_ void **ppProtectedSession); + _COM_Outptr_opt_ void **ppvSession); - DECLSPEC_XFGVIRT(ID3D12Resource2, GetDesc1) -#if !defined(_WIN32) - D3D12_RESOURCE_DESC1 ( STDMETHODCALLTYPE *GetDesc1 )( - ID3D12Resource2 * This); + DECLSPEC_XFGVIRT(ID3D12Device9, ShaderCacheControl) + HRESULT ( STDMETHODCALLTYPE *ShaderCacheControl )( + ID3D12Device10 * This, + D3D12_SHADER_CACHE_KIND_FLAGS Kinds, + D3D12_SHADER_CACHE_CONTROL_FLAGS Control); -#else - D3D12_RESOURCE_DESC1 *( STDMETHODCALLTYPE *GetDesc1 )( - ID3D12Resource2 * This, - D3D12_RESOURCE_DESC1 * RetVal); + DECLSPEC_XFGVIRT(ID3D12Device9, CreateCommandQueue1) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue1 )( + ID3D12Device10 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID CreatorID, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); -#endif + DECLSPEC_XFGVIRT(ID3D12Device10, CreateCommittedResource3) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource3 )( + ID3D12Device10 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device10, CreatePlacedResource2) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource2 )( + ID3D12Device10 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device10, CreateReservedResource2) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource2 )( + ID3D12Device10 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); END_INTERFACE - } ID3D12Resource2Vtbl; + } ID3D12Device10Vtbl; - interface ID3D12Resource2 + interface ID3D12Device10 { - CONST_VTBL struct ID3D12Resource2Vtbl *lpVtbl; + CONST_VTBL struct ID3D12Device10Vtbl *lpVtbl; }; @@ -18840,227 +24971,279 @@ EXTERN_C const IID IID_ID3D12Resource2; #ifdef COBJMACROS -#define ID3D12Resource2_QueryInterface(This,riid,ppvObject) \ +#define ID3D12Device10_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12Resource2_AddRef(This) \ +#define ID3D12Device10_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12Resource2_Release(This) \ +#define ID3D12Device10_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Resource2_GetPrivateData(This,guid,pDataSize,pData) \ +#define ID3D12Device10_GetPrivateData(This,guid,pDataSize,pData) \ ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12Resource2_SetPrivateData(This,guid,DataSize,pData) \ +#define ID3D12Device10_SetPrivateData(This,guid,DataSize,pData) \ ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12Resource2_SetPrivateDataInterface(This,guid,pData) \ +#define ID3D12Device10_SetPrivateDataInterface(This,guid,pData) \ ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12Resource2_SetName(This,Name) \ +#define ID3D12Device10_SetName(This,Name) \ ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12Resource2_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) +#define ID3D12Device10_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) + +#define ID3D12Device10_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) + +#define ID3D12Device10_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) + +#define ID3D12Device10_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device10_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device10_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) + +#define ID3D12Device10_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) + +#define ID3D12Device10_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) + +#define ID3D12Device10_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) + +#define ID3D12Device10_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) + +#define ID3D12Device10_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) + +#define ID3D12Device10_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device10_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) + +#define ID3D12Device10_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device10_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device10_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) + +#define ID3D12Device10_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) + +#define ID3D12Device10_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) +#if !defined(_WIN32) + +#define ID3D12Device10_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) +#else +#define ID3D12Device10_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) +#endif +#if !defined(_WIN32) + +#define ID3D12Device10_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) +#else +#define ID3D12Device10_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) +#endif + +#define ID3D12Device10_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) + +#define ID3D12Device10_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device10_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device10_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12Device10_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) +#define ID3D12Device10_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) -#define ID3D12Resource2_Map(This,Subresource,pReadRange,ppData) \ - ( (This)->lpVtbl -> Map(This,Subresource,pReadRange,ppData) ) +#define ID3D12Device10_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) -#define ID3D12Resource2_Unmap(This,Subresource,pWrittenRange) \ - ( (This)->lpVtbl -> Unmap(This,Subresource,pWrittenRange) ) -#if !defined(_WIN32) +#define ID3D12Device10_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) -#define ID3D12Resource2_GetDesc(This) \ - ( (This)->lpVtbl -> GetDesc(This) ) -#else -#define ID3D12Resource2_GetDesc(This,RetVal) \ - ( (This)->lpVtbl -> GetDesc(This,RetVal) ) -#endif +#define ID3D12Device10_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) -#define ID3D12Resource2_GetGPUVirtualAddress(This) \ - ( (This)->lpVtbl -> GetGPUVirtualAddress(This) ) +#define ID3D12Device10_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) -#define ID3D12Resource2_WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) \ - ( (This)->lpVtbl -> WriteToSubresource(This,DstSubresource,pDstBox,pSrcData,SrcRowPitch,SrcDepthPitch) ) +#define ID3D12Device10_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) -#define ID3D12Resource2_ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) \ - ( (This)->lpVtbl -> ReadFromSubresource(This,pDstData,DstRowPitch,DstDepthPitch,SrcSubresource,pSrcBox) ) +#define ID3D12Device10_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) -#define ID3D12Resource2_GetHeapProperties(This,pHeapProperties,pHeapFlags) \ - ( (This)->lpVtbl -> GetHeapProperties(This,pHeapProperties,pHeapFlags) ) +#define ID3D12Device10_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) +#define ID3D12Device10_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) -#define ID3D12Resource2_GetProtectedResourceSession(This,riid,ppProtectedSession) \ - ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) +#define ID3D12Device10_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) +#define ID3D12Device10_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) #if !defined(_WIN32) -#define ID3D12Resource2_GetDesc1(This) \ - ( (This)->lpVtbl -> GetDesc1(This) ) +#define ID3D12Device10_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) #else -#define ID3D12Resource2_GetDesc1(This,RetVal) \ - ( (This)->lpVtbl -> GetDesc1(This,RetVal) ) +#define ID3D12Device10_GetAdapterLuid(This,RetVal) \ + ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) #endif -#endif /* COBJMACROS */ +#define ID3D12Device10_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) -#endif /* C style interface */ +#define ID3D12Device10_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) +#define ID3D12Device10_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) +#define ID3D12Device10_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) -#endif /* __ID3D12Resource2_INTERFACE_DEFINED__ */ +#define ID3D12Device10_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) -#ifndef __ID3D12Heap1_INTERFACE_DEFINED__ -#define __ID3D12Heap1_INTERFACE_DEFINED__ +#define ID3D12Device10_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) -/* interface ID3D12Heap1 */ -/* [unique][local][object][uuid] */ +#define ID3D12Device10_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ + ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) -EXTERN_C const IID IID_ID3D12Heap1; +#define ID3D12Device10_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("572F7389-2168-49E3-9693-D6DF5871BF6D") - ID3D12Heap1 : public ID3D12Heap - { - public: - virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( - REFIID riid, - _COM_Outptr_opt_ void **ppProtectedSession) = 0; - - }; - - -#else /* C style interface */ +#define ID3D12Device10_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) - typedef struct ID3D12Heap1Vtbl - { - BEGIN_INTERFACE - - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Heap1 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Heap1 * This); - - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Heap1 * This); - - DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Heap1 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Heap1 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Heap1 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetName) - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Heap1 * This, - _In_z_ LPCWSTR Name); - - DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12Heap1 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - DECLSPEC_XFGVIRT(ID3D12Heap, GetDesc) +#define ID3D12Device10_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) + +#define ID3D12Device10_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) + +#define ID3D12Device10_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) #if !defined(_WIN32) - D3D12_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12Heap1 * This); - + +#define ID3D12Device10_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) #else - D3D12_HEAP_DESC *( STDMETHODCALLTYPE *GetDesc )( - ID3D12Heap1 * This, - D3D12_HEAP_DESC * RetVal); - +#define ID3D12Device10_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) #endif - - DECLSPEC_XFGVIRT(ID3D12Heap1, GetProtectedResourceSession) - HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( - ID3D12Heap1 * This, - REFIID riid, - _COM_Outptr_opt_ void **ppProtectedSession); - - END_INTERFACE - } ID3D12Heap1Vtbl; - interface ID3D12Heap1 - { - CONST_VTBL struct ID3D12Heap1Vtbl *lpVtbl; - }; - - -#ifdef COBJMACROS +#define ID3D12Device10_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ + ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) +#define ID3D12Device10_RemoveDevice(This) \ + ( (This)->lpVtbl -> RemoveDevice(This) ) -#define ID3D12Heap1_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) +#define ID3D12Device10_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) -#define ID3D12Heap1_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) +#define ID3D12Device10_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) -#define ID3D12Heap1_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) +#define ID3D12Device10_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ + ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) +#define ID3D12Device10_CreateStateObject(This,pDesc,riid,ppStateObject) \ + ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) -#define ID3D12Heap1_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) +#define ID3D12Device10_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ + ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) -#define ID3D12Heap1_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) +#define ID3D12Device10_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ + ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) -#define ID3D12Heap1_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12Heap1_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) +#define ID3D12Device10_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ + ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) -#define ID3D12Heap1_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) +#define ID3D12Device10_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) \ + ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) +#define ID3D12Device10_CreateProtectedResourceSession1(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) #if !defined(_WIN32) -#define ID3D12Heap1_GetDesc(This) \ - ( (This)->lpVtbl -> GetDesc(This) ) +#define ID3D12Device10_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) #else -#define ID3D12Heap1_GetDesc(This,RetVal) \ - ( (This)->lpVtbl -> GetDesc(This,RetVal) ) +#define ID3D12Device10_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) #endif +#define ID3D12Device10_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) + +#define ID3D12Device10_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device10_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) + +#define ID3D12Device10_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + + +#define ID3D12Device10_CreateShaderCacheSession(This,pDesc,riid,ppvSession) \ + ( (This)->lpVtbl -> CreateShaderCacheSession(This,pDesc,riid,ppvSession) ) + +#define ID3D12Device10_ShaderCacheControl(This,Kinds,Control) \ + ( (This)->lpVtbl -> ShaderCacheControl(This,Kinds,Control) ) + +#define ID3D12Device10_CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) ) + + +#define ID3D12Device10_CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) ) + +#define ID3D12Device10_CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) ) -#define ID3D12Heap1_GetProtectedResourceSession(This,riid,ppProtectedSession) \ - ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) +#define ID3D12Device10_CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) ) #endif /* COBJMACROS */ @@ -19070,1573 +25253,1752 @@ EXTERN_C const IID IID_ID3D12Heap1; -#endif /* __ID3D12Heap1_INTERFACE_DEFINED__ */ +#endif /* __ID3D12Device10_INTERFACE_DEFINED__ */ -#ifndef __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__ -#define __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__ +#ifndef __ID3D12Device11_INTERFACE_DEFINED__ +#define __ID3D12Device11_INTERFACE_DEFINED__ -/* interface ID3D12GraphicsCommandList3 */ +/* interface ID3D12Device11 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12GraphicsCommandList3; +EXTERN_C const IID IID_ID3D12Device11; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("6FDA83A7-B84C-4E38-9AC8-C7BD22016B3D") - ID3D12GraphicsCommandList3 : public ID3D12GraphicsCommandList2 + MIDL_INTERFACE("5405c344-d457-444e-b4dd-2366e45aee39") + ID3D12Device11 : public ID3D12Device10 { public: - virtual void STDMETHODCALLTYPE SetProtectedResourceSession( - _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0; + virtual void STDMETHODCALLTYPE CreateSampler2( + _In_ const D3D12_SAMPLER_DESC2 *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; }; #else /* C style interface */ - typedef struct ID3D12GraphicsCommandList3Vtbl + typedef struct ID3D12Device11Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12GraphicsCommandList3 * This, + ID3D12Device11 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12GraphicsCommandList3 * This); + ID3D12Device11 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12GraphicsCommandList3 * This); + ID3D12Device11 * This); DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12GraphicsCommandList3 * This, + ID3D12Device11 * This, _In_ REFGUID guid, _Inout_ UINT *pDataSize, _Out_writes_bytes_opt_( *pDataSize ) void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12GraphicsCommandList3 * This, + ID3D12Device11 * This, _In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_( DataSize ) const void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12GraphicsCommandList3 * This, + ID3D12Device11 * This, _In_ REFGUID guid, _In_opt_ const IUnknown *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetName) HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12GraphicsCommandList3 * This, + ID3D12Device11 * This, _In_z_ LPCWSTR Name); - DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12GraphicsCommandList3 * This, + DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device11 * This); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device11 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); + _COM_Outptr_ void **ppCommandQueue); - DECLSPEC_XFGVIRT(ID3D12CommandList, GetType) - D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( - ID3D12GraphicsCommandList3 * This); + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device11 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close) - HRESULT ( STDMETHODCALLTYPE *Close )( - ID3D12GraphicsCommandList3 * This); + DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device11 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset) - HRESULT ( STDMETHODCALLTYPE *Reset )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12CommandAllocator *pAllocator, - _In_opt_ ID3D12PipelineState *pInitialState); + DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device11 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState) - void ( STDMETHODCALLTYPE *ClearState )( - ID3D12GraphicsCommandList3 * This, - _In_opt_ ID3D12PipelineState *pPipelineState); + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device11 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced) - void ( STDMETHODCALLTYPE *DrawInstanced )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT VertexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartVertexLocation, - _In_ UINT StartInstanceLocation); + DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device11 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced) - void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT IndexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartIndexLocation, - _In_ INT BaseVertexLocation, - _In_ UINT StartInstanceLocation); + DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device11 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch) - void ( STDMETHODCALLTYPE *Dispatch )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT ThreadGroupCountX, - _In_ UINT ThreadGroupCountY, - _In_ UINT ThreadGroupCountZ); + DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device11 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion) - void ( STDMETHODCALLTYPE *CopyBufferRegion )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT64 NumBytes); + DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device11 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device11 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device11 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device11 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device11 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device11 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device11 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device11 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device11 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device11 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device11 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) +#if !defined(_WIN32) + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device11 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#else + D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device11 * This, + D3D12_HEAP_PROPERTIES * RetVal, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device11 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device11 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion) - void ( STDMETHODCALLTYPE *CopyTextureRegion )( - ID3D12GraphicsCommandList3 * This, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, - UINT DstX, - UINT DstY, - UINT DstZ, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, - _In_opt_ const D3D12_BOX *pSrcBox); + DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device11 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource) - void ( STDMETHODCALLTYPE *CopyResource )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pDstResource, - _In_ ID3D12Resource *pSrcResource); + DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device11 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles) - void ( STDMETHODCALLTYPE *CopyTiles )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pTiledResource, - _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, - _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, - _In_ ID3D12Resource *pBuffer, - UINT64 BufferStartOffsetInBytes, - D3D12_TILE_COPY_FLAGS Flags); + DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device11 * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource) - void ( STDMETHODCALLTYPE *ResolveSubresource )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_ DXGI_FORMAT Format); + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device11 * This, + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology) - void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( - ID3D12GraphicsCommandList3 * This, - _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device11 * This, + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports) - void ( STDMETHODCALLTYPE *RSSetViewports )( - ID3D12GraphicsCommandList3 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, - _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); + DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device11 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects) - void ( STDMETHODCALLTYPE *RSSetScissorRects )( - ID3D12GraphicsCommandList3 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, - _In_reads_( NumRects) const D3D12_RECT *pRects); + DECLSPEC_XFGVIRT(ID3D12Device, Evict) + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device11 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor) - void ( STDMETHODCALLTYPE *OMSetBlendFactor )( - ID3D12GraphicsCommandList3 * This, - _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); + DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device11 * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef) - void ( STDMETHODCALLTYPE *OMSetStencilRef )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT StencilRef); + DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device11 * This); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState) - void ( STDMETHODCALLTYPE *SetPipelineState )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12PipelineState *pPipelineState); + DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device11 * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier) - void ( STDMETHODCALLTYPE *ResourceBarrier )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT NumBarriers, - _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); + DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device11 * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle) - void ( STDMETHODCALLTYPE *ExecuteBundle )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12GraphicsCommandList *pCommandList); + DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device11 * This, + BOOL Enable); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps) - void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT NumDescriptorHeaps, - _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device11 * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature) - void ( STDMETHODCALLTYPE *SetComputeRootSignature )( - ID3D12GraphicsCommandList3 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device11 * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature) - void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( - ID3D12GraphicsCommandList3 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); + DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) +#if !defined(_WIN32) + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device11 * This); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable) - void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); +#else + LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device11 * This, + LUID * RetVal); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable) - void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); +#endif - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant) - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); + DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( + ID3D12Device11 * This, + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant) - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); + DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) + HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( + ID3D12Device11 * This, + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants) - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); + DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) + HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( + ID3D12Device11 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants) - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); + DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( + ID3D12Device11 * This, + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( + ID3D12Device11 * This, + _In_ const void *pAddress, + REFIID riid, + _COM_Outptr_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView) - void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( + ID3D12Device11 * This, + _In_ HANDLE hFileMapping, + REFIID riid, + _COM_Outptr_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView) - void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) + HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( + ID3D12Device11 * This, + D3D12_RESIDENCY_FLAGS Flags, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_ ID3D12Fence *pFenceToSignal, + UINT64 FenceValueToSignal); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView) - void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( + ID3D12Device11 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ D3D12_COMMAND_LIST_FLAGS flags, + REFIID riid, + _COM_Outptr_ void **ppCommandList); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView) - void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( + ID3D12Device11 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView) - void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( + ID3D12Device11 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView) - void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) + HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( + ID3D12Device11 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer) - void ( STDMETHODCALLTYPE *IASetIndexBuffer )( - ID3D12GraphicsCommandList3 * This, - _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( + ID3D12Device11 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers) - void ( STDMETHODCALLTYPE *IASetVertexBuffers )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); + DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device11 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets) - void ( STDMETHODCALLTYPE *SOSetTargets )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device11 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets) - void ( STDMETHODCALLTYPE *OMSetRenderTargets )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT NumRenderTargetDescriptors, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, - _In_ BOOL RTsSingleHandleToDescriptorRange, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); +#endif - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView) - void ( STDMETHODCALLTYPE *ClearDepthStencilView )( - ID3D12GraphicsCommandList3 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, - _In_ D3D12_CLEAR_FLAGS ClearFlags, - _In_ FLOAT Depth, - _In_ UINT8 Stencil, - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); + DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) + HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( + ID3D12Device11 * This, + _In_ ID3D12LifetimeOwner *pOwner, + REFIID riid, + _COM_Outptr_ void **ppvTracker); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView) - void ( STDMETHODCALLTYPE *ClearRenderTargetView )( - ID3D12GraphicsCommandList3 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, - _In_ const FLOAT ColorRGBA[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); + DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) + void ( STDMETHODCALLTYPE *RemoveDevice )( + ID3D12Device11 * This); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint) - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( - ID3D12GraphicsCommandList3 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const UINT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( + ID3D12Device11 * This, + _Inout_ UINT *pNumMetaCommands, + _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat) - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( - ID3D12GraphicsCommandList3 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const FLOAT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( + ID3D12Device11 * This, + _In_ REFGUID CommandId, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _Out_opt_ UINT *pTotalStructureSizeInBytes, + _Inout_ UINT *pParameterCount, + _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource) - void ( STDMETHODCALLTYPE *DiscardResource )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DISCARD_REGION *pRegion); + DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) + HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( + ID3D12Device11 * This, + _In_ REFGUID CommandId, + _In_ UINT NodeMask, + _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, + _In_ SIZE_T CreationParametersDataSizeInBytes, + REFIID riid, + _COM_Outptr_ void **ppMetaCommand); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery) - void ( STDMETHODCALLTYPE *BeginQuery )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); + DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) + HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( + ID3D12Device11 * This, + const D3D12_STATE_OBJECT_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppStateObject); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery) - void ( STDMETHODCALLTYPE *EndQuery )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); + DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) + void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( + ID3D12Device11 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, + _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData) - void ( STDMETHODCALLTYPE *ResolveQueryData )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT StartIndex, - _In_ UINT NumQueries, - _In_ ID3D12Resource *pDestinationBuffer, - _In_ UINT64 AlignedDestinationBufferOffset); + DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) + D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( + ID3D12Device11 * This, + _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, + _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication) - void ( STDMETHODCALLTYPE *SetPredication )( - ID3D12GraphicsCommandList3 * This, - _In_opt_ ID3D12Resource *pBuffer, - _In_ UINT64 AlignedBufferOffset, - _In_ D3D12_PREDICATION_OP Operation); + DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) + HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( + ID3D12Device11 * This, + D3D12_BACKGROUND_PROCESSING_MODE Mode, + D3D12_MEASUREMENTS_ACTION MeasurementsAction, + _In_opt_ HANDLE hEventToSignalUponCompletion, + _Out_opt_ BOOL *pbFurtherMeasurementsDesired); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker) - void ( STDMETHODCALLTYPE *SetMarker )( - ID3D12GraphicsCommandList3 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); + DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject) + HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( + ID3D12Device11 * This, + const D3D12_STATE_OBJECT_DESC *pAddition, + ID3D12StateObject *pStateObjectToGrowFrom, + REFIID riid, + _COM_Outptr_ void **ppNewStateObject); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent) - void ( STDMETHODCALLTYPE *BeginEvent )( - ID3D12GraphicsCommandList3 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); + DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( + ID3D12Device11 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent) - void ( STDMETHODCALLTYPE *EndEvent )( - ID3D12GraphicsCommandList3 * This); + DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( + ID3D12Device11 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect) - void ( STDMETHODCALLTYPE *ExecuteIndirect )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12CommandSignature *pCommandSignature, - _In_ UINT MaxCommandCount, - _In_ ID3D12Resource *pArgumentBuffer, - _In_ UINT64 ArgumentBufferOffset, - _In_opt_ ID3D12Resource *pCountBuffer, - _In_ UINT64 CountBufferOffset); +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( + ID3D12Device11 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT) - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); +#endif - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64) - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); + DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( + ID3D12Device11 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds) - void ( STDMETHODCALLTYPE *OMSetDepthBounds )( - ID3D12GraphicsCommandList3 * This, - _In_ FLOAT Min, - _In_ FLOAT Max); + DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( + ID3D12Device11 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions) - void ( STDMETHODCALLTYPE *SetSamplePositions )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT NumSamplesPerPixel, - _In_ UINT NumPixels, - _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); + DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( + ID3D12Device11 * This, + _In_opt_ ID3D12Resource *pTargetedResource, + _In_opt_ ID3D12Resource *pFeedbackResource, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion) - void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( - ID3D12GraphicsCommandList3 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ UINT DstX, - _In_ UINT DstY, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_opt_ D3D12_RECT *pSrcRect, - _In_ DXGI_FORMAT Format, - _In_ D3D12_RESOLVE_MODE ResolveMode); + DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1) + void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( + ID3D12Device11 * This, + _In_ const D3D12_RESOURCE_DESC1 *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask) - void ( STDMETHODCALLTYPE *SetViewInstanceMask )( - ID3D12GraphicsCommandList3 * This, - _In_ UINT Mask); + DECLSPEC_XFGVIRT(ID3D12Device9, CreateShaderCacheSession) + HRESULT ( STDMETHODCALLTYPE *CreateShaderCacheSession )( + ID3D12Device11 * This, + _In_ const D3D12_SHADER_CACHE_SESSION_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvSession); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate) - void ( STDMETHODCALLTYPE *WriteBufferImmediate )( - ID3D12GraphicsCommandList3 * This, - UINT Count, - _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, - _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); + DECLSPEC_XFGVIRT(ID3D12Device9, ShaderCacheControl) + HRESULT ( STDMETHODCALLTYPE *ShaderCacheControl )( + ID3D12Device11 * This, + D3D12_SHADER_CACHE_KIND_FLAGS Kinds, + D3D12_SHADER_CACHE_CONTROL_FLAGS Control); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession) - void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( - ID3D12GraphicsCommandList3 * This, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); + DECLSPEC_XFGVIRT(ID3D12Device9, CreateCommandQueue1) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue1 )( + ID3D12Device11 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID CreatorID, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); - END_INTERFACE - } ID3D12GraphicsCommandList3Vtbl; - - interface ID3D12GraphicsCommandList3 - { - CONST_VTBL struct ID3D12GraphicsCommandList3Vtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12GraphicsCommandList3_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12GraphicsCommandList3_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12GraphicsCommandList3_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12GraphicsCommandList3_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12GraphicsCommandList3_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) - -#define ID3D12GraphicsCommandList3_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) - -#define ID3D12GraphicsCommandList3_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) - - -#define ID3D12GraphicsCommandList3_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12GraphicsCommandList3_GetType(This) \ - ( (This)->lpVtbl -> GetType(This) ) - - -#define ID3D12GraphicsCommandList3_Close(This) \ - ( (This)->lpVtbl -> Close(This) ) - -#define ID3D12GraphicsCommandList3_Reset(This,pAllocator,pInitialState) \ - ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) - -#define ID3D12GraphicsCommandList3_ClearState(This,pPipelineState) \ - ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList3_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList3_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList3_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ - ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) - -#define ID3D12GraphicsCommandList3_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ - ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) - -#define ID3D12GraphicsCommandList3_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ - ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) - -#define ID3D12GraphicsCommandList3_CopyResource(This,pDstResource,pSrcResource) \ - ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) - -#define ID3D12GraphicsCommandList3_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ - ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) - -#define ID3D12GraphicsCommandList3_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ - ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) - -#define ID3D12GraphicsCommandList3_IASetPrimitiveTopology(This,PrimitiveTopology) \ - ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) - -#define ID3D12GraphicsCommandList3_RSSetViewports(This,NumViewports,pViewports) \ - ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) - -#define ID3D12GraphicsCommandList3_RSSetScissorRects(This,NumRects,pRects) \ - ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) - -#define ID3D12GraphicsCommandList3_OMSetBlendFactor(This,BlendFactor) \ - ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) - -#define ID3D12GraphicsCommandList3_OMSetStencilRef(This,StencilRef) \ - ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) - -#define ID3D12GraphicsCommandList3_SetPipelineState(This,pPipelineState) \ - ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) + DECLSPEC_XFGVIRT(ID3D12Device10, CreateCommittedResource3) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource3 )( + ID3D12Device11 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device10, CreatePlacedResource2) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource2 )( + ID3D12Device11 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device10, CreateReservedResource2) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource2 )( + ID3D12Device11 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device11, CreateSampler2) + void ( STDMETHODCALLTYPE *CreateSampler2 )( + ID3D12Device11 * This, + _In_ const D3D12_SAMPLER_DESC2 *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + END_INTERFACE + } ID3D12Device11Vtbl; -#define ID3D12GraphicsCommandList3_ResourceBarrier(This,NumBarriers,pBarriers) \ - ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) + interface ID3D12Device11 + { + CONST_VTBL struct ID3D12Device11Vtbl *lpVtbl; + }; -#define ID3D12GraphicsCommandList3_ExecuteBundle(This,pCommandList) \ - ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) + -#define ID3D12GraphicsCommandList3_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ - ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) +#ifdef COBJMACROS -#define ID3D12GraphicsCommandList3_SetComputeRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) -#define ID3D12GraphicsCommandList3_SetGraphicsRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) +#define ID3D12Device11_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12GraphicsCommandList3_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) +#define ID3D12Device11_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12GraphicsCommandList3_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) +#define ID3D12Device11_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) -#define ID3D12GraphicsCommandList3_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList3_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) +#define ID3D12Device11_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12GraphicsCommandList3_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) +#define ID3D12Device11_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12GraphicsCommandList3_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) +#define ID3D12Device11_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12GraphicsCommandList3_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) +#define ID3D12Device11_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12GraphicsCommandList3_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList3_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) +#define ID3D12Device11_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) -#define ID3D12GraphicsCommandList3_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) +#define ID3D12Device11_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) -#define ID3D12GraphicsCommandList3_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) +#define ID3D12Device11_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) -#define ID3D12GraphicsCommandList3_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) +#define ID3D12Device11_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12GraphicsCommandList3_IASetIndexBuffer(This,pView) \ - ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) +#define ID3D12Device11_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12GraphicsCommandList3_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) +#define ID3D12Device11_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) -#define ID3D12GraphicsCommandList3_SOSetTargets(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) +#define ID3D12Device11_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) -#define ID3D12GraphicsCommandList3_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ - ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) +#define ID3D12Device11_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) -#define ID3D12GraphicsCommandList3_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) +#define ID3D12Device11_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) -#define ID3D12GraphicsCommandList3_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) +#define ID3D12Device11_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) -#define ID3D12GraphicsCommandList3_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) +#define ID3D12Device11_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) -#define ID3D12GraphicsCommandList3_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) +#define ID3D12Device11_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12GraphicsCommandList3_DiscardResource(This,pResource,pRegion) \ - ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) +#define ID3D12Device11_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) -#define ID3D12GraphicsCommandList3_BeginQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) +#define ID3D12Device11_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12GraphicsCommandList3_EndQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) +#define ID3D12Device11_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12GraphicsCommandList3_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ - ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) +#define ID3D12Device11_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) -#define ID3D12GraphicsCommandList3_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ - ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) +#define ID3D12Device11_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) -#define ID3D12GraphicsCommandList3_SetMarker(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) +#define ID3D12Device11_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) +#if !defined(_WIN32) -#define ID3D12GraphicsCommandList3_BeginEvent(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) +#define ID3D12Device11_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) +#else +#define ID3D12Device11_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) +#endif +#if !defined(_WIN32) -#define ID3D12GraphicsCommandList3_EndEvent(This) \ - ( (This)->lpVtbl -> EndEvent(This) ) +#define ID3D12Device11_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) +#else +#define ID3D12Device11_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) +#endif -#define ID3D12GraphicsCommandList3_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ - ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) +#define ID3D12Device11_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) +#define ID3D12Device11_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) -#define ID3D12GraphicsCommandList3_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) +#define ID3D12Device11_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) -#define ID3D12GraphicsCommandList3_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) +#define ID3D12Device11_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) -#define ID3D12GraphicsCommandList3_OMSetDepthBounds(This,Min,Max) \ - ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) +#define ID3D12Device11_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) -#define ID3D12GraphicsCommandList3_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ - ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) +#define ID3D12Device11_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) -#define ID3D12GraphicsCommandList3_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ - ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) +#define ID3D12Device11_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) -#define ID3D12GraphicsCommandList3_SetViewInstanceMask(This,Mask) \ - ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) +#define ID3D12Device11_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) +#define ID3D12Device11_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) -#define ID3D12GraphicsCommandList3_WriteBufferImmediate(This,Count,pParams,pModes) \ - ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) +#define ID3D12Device11_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) +#define ID3D12Device11_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) -#define ID3D12GraphicsCommandList3_SetProtectedResourceSession(This,pProtectedResourceSession) \ - ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) +#define ID3D12Device11_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) -#endif /* COBJMACROS */ +#define ID3D12Device11_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) +#define ID3D12Device11_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) -#endif /* C style interface */ +#define ID3D12Device11_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) +#define ID3D12Device11_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) +#if !defined(_WIN32) +#define ID3D12Device11_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) +#else +#define ID3D12Device11_GetAdapterLuid(This,RetVal) \ + ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) +#endif -#endif /* __ID3D12GraphicsCommandList3_INTERFACE_DEFINED__ */ +#define ID3D12Device11_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) +#define ID3D12Device11_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) -/* interface __MIDL_itf_d3d12_0000_0049 */ -/* [local] */ +#define ID3D12Device11_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) -typedef -enum D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE - { - D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD = 0, - D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD + 1 ) , - D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE + 1 ) , - D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS = ( D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR + 1 ) - } D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE; -typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS - { - D3D12_CLEAR_VALUE ClearValue; - } D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS; +#define ID3D12Device11_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) -typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS - { - D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE Type; - union - { - D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS Clear; - } ; - } D3D12_RENDER_PASS_BEGINNING_ACCESS; -typedef -enum D3D12_RENDER_PASS_ENDING_ACCESS_TYPE - { - D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD = 0, - D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD + 1 ) , - D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE + 1 ) , - D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS = ( D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE + 1 ) - } D3D12_RENDER_PASS_ENDING_ACCESS_TYPE; +#define ID3D12Device11_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) -typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS - { - UINT SrcSubresource; - UINT DstSubresource; - UINT DstX; - UINT DstY; - D3D12_RECT SrcRect; - } D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS; +#define ID3D12Device11_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) -typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS - { - ID3D12Resource *pSrcResource; - ID3D12Resource *pDstResource; - UINT SubresourceCount; - _Field_size_full_(SubresourceCount) const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS *pSubresourceParameters; - DXGI_FORMAT Format; - D3D12_RESOLVE_MODE ResolveMode; - BOOL PreserveResolveSource; - } D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS; +#define ID3D12Device11_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ + ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) -typedef struct D3D12_RENDER_PASS_ENDING_ACCESS - { - D3D12_RENDER_PASS_ENDING_ACCESS_TYPE Type; - union - { - D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS Resolve; - } ; - } D3D12_RENDER_PASS_ENDING_ACCESS; -typedef struct D3D12_RENDER_PASS_RENDER_TARGET_DESC - { - D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor; - D3D12_RENDER_PASS_BEGINNING_ACCESS BeginningAccess; - D3D12_RENDER_PASS_ENDING_ACCESS EndingAccess; - } D3D12_RENDER_PASS_RENDER_TARGET_DESC; +#define ID3D12Device11_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) -typedef struct D3D12_RENDER_PASS_DEPTH_STENCIL_DESC - { - D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor; - D3D12_RENDER_PASS_BEGINNING_ACCESS DepthBeginningAccess; - D3D12_RENDER_PASS_BEGINNING_ACCESS StencilBeginningAccess; - D3D12_RENDER_PASS_ENDING_ACCESS DepthEndingAccess; - D3D12_RENDER_PASS_ENDING_ACCESS StencilEndingAccess; - } D3D12_RENDER_PASS_DEPTH_STENCIL_DESC; +#define ID3D12Device11_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) -typedef -enum D3D12_RENDER_PASS_FLAGS - { - D3D12_RENDER_PASS_FLAG_NONE = 0, - D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES = 0x1, - D3D12_RENDER_PASS_FLAG_SUSPENDING_PASS = 0x2, - D3D12_RENDER_PASS_FLAG_RESUMING_PASS = 0x4 - } D3D12_RENDER_PASS_FLAGS; +#define ID3D12Device11_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) -DEFINE_ENUM_FLAG_OPERATORS( D3D12_RENDER_PASS_FLAGS ); +#define ID3D12Device11_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) +#define ID3D12Device11_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) +#if !defined(_WIN32) -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0049_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0049_v0_0_s_ifspec; +#define ID3D12Device11_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device11_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif -#ifndef __ID3D12MetaCommand_INTERFACE_DEFINED__ -#define __ID3D12MetaCommand_INTERFACE_DEFINED__ -/* interface ID3D12MetaCommand */ -/* [unique][local][object][uuid] */ +#define ID3D12Device11_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ + ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) +#define ID3D12Device11_RemoveDevice(This) \ + ( (This)->lpVtbl -> RemoveDevice(This) ) -EXTERN_C const IID IID_ID3D12MetaCommand; +#define ID3D12Device11_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("DBB84C27-36CE-4FC9-B801-F048C46AC570") - ID3D12MetaCommand : public ID3D12Pageable - { - public: - virtual UINT64 STDMETHODCALLTYPE GetRequiredParameterResourceSize( - _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, - _In_ UINT ParameterIndex) = 0; - - }; - - -#else /* C style interface */ +#define ID3D12Device11_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) - typedef struct ID3D12MetaCommandVtbl - { - BEGIN_INTERFACE - - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12MetaCommand * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12MetaCommand * This); - - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12MetaCommand * This); - - DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12MetaCommand * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12MetaCommand * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12MetaCommand * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetName) - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12MetaCommand * This, - _In_z_ LPCWSTR Name); - - DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12MetaCommand * This, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - DECLSPEC_XFGVIRT(ID3D12MetaCommand, GetRequiredParameterResourceSize) - UINT64 ( STDMETHODCALLTYPE *GetRequiredParameterResourceSize )( - ID3D12MetaCommand * This, - _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, - _In_ UINT ParameterIndex); - - END_INTERFACE - } ID3D12MetaCommandVtbl; +#define ID3D12Device11_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ + ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) - interface ID3D12MetaCommand - { - CONST_VTBL struct ID3D12MetaCommandVtbl *lpVtbl; - }; +#define ID3D12Device11_CreateStateObject(This,pDesc,riid,ppStateObject) \ + ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) - +#define ID3D12Device11_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ + ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) -#ifdef COBJMACROS +#define ID3D12Device11_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ + ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) -#define ID3D12MetaCommand_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) +#define ID3D12Device11_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ + ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) -#define ID3D12MetaCommand_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12MetaCommand_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) +#define ID3D12Device11_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) \ + ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) +#define ID3D12Device11_CreateProtectedResourceSession1(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) -#define ID3D12MetaCommand_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) +#if !defined(_WIN32) -#define ID3D12MetaCommand_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) +#define ID3D12Device11_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device11_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif -#define ID3D12MetaCommand_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) +#define ID3D12Device11_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) -#define ID3D12MetaCommand_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) +#define ID3D12Device11_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12Device11_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) -#define ID3D12MetaCommand_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) +#define ID3D12Device11_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) +#define ID3D12Device11_CreateShaderCacheSession(This,pDesc,riid,ppvSession) \ + ( (This)->lpVtbl -> CreateShaderCacheSession(This,pDesc,riid,ppvSession) ) -#define ID3D12MetaCommand_GetRequiredParameterResourceSize(This,Stage,ParameterIndex) \ - ( (This)->lpVtbl -> GetRequiredParameterResourceSize(This,Stage,ParameterIndex) ) +#define ID3D12Device11_ShaderCacheControl(This,Kinds,Control) \ + ( (This)->lpVtbl -> ShaderCacheControl(This,Kinds,Control) ) -#endif /* COBJMACROS */ +#define ID3D12Device11_CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) ) -#endif /* C style interface */ +#define ID3D12Device11_CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) ) +#define ID3D12Device11_CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) ) +#define ID3D12Device11_CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) ) -#endif /* __ID3D12MetaCommand_INTERFACE_DEFINED__ */ +#define ID3D12Device11_CreateSampler2(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler2(This,pDesc,DestDescriptor) ) +#endif /* COBJMACROS */ -/* interface __MIDL_itf_d3d12_0000_0050 */ -/* [local] */ -typedef struct D3D12_DISPATCH_RAYS_DESC - { - D3D12_GPU_VIRTUAL_ADDRESS_RANGE RayGenerationShaderRecord; - D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE MissShaderTable; - D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE HitGroupTable; - D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE CallableShaderTable; - UINT Width; - UINT Height; - UINT Depth; - } D3D12_DISPATCH_RAYS_DESC; +#endif /* C style interface */ + -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0050_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0050_v0_0_s_ifspec; +#endif /* __ID3D12Device11_INTERFACE_DEFINED__ */ + -#ifndef __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__ -#define __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__ +#ifndef __ID3D12Device12_INTERFACE_DEFINED__ +#define __ID3D12Device12_INTERFACE_DEFINED__ -/* interface ID3D12GraphicsCommandList4 */ +/* interface ID3D12Device12 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12GraphicsCommandList4; +EXTERN_C const IID IID_ID3D12Device12; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("8754318e-d3a9-4541-98cf-645b50dc4874") - ID3D12GraphicsCommandList4 : public ID3D12GraphicsCommandList3 + MIDL_INTERFACE("5af5c532-4c91-4cd0-b541-15a405395fc5") + ID3D12Device12 : public ID3D12Device11 { public: - virtual void STDMETHODCALLTYPE BeginRenderPass( - _In_ UINT NumRenderTargets, - _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, - _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, - D3D12_RENDER_PASS_FLAGS Flags) = 0; - - virtual void STDMETHODCALLTYPE EndRenderPass( void) = 0; - - virtual void STDMETHODCALLTYPE InitializeMetaCommand( - _In_ ID3D12MetaCommand *pMetaCommand, - _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, - _In_ SIZE_T InitializationParametersDataSizeInBytes) = 0; - - virtual void STDMETHODCALLTYPE ExecuteMetaCommand( - _In_ ID3D12MetaCommand *pMetaCommand, - _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, - _In_ SIZE_T ExecutionParametersDataSizeInBytes) = 0; - - virtual void STDMETHODCALLTYPE BuildRaytracingAccelerationStructure( - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, - _In_ UINT NumPostbuildInfoDescs, - _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs) = 0; - - virtual void STDMETHODCALLTYPE EmitRaytracingAccelerationStructurePostbuildInfo( - _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, - _In_ UINT NumSourceAccelerationStructures, - _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData) = 0; - - virtual void STDMETHODCALLTYPE CopyRaytracingAccelerationStructure( - _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, - _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, - _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode) = 0; - - virtual void STDMETHODCALLTYPE SetPipelineState1( - _In_ ID3D12StateObject *pStateObject) = 0; - - virtual void STDMETHODCALLTYPE DispatchRays( - _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc) = 0; +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) + virtual D3D12_RESOURCE_ALLOCATION_INFO STDMETHODCALLTYPE GetResourceAllocationInfo3( + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _In_opt_count_(numResourceDescs) const UINT32 *pNumCastableFormats, + _In_opt_count_(numResourceDescs) const DXGI_FORMAT *const *ppCastableFormats, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1) = 0; +#else + virtual D3D12_RESOURCE_ALLOCATION_INFO *STDMETHODCALLTYPE GetResourceAllocationInfo3( + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _In_opt_count_(numResourceDescs) const UINT32 *pNumCastableFormats, + _In_opt_count_(numResourceDescs) const DXGI_FORMAT *const *ppCastableFormats, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1) = 0; +#endif }; #else /* C style interface */ - typedef struct ID3D12GraphicsCommandList4Vtbl + typedef struct ID3D12Device12Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12GraphicsCommandList4 * This, + ID3D12Device12 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12GraphicsCommandList4 * This); + ID3D12Device12 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12GraphicsCommandList4 * This); + ID3D12Device12 * This); DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12GraphicsCommandList4 * This, + ID3D12Device12 * This, _In_ REFGUID guid, _Inout_ UINT *pDataSize, _Out_writes_bytes_opt_( *pDataSize ) void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12GraphicsCommandList4 * This, + ID3D12Device12 * This, _In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_( DataSize ) const void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12GraphicsCommandList4 * This, + ID3D12Device12 * This, _In_ REFGUID guid, _In_opt_ const IUnknown *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetName) HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12GraphicsCommandList4 * This, + ID3D12Device12 * This, _In_z_ LPCWSTR Name); - DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12GraphicsCommandList4 * This, + DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device12 * This); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device12 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); + _COM_Outptr_ void **ppCommandQueue); - DECLSPEC_XFGVIRT(ID3D12CommandList, GetType) - D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( - ID3D12GraphicsCommandList4 * This); + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device12 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close) - HRESULT ( STDMETHODCALLTYPE *Close )( - ID3D12GraphicsCommandList4 * This); + DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device12 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset) - HRESULT ( STDMETHODCALLTYPE *Reset )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12CommandAllocator *pAllocator, - _In_opt_ ID3D12PipelineState *pInitialState); + DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device12 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState) - void ( STDMETHODCALLTYPE *ClearState )( - ID3D12GraphicsCommandList4 * This, - _In_opt_ ID3D12PipelineState *pPipelineState); + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device12 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced) - void ( STDMETHODCALLTYPE *DrawInstanced )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT VertexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartVertexLocation, - _In_ UINT StartInstanceLocation); + DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device12 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced) - void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT IndexCountPerInstance, - _In_ UINT InstanceCount, - _In_ UINT StartIndexLocation, - _In_ INT BaseVertexLocation, - _In_ UINT StartInstanceLocation); + DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device12 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch) - void ( STDMETHODCALLTYPE *Dispatch )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT ThreadGroupCountX, - _In_ UINT ThreadGroupCountY, - _In_ UINT ThreadGroupCountZ); + DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device12 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion) - void ( STDMETHODCALLTYPE *CopyBufferRegion )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT64 NumBytes); + DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device12 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion) - void ( STDMETHODCALLTYPE *CopyTextureRegion )( - ID3D12GraphicsCommandList4 * This, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, - UINT DstX, - UINT DstY, - UINT DstZ, - _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, - _In_opt_ const D3D12_BOX *pSrcBox); + DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device12 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device12 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device12 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device12 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device12 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device12 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device12 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device12 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device12 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device12 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) +#if !defined(_WIN32) + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device12 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#else + D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device12 * This, + D3D12_HEAP_PROPERTIES * RetVal, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device12 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource) - void ( STDMETHODCALLTYPE *CopyResource )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pDstResource, - _In_ ID3D12Resource *pSrcResource); + DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device12 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles) - void ( STDMETHODCALLTYPE *CopyTiles )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pTiledResource, - _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, - _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, - _In_ ID3D12Resource *pBuffer, - UINT64 BufferStartOffsetInBytes, - D3D12_TILE_COPY_FLAGS Flags); + DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device12 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource) - void ( STDMETHODCALLTYPE *ResolveSubresource )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_ DXGI_FORMAT Format); + DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device12 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology) - void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( - ID3D12GraphicsCommandList4 * This, - _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); + DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device12 * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports) - void ( STDMETHODCALLTYPE *RSSetViewports )( - ID3D12GraphicsCommandList4 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, - _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device12 * This, + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects) - void ( STDMETHODCALLTYPE *RSSetScissorRects )( - ID3D12GraphicsCommandList4 * This, - _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, - _In_reads_( NumRects) const D3D12_RECT *pRects); + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device12 * This, + _In_ LPCWSTR Name, + DWORD Access, + /* [annotation][out] */ + _Out_ HANDLE *pNTHandle); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor) - void ( STDMETHODCALLTYPE *OMSetBlendFactor )( - ID3D12GraphicsCommandList4 * This, - _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); + DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device12 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef) - void ( STDMETHODCALLTYPE *OMSetStencilRef )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT StencilRef); + DECLSPEC_XFGVIRT(ID3D12Device, Evict) + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device12 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState) - void ( STDMETHODCALLTYPE *SetPipelineState )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12PipelineState *pPipelineState); + DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device12 * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier) - void ( STDMETHODCALLTYPE *ResourceBarrier )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT NumBarriers, - _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); + DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device12 * This); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle) - void ( STDMETHODCALLTYPE *ExecuteBundle )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12GraphicsCommandList *pCommandList); + DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device12 * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps) - void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT NumDescriptorHeaps, - _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); + DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device12 * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature) - void ( STDMETHODCALLTYPE *SetComputeRootSignature )( - ID3D12GraphicsCommandList4 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); + DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device12 * This, + BOOL Enable); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature) - void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( - ID3D12GraphicsCommandList4 * This, - _In_opt_ ID3D12RootSignature *pRootSignature); + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device12 * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable) - void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device12 * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable) - void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) +#if !defined(_WIN32) + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device12 * This); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant) - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); +#else + LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device12 * This, + LUID * RetVal); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant) - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ UINT SrcData, - _In_ UINT DestOffsetIn32BitValues); +#endif - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants) - void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); + DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( + ID3D12Device12 * This, + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants) - void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ UINT Num32BitValuesToSet, - _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, - _In_ UINT DestOffsetIn32BitValues); + DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) + HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( + ID3D12Device12 * This, + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView) - void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) + HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( + ID3D12Device12 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView) - void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( + ID3D12Device12 * This, + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView) - void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( + ID3D12Device12 * This, + _In_ const void *pAddress, + REFIID riid, + _COM_Outptr_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView) - void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( + ID3D12Device12 * This, + _In_ HANDLE hFileMapping, + REFIID riid, + _COM_Outptr_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView) - void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) + HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( + ID3D12Device12 * This, + D3D12_RESIDENCY_FLAGS Flags, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_ ID3D12Fence *pFenceToSignal, + UINT64 FenceValueToSignal); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView) - void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT RootParameterIndex, - _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( + ID3D12Device12 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ D3D12_COMMAND_LIST_FLAGS flags, + REFIID riid, + _COM_Outptr_ void **ppCommandList); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer) - void ( STDMETHODCALLTYPE *IASetIndexBuffer )( - ID3D12GraphicsCommandList4 * This, - _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( + ID3D12Device12 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers) - void ( STDMETHODCALLTYPE *IASetVertexBuffers )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( + ID3D12Device12 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets) - void ( STDMETHODCALLTYPE *SOSetTargets )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT StartSlot, - _In_ UINT NumViews, - _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) + HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( + ID3D12Device12 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets) - void ( STDMETHODCALLTYPE *OMSetRenderTargets )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT NumRenderTargetDescriptors, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, - _In_ BOOL RTsSingleHandleToDescriptorRange, - _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); + DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( + ID3D12Device12 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView) - void ( STDMETHODCALLTYPE *ClearDepthStencilView )( - ID3D12GraphicsCommandList4 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, - _In_ D3D12_CLEAR_FLAGS ClearFlags, - _In_ FLOAT Depth, - _In_ UINT8 Stencil, - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); + DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device12 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView) - void ( STDMETHODCALLTYPE *ClearRenderTargetView )( - ID3D12GraphicsCommandList4 * This, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, - _In_ const FLOAT ColorRGBA[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device12 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint) - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( - ID3D12GraphicsCommandList4 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const UINT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); +#endif - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat) - void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( - ID3D12GraphicsCommandList4 * This, - _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, - _In_ ID3D12Resource *pResource, - _In_ const FLOAT Values[ 4 ], - _In_ UINT NumRects, - _In_reads_(NumRects) const D3D12_RECT *pRects); + DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) + HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( + ID3D12Device12 * This, + _In_ ID3D12LifetimeOwner *pOwner, + REFIID riid, + _COM_Outptr_ void **ppvTracker); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource) - void ( STDMETHODCALLTYPE *DiscardResource )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DISCARD_REGION *pRegion); + DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) + void ( STDMETHODCALLTYPE *RemoveDevice )( + ID3D12Device12 * This); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery) - void ( STDMETHODCALLTYPE *BeginQuery )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( + ID3D12Device12 * This, + _Inout_ UINT *pNumMetaCommands, + _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery) - void ( STDMETHODCALLTYPE *EndQuery )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT Index); + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( + ID3D12Device12 * This, + _In_ REFGUID CommandId, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _Out_opt_ UINT *pTotalStructureSizeInBytes, + _Inout_ UINT *pParameterCount, + _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData) - void ( STDMETHODCALLTYPE *ResolveQueryData )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12QueryHeap *pQueryHeap, - _In_ D3D12_QUERY_TYPE Type, - _In_ UINT StartIndex, - _In_ UINT NumQueries, - _In_ ID3D12Resource *pDestinationBuffer, - _In_ UINT64 AlignedDestinationBufferOffset); + DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) + HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( + ID3D12Device12 * This, + _In_ REFGUID CommandId, + _In_ UINT NodeMask, + _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, + _In_ SIZE_T CreationParametersDataSizeInBytes, + REFIID riid, + _COM_Outptr_ void **ppMetaCommand); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication) - void ( STDMETHODCALLTYPE *SetPredication )( - ID3D12GraphicsCommandList4 * This, - _In_opt_ ID3D12Resource *pBuffer, - _In_ UINT64 AlignedBufferOffset, - _In_ D3D12_PREDICATION_OP Operation); + DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) + HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( + ID3D12Device12 * This, + const D3D12_STATE_OBJECT_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppStateObject); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker) - void ( STDMETHODCALLTYPE *SetMarker )( - ID3D12GraphicsCommandList4 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); + DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) + void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( + ID3D12Device12 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, + _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent) - void ( STDMETHODCALLTYPE *BeginEvent )( - ID3D12GraphicsCommandList4 * This, - UINT Metadata, - _In_reads_bytes_opt_(Size) const void *pData, - UINT Size); + DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) + D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( + ID3D12Device12 * This, + _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, + _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent) - void ( STDMETHODCALLTYPE *EndEvent )( - ID3D12GraphicsCommandList4 * This); + DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) + HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( + ID3D12Device12 * This, + D3D12_BACKGROUND_PROCESSING_MODE Mode, + D3D12_MEASUREMENTS_ACTION MeasurementsAction, + _In_opt_ HANDLE hEventToSignalUponCompletion, + _Out_opt_ BOOL *pbFurtherMeasurementsDesired); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect) - void ( STDMETHODCALLTYPE *ExecuteIndirect )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12CommandSignature *pCommandSignature, - _In_ UINT MaxCommandCount, - _In_ ID3D12Resource *pArgumentBuffer, - _In_ UINT64 ArgumentBufferOffset, - _In_opt_ ID3D12Resource *pCountBuffer, - _In_ UINT64 CountBufferOffset); + DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject) + HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( + ID3D12Device12 * This, + const D3D12_STATE_OBJECT_DESC *pAddition, + ID3D12StateObject *pStateObjectToGrowFrom, + REFIID riid, + _COM_Outptr_ void **ppNewStateObject); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT) - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); + DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( + ID3D12Device12 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); + + DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( + ID3D12Device12 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64) - void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pDstBuffer, - UINT64 DstOffset, - _In_ ID3D12Resource *pSrcBuffer, - UINT64 SrcOffset, - UINT Dependencies, - _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, - _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( + ID3D12Device12 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds) - void ( STDMETHODCALLTYPE *OMSetDepthBounds )( - ID3D12GraphicsCommandList4 * This, - _In_ FLOAT Min, - _In_ FLOAT Max); +#endif - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions) - void ( STDMETHODCALLTYPE *SetSamplePositions )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT NumSamplesPerPixel, - _In_ UINT NumPixels, - _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); + DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( + ID3D12Device12 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion) - void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12Resource *pDstResource, - _In_ UINT DstSubresource, - _In_ UINT DstX, - _In_ UINT DstY, - _In_ ID3D12Resource *pSrcResource, - _In_ UINT SrcSubresource, - _In_opt_ D3D12_RECT *pSrcRect, - _In_ DXGI_FORMAT Format, - _In_ D3D12_RESOLVE_MODE ResolveMode); + DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( + ID3D12Device12 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask) - void ( STDMETHODCALLTYPE *SetViewInstanceMask )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT Mask); + DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( + ID3D12Device12 * This, + _In_opt_ ID3D12Resource *pTargetedResource, + _In_opt_ ID3D12Resource *pFeedbackResource, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate) - void ( STDMETHODCALLTYPE *WriteBufferImmediate )( - ID3D12GraphicsCommandList4 * This, - UINT Count, - _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, - _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); + DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1) + void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( + ID3D12Device12 * This, + _In_ const D3D12_RESOURCE_DESC1 *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession) - void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( - ID3D12GraphicsCommandList4 * This, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); + DECLSPEC_XFGVIRT(ID3D12Device9, CreateShaderCacheSession) + HRESULT ( STDMETHODCALLTYPE *CreateShaderCacheSession )( + ID3D12Device12 * This, + _In_ const D3D12_SHADER_CACHE_SESSION_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvSession); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BeginRenderPass) - void ( STDMETHODCALLTYPE *BeginRenderPass )( - ID3D12GraphicsCommandList4 * This, - _In_ UINT NumRenderTargets, - _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, - _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, - D3D12_RENDER_PASS_FLAGS Flags); + DECLSPEC_XFGVIRT(ID3D12Device9, ShaderCacheControl) + HRESULT ( STDMETHODCALLTYPE *ShaderCacheControl )( + ID3D12Device12 * This, + D3D12_SHADER_CACHE_KIND_FLAGS Kinds, + D3D12_SHADER_CACHE_CONTROL_FLAGS Control); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EndRenderPass) - void ( STDMETHODCALLTYPE *EndRenderPass )( - ID3D12GraphicsCommandList4 * This); + DECLSPEC_XFGVIRT(ID3D12Device9, CreateCommandQueue1) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue1 )( + ID3D12Device12 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID CreatorID, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, InitializeMetaCommand) - void ( STDMETHODCALLTYPE *InitializeMetaCommand )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12MetaCommand *pMetaCommand, - _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, - _In_ SIZE_T InitializationParametersDataSizeInBytes); + DECLSPEC_XFGVIRT(ID3D12Device10, CreateCommittedResource3) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource3 )( + ID3D12Device12 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, ExecuteMetaCommand) - void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12MetaCommand *pMetaCommand, - _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, - _In_ SIZE_T ExecutionParametersDataSizeInBytes); + DECLSPEC_XFGVIRT(ID3D12Device10, CreatePlacedResource2) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource2 )( + ID3D12Device12 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BuildRaytracingAccelerationStructure) - void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList4 * This, - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, - _In_ UINT NumPostbuildInfoDescs, - _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs); + DECLSPEC_XFGVIRT(ID3D12Device10, CreateReservedResource2) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource2 )( + ID3D12Device12 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EmitRaytracingAccelerationStructurePostbuildInfo) - void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( - ID3D12GraphicsCommandList4 * This, - _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, - _In_ UINT NumSourceAccelerationStructures, - _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData); + DECLSPEC_XFGVIRT(ID3D12Device11, CreateSampler2) + void ( STDMETHODCALLTYPE *CreateSampler2 )( + ID3D12Device12 * This, + _In_ const D3D12_SAMPLER_DESC2 *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, CopyRaytracingAccelerationStructure) - void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList4 * This, - _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, - _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, - _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode); + DECLSPEC_XFGVIRT(ID3D12Device12, GetResourceAllocationInfo3) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo3 )( + ID3D12Device12 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _In_opt_count_(numResourceDescs) const UINT32 *pNumCastableFormats, + _In_opt_count_(numResourceDescs) const DXGI_FORMAT *const *ppCastableFormats, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, SetPipelineState1) - void ( STDMETHODCALLTYPE *SetPipelineState1 )( - ID3D12GraphicsCommandList4 * This, - _In_ ID3D12StateObject *pStateObject); +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo3 )( + ID3D12Device12 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _In_opt_count_(numResourceDescs) const UINT32 *pNumCastableFormats, + _In_opt_count_(numResourceDescs) const DXGI_FORMAT *const *ppCastableFormats, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, DispatchRays) - void ( STDMETHODCALLTYPE *DispatchRays )( - ID3D12GraphicsCommandList4 * This, - _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc); +#endif END_INTERFACE - } ID3D12GraphicsCommandList4Vtbl; + } ID3D12Device12Vtbl; - interface ID3D12GraphicsCommandList4 + interface ID3D12Device12 { - CONST_VTBL struct ID3D12GraphicsCommandList4Vtbl *lpVtbl; + CONST_VTBL struct ID3D12Device12Vtbl *lpVtbl; }; @@ -20644,597 +27006,1042 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList4; #ifdef COBJMACROS -#define ID3D12GraphicsCommandList4_QueryInterface(This,riid,ppvObject) \ +#define ID3D12Device12_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12GraphicsCommandList4_AddRef(This) \ +#define ID3D12Device12_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12GraphicsCommandList4_Release(This) \ +#define ID3D12Device12_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12GraphicsCommandList4_GetPrivateData(This,guid,pDataSize,pData) \ +#define ID3D12Device12_GetPrivateData(This,guid,pDataSize,pData) \ ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12GraphicsCommandList4_SetPrivateData(This,guid,DataSize,pData) \ +#define ID3D12Device12_SetPrivateData(This,guid,DataSize,pData) \ ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12GraphicsCommandList4_SetPrivateDataInterface(This,guid,pData) \ +#define ID3D12Device12_SetPrivateDataInterface(This,guid,pData) \ ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12GraphicsCommandList4_SetName(This,Name) \ +#define ID3D12Device12_SetName(This,Name) \ ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12GraphicsCommandList4_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) - - -#define ID3D12GraphicsCommandList4_GetType(This) \ - ( (This)->lpVtbl -> GetType(This) ) - - -#define ID3D12GraphicsCommandList4_Close(This) \ - ( (This)->lpVtbl -> Close(This) ) - -#define ID3D12GraphicsCommandList4_Reset(This,pAllocator,pInitialState) \ - ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) - -#define ID3D12GraphicsCommandList4_ClearState(This,pPipelineState) \ - ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) - -#define ID3D12GraphicsCommandList4_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList4_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ - ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) - -#define ID3D12GraphicsCommandList4_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ - ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) - -#define ID3D12GraphicsCommandList4_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ - ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) - -#define ID3D12GraphicsCommandList4_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ - ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) - -#define ID3D12GraphicsCommandList4_CopyResource(This,pDstResource,pSrcResource) \ - ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) - -#define ID3D12GraphicsCommandList4_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ - ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) - -#define ID3D12GraphicsCommandList4_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ - ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) - -#define ID3D12GraphicsCommandList4_IASetPrimitiveTopology(This,PrimitiveTopology) \ - ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) - -#define ID3D12GraphicsCommandList4_RSSetViewports(This,NumViewports,pViewports) \ - ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) +#define ID3D12Device12_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) -#define ID3D12GraphicsCommandList4_RSSetScissorRects(This,NumRects,pRects) \ - ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) +#define ID3D12Device12_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) -#define ID3D12GraphicsCommandList4_OMSetBlendFactor(This,BlendFactor) \ - ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) +#define ID3D12Device12_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) -#define ID3D12GraphicsCommandList4_OMSetStencilRef(This,StencilRef) \ - ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) +#define ID3D12Device12_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12GraphicsCommandList4_SetPipelineState(This,pPipelineState) \ - ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) +#define ID3D12Device12_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12GraphicsCommandList4_ResourceBarrier(This,NumBarriers,pBarriers) \ - ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) +#define ID3D12Device12_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) -#define ID3D12GraphicsCommandList4_ExecuteBundle(This,pCommandList) \ - ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) +#define ID3D12Device12_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) -#define ID3D12GraphicsCommandList4_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ - ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) +#define ID3D12Device12_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) -#define ID3D12GraphicsCommandList4_SetComputeRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) +#define ID3D12Device12_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) -#define ID3D12GraphicsCommandList4_SetGraphicsRootSignature(This,pRootSignature) \ - ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) +#define ID3D12Device12_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) -#define ID3D12GraphicsCommandList4_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) +#define ID3D12Device12_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) -#define ID3D12GraphicsCommandList4_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ - ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) +#define ID3D12Device12_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12GraphicsCommandList4_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) +#define ID3D12Device12_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) -#define ID3D12GraphicsCommandList4_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) +#define ID3D12Device12_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12GraphicsCommandList4_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) +#define ID3D12Device12_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12GraphicsCommandList4_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ - ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) +#define ID3D12Device12_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) -#define ID3D12GraphicsCommandList4_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) +#define ID3D12Device12_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) -#define ID3D12GraphicsCommandList4_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) +#define ID3D12Device12_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) +#if !defined(_WIN32) -#define ID3D12GraphicsCommandList4_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) +#define ID3D12Device12_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) +#else +#define ID3D12Device12_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) +#endif +#if !defined(_WIN32) -#define ID3D12GraphicsCommandList4_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) +#define ID3D12Device12_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) +#else +#define ID3D12Device12_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) +#endif -#define ID3D12GraphicsCommandList4_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) +#define ID3D12Device12_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) -#define ID3D12GraphicsCommandList4_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ - ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) +#define ID3D12Device12_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) -#define ID3D12GraphicsCommandList4_IASetIndexBuffer(This,pView) \ - ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) +#define ID3D12Device12_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) -#define ID3D12GraphicsCommandList4_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) +#define ID3D12Device12_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) -#define ID3D12GraphicsCommandList4_SOSetTargets(This,StartSlot,NumViews,pViews) \ - ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) +#define ID3D12Device12_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) -#define ID3D12GraphicsCommandList4_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ - ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) +#define ID3D12Device12_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) -#define ID3D12GraphicsCommandList4_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) +#define ID3D12Device12_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) -#define ID3D12GraphicsCommandList4_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) +#define ID3D12Device12_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) -#define ID3D12GraphicsCommandList4_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) +#define ID3D12Device12_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) -#define ID3D12GraphicsCommandList4_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ - ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) +#define ID3D12Device12_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) -#define ID3D12GraphicsCommandList4_DiscardResource(This,pResource,pRegion) \ - ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) +#define ID3D12Device12_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) -#define ID3D12GraphicsCommandList4_BeginQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) +#define ID3D12Device12_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) -#define ID3D12GraphicsCommandList4_EndQuery(This,pQueryHeap,Type,Index) \ - ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) +#define ID3D12Device12_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) -#define ID3D12GraphicsCommandList4_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ - ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) +#define ID3D12Device12_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) -#define ID3D12GraphicsCommandList4_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ - ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) +#define ID3D12Device12_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) -#define ID3D12GraphicsCommandList4_SetMarker(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) +#define ID3D12Device12_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) +#if !defined(_WIN32) -#define ID3D12GraphicsCommandList4_BeginEvent(This,Metadata,pData,Size) \ - ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) +#define ID3D12Device12_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) +#else +#define ID3D12Device12_GetAdapterLuid(This,RetVal) \ + ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) +#endif -#define ID3D12GraphicsCommandList4_EndEvent(This) \ - ( (This)->lpVtbl -> EndEvent(This) ) -#define ID3D12GraphicsCommandList4_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ - ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) +#define ID3D12Device12_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) +#define ID3D12Device12_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) -#define ID3D12GraphicsCommandList4_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) +#define ID3D12Device12_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) -#define ID3D12GraphicsCommandList4_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ - ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -#define ID3D12GraphicsCommandList4_OMSetDepthBounds(This,Min,Max) \ - ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) +#define ID3D12Device12_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12GraphicsCommandList4_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ - ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) -#define ID3D12GraphicsCommandList4_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ - ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) +#define ID3D12Device12_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) -#define ID3D12GraphicsCommandList4_SetViewInstanceMask(This,Mask) \ - ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) +#define ID3D12Device12_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) +#define ID3D12Device12_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ + ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) -#define ID3D12GraphicsCommandList4_WriteBufferImmediate(This,Count,pParams,pModes) \ - ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) +#define ID3D12Device12_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) -#define ID3D12GraphicsCommandList4_SetProtectedResourceSession(This,pProtectedResourceSession) \ - ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) +#define ID3D12Device12_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) +#define ID3D12Device12_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) -#define ID3D12GraphicsCommandList4_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ - ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) +#define ID3D12Device12_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) -#define ID3D12GraphicsCommandList4_EndRenderPass(This) \ - ( (This)->lpVtbl -> EndRenderPass(This) ) +#define ID3D12Device12_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) +#if !defined(_WIN32) -#define ID3D12GraphicsCommandList4_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ - ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) +#define ID3D12Device12_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device12_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif -#define ID3D12GraphicsCommandList4_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ - ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) -#define ID3D12GraphicsCommandList4_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ - ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) +#define ID3D12Device12_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ + ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) -#define ID3D12GraphicsCommandList4_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ - ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) +#define ID3D12Device12_RemoveDevice(This) \ + ( (This)->lpVtbl -> RemoveDevice(This) ) -#define ID3D12GraphicsCommandList4_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ - ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) +#define ID3D12Device12_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) -#define ID3D12GraphicsCommandList4_SetPipelineState1(This,pStateObject) \ - ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) +#define ID3D12Device12_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) -#define ID3D12GraphicsCommandList4_DispatchRays(This,pDesc) \ - ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) +#define ID3D12Device12_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ + ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) -#endif /* COBJMACROS */ +#define ID3D12Device12_CreateStateObject(This,pDesc,riid,ppStateObject) \ + ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) +#define ID3D12Device12_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ + ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) -#endif /* C style interface */ +#define ID3D12Device12_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ + ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) +#define ID3D12Device12_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ + ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) -#endif /* __ID3D12GraphicsCommandList4_INTERFACE_DEFINED__ */ +#define ID3D12Device12_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) \ + ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) +#define ID3D12Device12_CreateProtectedResourceSession1(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) -/* interface __MIDL_itf_d3d12_0000_0051 */ -/* [local] */ +#if !defined(_WIN32) -typedef -enum D3D12_SHADER_CACHE_MODE - { - D3D12_SHADER_CACHE_MODE_MEMORY = 0, - D3D12_SHADER_CACHE_MODE_DISK = ( D3D12_SHADER_CACHE_MODE_MEMORY + 1 ) - } D3D12_SHADER_CACHE_MODE; +#define ID3D12Device12_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device12_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif -typedef -enum D3D12_SHADER_CACHE_FLAGS - { - D3D12_SHADER_CACHE_FLAG_NONE = 0, - D3D12_SHADER_CACHE_FLAG_DRIVER_VERSIONED = 0x1, - D3D12_SHADER_CACHE_FLAG_USE_WORKING_DIR = 0x2 - } D3D12_SHADER_CACHE_FLAGS; +#define ID3D12Device12_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) -DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_FLAGS ); -typedef struct D3D12_SHADER_CACHE_SESSION_DESC - { - GUID Identifier; - D3D12_SHADER_CACHE_MODE Mode; - D3D12_SHADER_CACHE_FLAGS Flags; - UINT MaximumInMemoryCacheSizeBytes; - UINT MaximumInMemoryCacheEntries; - UINT MaximumValueFileSizeBytes; - UINT64 Version; - } D3D12_SHADER_CACHE_SESSION_DESC; +#define ID3D12Device12_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) -typedef -enum D3D12_BARRIER_LAYOUT - { - D3D12_BARRIER_LAYOUT_UNDEFINED = 0xffffffff, - D3D12_BARRIER_LAYOUT_COMMON = 0, - D3D12_BARRIER_LAYOUT_PRESENT = 0, - D3D12_BARRIER_LAYOUT_GENERIC_READ = ( D3D12_BARRIER_LAYOUT_PRESENT + 1 ) , - D3D12_BARRIER_LAYOUT_RENDER_TARGET = ( D3D12_BARRIER_LAYOUT_GENERIC_READ + 1 ) , - D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS = ( D3D12_BARRIER_LAYOUT_RENDER_TARGET + 1 ) , - D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE = ( D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS + 1 ) , - D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ = ( D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE + 1 ) , - D3D12_BARRIER_LAYOUT_SHADER_RESOURCE = ( D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ + 1 ) , - D3D12_BARRIER_LAYOUT_COPY_SOURCE = ( D3D12_BARRIER_LAYOUT_SHADER_RESOURCE + 1 ) , - D3D12_BARRIER_LAYOUT_COPY_DEST = ( D3D12_BARRIER_LAYOUT_COPY_SOURCE + 1 ) , - D3D12_BARRIER_LAYOUT_RESOLVE_SOURCE = ( D3D12_BARRIER_LAYOUT_COPY_DEST + 1 ) , - D3D12_BARRIER_LAYOUT_RESOLVE_DEST = ( D3D12_BARRIER_LAYOUT_RESOLVE_SOURCE + 1 ) , - D3D12_BARRIER_LAYOUT_SHADING_RATE_SOURCE = ( D3D12_BARRIER_LAYOUT_RESOLVE_DEST + 1 ) , - D3D12_BARRIER_LAYOUT_VIDEO_DECODE_READ = ( D3D12_BARRIER_LAYOUT_SHADING_RATE_SOURCE + 1 ) , - D3D12_BARRIER_LAYOUT_VIDEO_DECODE_WRITE = ( D3D12_BARRIER_LAYOUT_VIDEO_DECODE_READ + 1 ) , - D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_READ = ( D3D12_BARRIER_LAYOUT_VIDEO_DECODE_WRITE + 1 ) , - D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_WRITE = ( D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_READ + 1 ) , - D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_READ = ( D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_WRITE + 1 ) , - D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_WRITE = ( D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_READ + 1 ) , - D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON = ( D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_WRITE + 1 ) , - D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ = ( D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON + 1 ) , - D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS = ( D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ + 1 ) , - D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE = ( D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS + 1 ) , - D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE = ( D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE + 1 ) , - D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST = ( D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE + 1 ) , - D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON = ( D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST + 1 ) , - D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ = ( D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON + 1 ) , - D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS = ( D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ + 1 ) , - D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE = ( D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS + 1 ) , - D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE = ( D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE + 1 ) , - D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST = ( D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE + 1 ) , - D3D12_BARRIER_LAYOUT_VIDEO_QUEUE_COMMON = ( D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST + 1 ) - } D3D12_BARRIER_LAYOUT; +#define ID3D12Device12_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) -typedef -enum D3D12_BARRIER_SYNC - { - D3D12_BARRIER_SYNC_NONE = 0, - D3D12_BARRIER_SYNC_ALL = 0x1, - D3D12_BARRIER_SYNC_DRAW = 0x2, - D3D12_BARRIER_SYNC_INPUT_ASSEMBLER = 0x4, - D3D12_BARRIER_SYNC_VERTEX_SHADING = 0x8, - D3D12_BARRIER_SYNC_PIXEL_SHADING = 0x10, - D3D12_BARRIER_SYNC_DEPTH_STENCIL = 0x20, - D3D12_BARRIER_SYNC_RENDER_TARGET = 0x40, - D3D12_BARRIER_SYNC_COMPUTE_SHADING = 0x80, - D3D12_BARRIER_SYNC_RAYTRACING = 0x100, - D3D12_BARRIER_SYNC_COPY = 0x200, - D3D12_BARRIER_SYNC_RESOLVE = 0x400, - D3D12_BARRIER_SYNC_EXECUTE_INDIRECT = 0x800, - D3D12_BARRIER_SYNC_PREDICATION = 0x800, - D3D12_BARRIER_SYNC_ALL_SHADING = 0x1000, - D3D12_BARRIER_SYNC_NON_PIXEL_SHADING = 0x2000, - D3D12_BARRIER_SYNC_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO = 0x4000, - D3D12_BARRIER_SYNC_CLEAR_UNORDERED_ACCESS_VIEW = 0x8000, - D3D12_BARRIER_SYNC_VIDEO_DECODE = 0x100000, - D3D12_BARRIER_SYNC_VIDEO_PROCESS = 0x200000, - D3D12_BARRIER_SYNC_VIDEO_ENCODE = 0x400000, - D3D12_BARRIER_SYNC_BUILD_RAYTRACING_ACCELERATION_STRUCTURE = 0x800000, - D3D12_BARRIER_SYNC_COPY_RAYTRACING_ACCELERATION_STRUCTURE = 0x1000000, - D3D12_BARRIER_SYNC_SPLIT = 0x80000000 - } D3D12_BARRIER_SYNC; +#define ID3D12Device12_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) -DEFINE_ENUM_FLAG_OPERATORS( D3D12_BARRIER_SYNC ); -typedef -enum D3D12_BARRIER_ACCESS - { - D3D12_BARRIER_ACCESS_COMMON = 0, - D3D12_BARRIER_ACCESS_VERTEX_BUFFER = 0x1, - D3D12_BARRIER_ACCESS_CONSTANT_BUFFER = 0x2, - D3D12_BARRIER_ACCESS_INDEX_BUFFER = 0x4, - D3D12_BARRIER_ACCESS_RENDER_TARGET = 0x8, - D3D12_BARRIER_ACCESS_UNORDERED_ACCESS = 0x10, - D3D12_BARRIER_ACCESS_DEPTH_STENCIL_WRITE = 0x20, - D3D12_BARRIER_ACCESS_DEPTH_STENCIL_READ = 0x40, - D3D12_BARRIER_ACCESS_SHADER_RESOURCE = 0x80, - D3D12_BARRIER_ACCESS_STREAM_OUTPUT = 0x100, - D3D12_BARRIER_ACCESS_INDIRECT_ARGUMENT = 0x200, - D3D12_BARRIER_ACCESS_PREDICATION = 0x200, - D3D12_BARRIER_ACCESS_COPY_DEST = 0x400, - D3D12_BARRIER_ACCESS_COPY_SOURCE = 0x800, - D3D12_BARRIER_ACCESS_RESOLVE_DEST = 0x1000, - D3D12_BARRIER_ACCESS_RESOLVE_SOURCE = 0x2000, - D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_READ = 0x4000, - D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_WRITE = 0x8000, - D3D12_BARRIER_ACCESS_SHADING_RATE_SOURCE = 0x10000, - D3D12_BARRIER_ACCESS_VIDEO_DECODE_READ = 0x20000, - D3D12_BARRIER_ACCESS_VIDEO_DECODE_WRITE = 0x40000, - D3D12_BARRIER_ACCESS_VIDEO_PROCESS_READ = 0x80000, - D3D12_BARRIER_ACCESS_VIDEO_PROCESS_WRITE = 0x100000, - D3D12_BARRIER_ACCESS_VIDEO_ENCODE_READ = 0x200000, - D3D12_BARRIER_ACCESS_VIDEO_ENCODE_WRITE = 0x400000, - D3D12_BARRIER_ACCESS_NO_ACCESS = 0x80000000 - } D3D12_BARRIER_ACCESS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_BARRIER_ACCESS ); -typedef -enum D3D12_BARRIER_TYPE - { - D3D12_BARRIER_TYPE_GLOBAL = 0, - D3D12_BARRIER_TYPE_TEXTURE = ( D3D12_BARRIER_TYPE_GLOBAL + 1 ) , - D3D12_BARRIER_TYPE_BUFFER = ( D3D12_BARRIER_TYPE_TEXTURE + 1 ) - } D3D12_BARRIER_TYPE; +#define ID3D12Device12_CreateShaderCacheSession(This,pDesc,riid,ppvSession) \ + ( (This)->lpVtbl -> CreateShaderCacheSession(This,pDesc,riid,ppvSession) ) -typedef -enum D3D12_TEXTURE_BARRIER_FLAGS - { - D3D12_TEXTURE_BARRIER_FLAG_NONE = 0, - D3D12_TEXTURE_BARRIER_FLAG_DISCARD = 0x1 - } D3D12_TEXTURE_BARRIER_FLAGS; +#define ID3D12Device12_ShaderCacheControl(This,Kinds,Control) \ + ( (This)->lpVtbl -> ShaderCacheControl(This,Kinds,Control) ) -DEFINE_ENUM_FLAG_OPERATORS( D3D12_TEXTURE_BARRIER_FLAGS ); -typedef struct D3D12_BARRIER_SUBRESOURCE_RANGE - { - UINT IndexOrFirstMipLevel; - UINT NumMipLevels; - UINT FirstArraySlice; - UINT NumArraySlices; - UINT FirstPlane; - UINT NumPlanes; - } D3D12_BARRIER_SUBRESOURCE_RANGE; +#define ID3D12Device12_CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) ) -typedef struct D3D12_GLOBAL_BARRIER - { - D3D12_BARRIER_SYNC SyncBefore; - D3D12_BARRIER_SYNC SyncAfter; - D3D12_BARRIER_ACCESS AccessBefore; - D3D12_BARRIER_ACCESS AccessAfter; - } D3D12_GLOBAL_BARRIER; -typedef struct D3D12_TEXTURE_BARRIER - { - D3D12_BARRIER_SYNC SyncBefore; - D3D12_BARRIER_SYNC SyncAfter; - D3D12_BARRIER_ACCESS AccessBefore; - D3D12_BARRIER_ACCESS AccessAfter; - D3D12_BARRIER_LAYOUT LayoutBefore; - D3D12_BARRIER_LAYOUT LayoutAfter; - _In_ ID3D12Resource *pResource; - D3D12_BARRIER_SUBRESOURCE_RANGE Subresources; - D3D12_TEXTURE_BARRIER_FLAGS Flags; - } D3D12_TEXTURE_BARRIER; +#define ID3D12Device12_CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) ) -typedef struct D3D12_BUFFER_BARRIER - { - D3D12_BARRIER_SYNC SyncBefore; - D3D12_BARRIER_SYNC SyncAfter; - D3D12_BARRIER_ACCESS AccessBefore; - D3D12_BARRIER_ACCESS AccessAfter; - _In_ ID3D12Resource *pResource; - UINT64 Offset; - UINT64 Size; - } D3D12_BUFFER_BARRIER; +#define ID3D12Device12_CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) ) -typedef struct D3D12_BARRIER_GROUP - { - D3D12_BARRIER_TYPE Type; - UINT32 NumBarriers; - union - { - _In_reads_(NumBarriers) const D3D12_GLOBAL_BARRIER *pGlobalBarriers; - _In_reads_(NumBarriers) const D3D12_TEXTURE_BARRIER *pTextureBarriers; - _In_reads_(NumBarriers) const D3D12_BUFFER_BARRIER *pBufferBarriers; - } ; - } D3D12_BARRIER_GROUP; +#define ID3D12Device12_CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) ) +#define ID3D12Device12_CreateSampler2(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler2(This,pDesc,DestDescriptor) ) -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0051_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0051_v0_0_s_ifspec; +#if !defined(_WIN32) -#ifndef __ID3D12ShaderCacheSession_INTERFACE_DEFINED__ -#define __ID3D12ShaderCacheSession_INTERFACE_DEFINED__ +#define ID3D12Device12_GetResourceAllocationInfo3(This,visibleMask,numResourceDescs,pResourceDescs,pNumCastableFormats,ppCastableFormats,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo3(This,visibleMask,numResourceDescs,pResourceDescs,pNumCastableFormats,ppCastableFormats,pResourceAllocationInfo1) ) +#else +#define ID3D12Device12_GetResourceAllocationInfo3(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pNumCastableFormats,ppCastableFormats,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo3(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pNumCastableFormats,ppCastableFormats,pResourceAllocationInfo1) ) +#endif -/* interface ID3D12ShaderCacheSession */ +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Device12_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Device13_INTERFACE_DEFINED__ +#define __ID3D12Device13_INTERFACE_DEFINED__ + +/* interface ID3D12Device13 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12ShaderCacheSession; +EXTERN_C const IID IID_ID3D12Device13; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("28e2495d-0f64-4ae4-a6ec-129255dc49a8") - ID3D12ShaderCacheSession : public ID3D12DeviceChild + MIDL_INTERFACE("14eecffc-4df8-40f7-a118-5c816f45695e") + ID3D12Device13 : public ID3D12Device12 { public: - virtual HRESULT STDMETHODCALLTYPE FindValue( - /* [annotation][in] */ - _In_reads_bytes_(KeySize) const void *pKey, - UINT KeySize, + virtual HRESULT STDMETHODCALLTYPE OpenExistingHeapFromAddress1( + _In_ const void *pAddress, + SIZE_T size, + REFIID riid, + _COM_Outptr_ void **ppvHeap) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12Device13Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Device13 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Device13 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Device13 * This); + + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12Device13 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12Device13 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12Device13 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12Device13 * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) + UINT ( STDMETHODCALLTYPE *GetNodeCount )( + ID3D12Device13 * This); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( + ID3D12Device13 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) + HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( + ID3D12Device13 * This, + _In_ D3D12_COMMAND_LIST_TYPE type, + REFIID riid, + _COM_Outptr_ void **ppCommandAllocator); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( + ID3D12Device13 * This, + _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( + ID3D12Device13 * This, + _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( + ID3D12Device13 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ ID3D12CommandAllocator *pCommandAllocator, + _In_opt_ ID3D12PipelineState *pInitialState, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12Device13 * This, + D3D12_FEATURE Feature, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) + HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( + ID3D12Device13 * This, + _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) + UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( + ID3D12Device13 * This, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) + HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( + ID3D12Device13 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, + _In_ SIZE_T blobLengthInBytes, + REFIID riid, + _COM_Outptr_ void **ppvRootSignature); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) + void ( STDMETHODCALLTYPE *CreateConstantBufferView )( + ID3D12Device13 * This, + _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) + void ( STDMETHODCALLTYPE *CreateShaderResourceView )( + ID3D12Device13 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( + ID3D12Device13 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ ID3D12Resource *pCounterResource, + _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) + void ( STDMETHODCALLTYPE *CreateRenderTargetView )( + ID3D12Device13 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) + void ( STDMETHODCALLTYPE *CreateDepthStencilView )( + ID3D12Device13 * This, + _In_opt_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) + void ( STDMETHODCALLTYPE *CreateSampler )( + ID3D12Device13 * This, + _In_ const D3D12_SAMPLER_DESC *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) + void ( STDMETHODCALLTYPE *CopyDescriptors )( + ID3D12Device13 * This, + _In_ UINT NumDestDescriptorRanges, + _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, + _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, + _In_ UINT NumSrcDescriptorRanges, + _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, + _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) + void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( + ID3D12Device13 * This, + _In_ UINT NumDescriptors, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, + _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device13 * This, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( + ID3D12Device13 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + _In_ UINT visibleMask, + _In_ UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) +#if !defined(_WIN32) + D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device13 * This, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#else + D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( + ID3D12Device13 * This, + D3D12_HEAP_PROPERTIES * RetVal, + _In_ UINT nodeMask, + D3D12_HEAP_TYPE heapType); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( + ID3D12Device13 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) + HRESULT ( STDMETHODCALLTYPE *CreateHeap )( + ID3D12Device13 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( + ID3D12Device13 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( + ID3D12Device13 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) + HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( + ID3D12Device13 * This, + _In_ ID3D12DeviceChild *pObject, + _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, + DWORD Access, + _In_opt_ LPCWSTR Name, + _Out_ HANDLE *pHandle); + + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( + ID3D12Device13 * This, + _In_ HANDLE NTHandle, + REFIID riid, + _COM_Outptr_opt_ void **ppvObj); + + DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) + HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( + ID3D12Device13 * This, + _In_ LPCWSTR Name, + DWORD Access, /* [annotation][out] */ - _Out_writes_bytes_(*pValueSize) void *pValue, - _Inout_ UINT *pValueSize) = 0; + _Out_ HANDLE *pNTHandle); + + DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) + HRESULT ( STDMETHODCALLTYPE *MakeResident )( + ID3D12Device13 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + DECLSPEC_XFGVIRT(ID3D12Device, Evict) + HRESULT ( STDMETHODCALLTYPE *Evict )( + ID3D12Device13 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) + HRESULT ( STDMETHODCALLTYPE *CreateFence )( + ID3D12Device13 * This, + UINT64 InitialValue, + D3D12_FENCE_FLAGS Flags, + REFIID riid, + _COM_Outptr_ void **ppFence); + + DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) + HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( + ID3D12Device13 * This); + + DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) + void ( STDMETHODCALLTYPE *GetCopyableFootprints )( + ID3D12Device13 * This, + _In_ const D3D12_RESOURCE_DESC *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) + HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( + ID3D12Device13 * This, + _In_ const D3D12_QUERY_HEAP_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) + HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( + ID3D12Device13 * This, + BOOL Enable); + + DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) + HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( + ID3D12Device13 * This, + _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, + _In_opt_ ID3D12RootSignature *pRootSignature, + REFIID riid, + _COM_Outptr_opt_ void **ppvCommandSignature); + + DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) + void ( STDMETHODCALLTYPE *GetResourceTiling )( + ID3D12Device13 * This, + _In_ ID3D12Resource *pTiledResource, + _Out_opt_ UINT *pNumTilesForEntireResource, + _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, + _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, + _Inout_opt_ UINT *pNumSubresourceTilings, + _In_ UINT FirstSubresourceTilingToGet, + _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + + DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) +#if !defined(_WIN32) + LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device13 * This); + +#else + LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( + ID3D12Device13 * This, + LUID * RetVal); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( + ID3D12Device13 * This, + _In_reads_(BlobLength) const void *pLibraryBlob, + SIZE_T BlobLength, + REFIID riid, + _COM_Outptr_ void **ppPipelineLibrary); + + DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) + HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( + ID3D12Device13 * This, + _In_reads_(NumFences) ID3D12Fence *const *ppFences, + _In_reads_(NumFences) const UINT64 *pFenceValues, + UINT NumFences, + D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, + HANDLE hEvent); + + DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) + HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( + ID3D12Device13 * This, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + + DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) + HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( + ID3D12Device13 * This, + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppPipelineState); + + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( + ID3D12Device13 * This, + _In_ const void *pAddress, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( + ID3D12Device13 * This, + _In_ HANDLE hFileMapping, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) + HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( + ID3D12Device13 * This, + D3D12_RESIDENCY_FLAGS Flags, + UINT NumObjects, + _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, + _In_ ID3D12Fence *pFenceToSignal, + UINT64 FenceValueToSignal); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) + HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( + ID3D12Device13 * This, + _In_ UINT nodeMask, + _In_ D3D12_COMMAND_LIST_TYPE type, + _In_ D3D12_COMMAND_LIST_FLAGS flags, + REFIID riid, + _COM_Outptr_ void **ppCommandList); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( + ID3D12Device13 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( + ID3D12Device13 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) + HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( + ID3D12Device13 * This, + _In_ const D3D12_HEAP_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvHeap); - virtual HRESULT STDMETHODCALLTYPE StoreValue( - /* [annotation][in] */ - _In_reads_bytes_(KeySize) const void *pKey, - UINT KeySize, - /* [annotation][in] */ - _In_reads_bytes_(ValueSize) const void *pValue, - UINT ValueSize) = 0; + DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( + ID3D12Device13 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - virtual void STDMETHODCALLTYPE SetDeleteOnDestroy( void) = 0; + DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device13 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); -#if defined(_MSC_VER) - virtual D3D12_SHADER_CACHE_SESSION_DESC STDMETHODCALLTYPE GetDesc( void) = 0; #else - virtual D3D12_SHADER_CACHE_SESSION_DESC *STDMETHODCALLTYPE GetDesc( - D3D12_SHADER_CACHE_SESSION_DESC * RetVal) = 0; + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device13 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + #endif - }; - - -#else /* C style interface */ - - typedef struct ID3D12ShaderCacheSessionVtbl - { - BEGIN_INTERFACE + DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) + HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( + ID3D12Device13 * This, + _In_ ID3D12LifetimeOwner *pOwner, + REFIID riid, + _COM_Outptr_ void **ppvTracker); - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12ShaderCacheSession * This, + DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) + void ( STDMETHODCALLTYPE *RemoveDevice )( + ID3D12Device13 * This); + + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( + ID3D12Device13 * This, + _Inout_ UINT *pNumMetaCommands, + _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); + + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( + ID3D12Device13 * This, + _In_ REFGUID CommandId, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _Out_opt_ UINT *pTotalStructureSizeInBytes, + _Inout_ UINT *pParameterCount, + _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); + + DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) + HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( + ID3D12Device13 * This, + _In_ REFGUID CommandId, + _In_ UINT NodeMask, + _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, + _In_ SIZE_T CreationParametersDataSizeInBytes, REFIID riid, - _COM_Outptr_ void **ppvObject); + _COM_Outptr_ void **ppMetaCommand); - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12ShaderCacheSession * This); + DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) + HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( + ID3D12Device13 * This, + const D3D12_STATE_OBJECT_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppStateObject); - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12ShaderCacheSession * This); + DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) + void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( + ID3D12Device13 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, + _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); - DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12ShaderCacheSession * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); + DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) + D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( + ID3D12Device13 * This, + _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, + _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12ShaderCacheSession * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); + DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) + HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( + ID3D12Device13 * This, + D3D12_BACKGROUND_PROCESSING_MODE Mode, + D3D12_MEASUREMENTS_ACTION MeasurementsAction, + _In_opt_ HANDLE hEventToSignalUponCompletion, + _Out_opt_ BOOL *pbFurtherMeasurementsDesired); - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12ShaderCacheSession * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); + DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject) + HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( + ID3D12Device13 * This, + const D3D12_STATE_OBJECT_DESC *pAddition, + ID3D12StateObject *pStateObjectToGrowFrom, + REFIID riid, + _COM_Outptr_ void **ppNewStateObject); - DECLSPEC_XFGVIRT(ID3D12Object, SetName) - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12ShaderCacheSession * This, - _In_z_ LPCWSTR Name); + DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( + ID3D12Device13 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); - DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) - HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12ShaderCacheSession * This, + DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( + ID3D12Device13 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( + ID3D12Device13 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( + ID3D12Device13 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( + ID3D12Device13 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12ShaderCacheSession, FindValue) - HRESULT ( STDMETHODCALLTYPE *FindValue )( - ID3D12ShaderCacheSession * This, - /* [annotation][in] */ - _In_reads_bytes_(KeySize) const void *pKey, - UINT KeySize, - /* [annotation][out] */ - _Out_writes_bytes_(*pValueSize) void *pValue, - _Inout_ UINT *pValueSize); + DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( + ID3D12Device13 * This, + _In_opt_ ID3D12Resource *pTargetedResource, + _In_opt_ ID3D12Resource *pFeedbackResource, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - DECLSPEC_XFGVIRT(ID3D12ShaderCacheSession, StoreValue) - HRESULT ( STDMETHODCALLTYPE *StoreValue )( - ID3D12ShaderCacheSession * This, - /* [annotation][in] */ - _In_reads_bytes_(KeySize) const void *pKey, - UINT KeySize, - /* [annotation][in] */ - _In_reads_bytes_(ValueSize) const void *pValue, - UINT ValueSize); + DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1) + void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( + ID3D12Device13 * This, + _In_ const D3D12_RESOURCE_DESC1 *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); - DECLSPEC_XFGVIRT(ID3D12ShaderCacheSession, SetDeleteOnDestroy) - void ( STDMETHODCALLTYPE *SetDeleteOnDestroy )( - ID3D12ShaderCacheSession * This); + DECLSPEC_XFGVIRT(ID3D12Device9, CreateShaderCacheSession) + HRESULT ( STDMETHODCALLTYPE *CreateShaderCacheSession )( + ID3D12Device13 * This, + _In_ const D3D12_SHADER_CACHE_SESSION_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvSession); + + DECLSPEC_XFGVIRT(ID3D12Device9, ShaderCacheControl) + HRESULT ( STDMETHODCALLTYPE *ShaderCacheControl )( + ID3D12Device13 * This, + D3D12_SHADER_CACHE_KIND_FLAGS Kinds, + D3D12_SHADER_CACHE_CONTROL_FLAGS Control); + + DECLSPEC_XFGVIRT(ID3D12Device9, CreateCommandQueue1) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue1 )( + ID3D12Device13 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID CreatorID, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + DECLSPEC_XFGVIRT(ID3D12Device10, CreateCommittedResource3) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource3 )( + ID3D12Device13 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device10, CreatePlacedResource2) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource2 )( + ID3D12Device13 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device10, CreateReservedResource2) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource2 )( + ID3D12Device13 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12ShaderCacheSession, GetDesc) + DECLSPEC_XFGVIRT(ID3D12Device11, CreateSampler2) + void ( STDMETHODCALLTYPE *CreateSampler2 )( + ID3D12Device13 * This, + _In_ const D3D12_SAMPLER_DESC2 *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device12, GetResourceAllocationInfo3) #if !defined(_WIN32) - D3D12_SHADER_CACHE_SESSION_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12ShaderCacheSession * This); + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo3 )( + ID3D12Device13 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _In_opt_count_(numResourceDescs) const UINT32 *pNumCastableFormats, + _In_opt_count_(numResourceDescs) const DXGI_FORMAT *const *ppCastableFormats, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); #else - D3D12_SHADER_CACHE_SESSION_DESC *( STDMETHODCALLTYPE *GetDesc )( - ID3D12ShaderCacheSession * This, - D3D12_SHADER_CACHE_SESSION_DESC * RetVal); + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo3 )( + ID3D12Device13 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _In_opt_count_(numResourceDescs) const UINT32 *pNumCastableFormats, + _In_opt_count_(numResourceDescs) const DXGI_FORMAT *const *ppCastableFormats, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); #endif + DECLSPEC_XFGVIRT(ID3D12Device13, OpenExistingHeapFromAddress1) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress1 )( + ID3D12Device13 * This, + _In_ const void *pAddress, + SIZE_T size, + REFIID riid, + _COM_Outptr_ void **ppvHeap); + END_INTERFACE - } ID3D12ShaderCacheSessionVtbl; + } ID3D12Device13Vtbl; - interface ID3D12ShaderCacheSession + interface ID3D12Device13 { - CONST_VTBL struct ID3D12ShaderCacheSessionVtbl *lpVtbl; + CONST_VTBL struct ID3D12Device13Vtbl *lpVtbl; }; @@ -21242,201 +28049,414 @@ EXTERN_C const IID IID_ID3D12ShaderCacheSession; #ifdef COBJMACROS -#define ID3D12ShaderCacheSession_QueryInterface(This,riid,ppvObject) \ +#define ID3D12Device13_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12ShaderCacheSession_AddRef(This) \ +#define ID3D12Device13_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12ShaderCacheSession_Release(This) \ +#define ID3D12Device13_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12ShaderCacheSession_GetPrivateData(This,guid,pDataSize,pData) \ +#define ID3D12Device13_GetPrivateData(This,guid,pDataSize,pData) \ ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12ShaderCacheSession_SetPrivateData(This,guid,DataSize,pData) \ +#define ID3D12Device13_SetPrivateData(This,guid,DataSize,pData) \ ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12ShaderCacheSession_SetPrivateDataInterface(This,guid,pData) \ +#define ID3D12Device13_SetPrivateDataInterface(This,guid,pData) \ ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12ShaderCacheSession_SetName(This,Name) \ +#define ID3D12Device13_SetName(This,Name) \ ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12ShaderCacheSession_GetDevice(This,riid,ppvDevice) \ - ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) +#define ID3D12Device13_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) +#define ID3D12Device13_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) -#define ID3D12ShaderCacheSession_FindValue(This,pKey,KeySize,pValue,pValueSize) \ - ( (This)->lpVtbl -> FindValue(This,pKey,KeySize,pValue,pValueSize) ) +#define ID3D12Device13_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) -#define ID3D12ShaderCacheSession_StoreValue(This,pKey,KeySize,pValue,ValueSize) \ - ( (This)->lpVtbl -> StoreValue(This,pKey,KeySize,pValue,ValueSize) ) +#define ID3D12Device13_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12ShaderCacheSession_SetDeleteOnDestroy(This) \ - ( (This)->lpVtbl -> SetDeleteOnDestroy(This) ) +#define ID3D12Device13_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device13_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) + +#define ID3D12Device13_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) + +#define ID3D12Device13_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) + +#define ID3D12Device13_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) + +#define ID3D12Device13_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) + +#define ID3D12Device13_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) + +#define ID3D12Device13_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device13_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) + +#define ID3D12Device13_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device13_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device13_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) + +#define ID3D12Device13_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) + +#define ID3D12Device13_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) #if !defined(_WIN32) -#define ID3D12ShaderCacheSession_GetDesc(This) \ - ( (This)->lpVtbl -> GetDesc(This) ) +#define ID3D12Device13_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) #else -#define ID3D12ShaderCacheSession_GetDesc(This,RetVal) \ - ( (This)->lpVtbl -> GetDesc(This,RetVal) ) +#define ID3D12Device13_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) #endif +#if !defined(_WIN32) -#endif /* COBJMACROS */ +#define ID3D12Device13_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) +#else +#define ID3D12Device13_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) +#endif +#define ID3D12Device13_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) -#endif /* C style interface */ +#define ID3D12Device13_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) +#define ID3D12Device13_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12Device13_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12Device13_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) -#endif /* __ID3D12ShaderCacheSession_INTERFACE_DEFINED__ */ +#define ID3D12Device13_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) +#define ID3D12Device13_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) -/* interface __MIDL_itf_d3d12_0000_0052 */ -/* [local] */ +#define ID3D12Device13_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) -typedef -enum D3D12_SHADER_CACHE_KIND_FLAGS - { - D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CACHE_FOR_DRIVER = 0x1, - D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CONVERSIONS = 0x2, - D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_DRIVER_MANAGED = 0x4, - D3D12_SHADER_CACHE_KIND_FLAG_APPLICATION_MANAGED = 0x8 - } D3D12_SHADER_CACHE_KIND_FLAGS; +#define ID3D12Device13_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) -DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_KIND_FLAGS ); -typedef -enum D3D12_SHADER_CACHE_CONTROL_FLAGS - { - D3D12_SHADER_CACHE_CONTROL_FLAG_DISABLE = 0x1, - D3D12_SHADER_CACHE_CONTROL_FLAG_ENABLE = 0x2, - D3D12_SHADER_CACHE_CONTROL_FLAG_CLEAR = 0x4 - } D3D12_SHADER_CACHE_CONTROL_FLAGS; +#define ID3D12Device13_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) -DEFINE_ENUM_FLAG_OPERATORS( D3D12_SHADER_CACHE_CONTROL_FLAGS ); +#define ID3D12Device13_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) +#define ID3D12Device13_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0052_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0052_v0_0_s_ifspec; +#define ID3D12Device13_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) -#ifndef __ID3D12Device9_INTERFACE_DEFINED__ -#define __ID3D12Device9_INTERFACE_DEFINED__ +#define ID3D12Device13_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) -/* interface ID3D12Device9 */ -/* [unique][local][object][uuid] */ +#define ID3D12Device13_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) +#define ID3D12Device13_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) +#if !defined(_WIN32) -EXTERN_C const IID IID_ID3D12Device9; +#define ID3D12Device13_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) +#else +#define ID3D12Device13_GetAdapterLuid(This,RetVal) \ + ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) +#endif -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("4c80e962-f032-4f60-bc9e-ebc2cfa1d83c") - ID3D12Device9 : public ID3D12Device8 - { - public: - virtual HRESULT STDMETHODCALLTYPE CreateShaderCacheSession( - _In_ const D3D12_SHADER_CACHE_SESSION_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvSession) = 0; - - virtual HRESULT STDMETHODCALLTYPE ShaderCacheControl( - D3D12_SHADER_CACHE_KIND_FLAGS Kinds, - D3D12_SHADER_CACHE_CONTROL_FLAGS Control) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateCommandQueue1( - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID CreatorID, + +#define ID3D12Device13_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) + +#define ID3D12Device13_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) + +#define ID3D12Device13_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) + + +#define ID3D12Device13_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) + + +#define ID3D12Device13_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) + +#define ID3D12Device13_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) + +#define ID3D12Device13_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ + ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) + + +#define ID3D12Device13_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) + +#define ID3D12Device13_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) + +#define ID3D12Device13_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) + +#define ID3D12Device13_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) + +#define ID3D12Device13_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) +#if !defined(_WIN32) + +#define ID3D12Device13_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device13_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif + + +#define ID3D12Device13_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ + ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) + +#define ID3D12Device13_RemoveDevice(This) \ + ( (This)->lpVtbl -> RemoveDevice(This) ) + +#define ID3D12Device13_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) + +#define ID3D12Device13_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) + +#define ID3D12Device13_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ + ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) + +#define ID3D12Device13_CreateStateObject(This,pDesc,riid,ppStateObject) \ + ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) + +#define ID3D12Device13_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ + ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) + +#define ID3D12Device13_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ + ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) + + +#define ID3D12Device13_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ + ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) + + +#define ID3D12Device13_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) \ + ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) + +#define ID3D12Device13_CreateProtectedResourceSession1(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) + +#if !defined(_WIN32) + +#define ID3D12Device13_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device13_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif + +#define ID3D12Device13_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) + +#define ID3D12Device13_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device13_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) + +#define ID3D12Device13_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + + +#define ID3D12Device13_CreateShaderCacheSession(This,pDesc,riid,ppvSession) \ + ( (This)->lpVtbl -> CreateShaderCacheSession(This,pDesc,riid,ppvSession) ) + +#define ID3D12Device13_ShaderCacheControl(This,Kinds,Control) \ + ( (This)->lpVtbl -> ShaderCacheControl(This,Kinds,Control) ) + +#define ID3D12Device13_CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) ) + + +#define ID3D12Device13_CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) ) + +#define ID3D12Device13_CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) ) + +#define ID3D12Device13_CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) ) + + +#define ID3D12Device13_CreateSampler2(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler2(This,pDesc,DestDescriptor) ) + +#if !defined(_WIN32) + +#define ID3D12Device13_GetResourceAllocationInfo3(This,visibleMask,numResourceDescs,pResourceDescs,pNumCastableFormats,ppCastableFormats,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo3(This,visibleMask,numResourceDescs,pResourceDescs,pNumCastableFormats,ppCastableFormats,pResourceAllocationInfo1) ) +#else +#define ID3D12Device13_GetResourceAllocationInfo3(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pNumCastableFormats,ppCastableFormats,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo3(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pNumCastableFormats,ppCastableFormats,pResourceAllocationInfo1) ) +#endif + + +#define ID3D12Device13_OpenExistingHeapFromAddress1(This,pAddress,size,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress1(This,pAddress,size,riid,ppvHeap) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Device13_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12Device14_INTERFACE_DEFINED__ +#define __ID3D12Device14_INTERFACE_DEFINED__ + +/* interface ID3D12Device14 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Device14; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5f6e592d-d895-44c2-8e4a-88ad4926d323") + ID3D12Device14 : public ID3D12Device13 + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateRootSignatureFromSubobjectInLibrary( + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pLibraryBlob, + _In_ SIZE_T blobLengthInBytes, + _In_opt_ LPCWSTR subobjectName, REFIID riid, - _COM_Outptr_ void **ppCommandQueue) = 0; + _COM_Outptr_ void **ppvRootSignature) = 0; }; #else /* C style interface */ - typedef struct ID3D12Device9Vtbl + typedef struct ID3D12Device14Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device9 * This, + ID3D12Device14 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device9 * This); + ID3D12Device14 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device9 * This); + ID3D12Device14 * This); DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ REFGUID guid, _Inout_ UINT *pDataSize, _Out_writes_bytes_opt_( *pDataSize ) void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_( DataSize ) const void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ REFGUID guid, _In_opt_ const IUnknown *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetName) HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_z_ LPCWSTR Name); DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device9 * This); + ID3D12Device14 * This); DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, REFIID riid, _COM_Outptr_ void **ppCommandQueue); DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ D3D12_COMMAND_LIST_TYPE type, REFIID riid, _COM_Outptr_ void **ppCommandAllocator); DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, REFIID riid, _COM_Outptr_ void **ppPipelineState); DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, REFIID riid, _COM_Outptr_ void **ppPipelineState); DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ UINT nodeMask, _In_ D3D12_COMMAND_LIST_TYPE type, _In_ ID3D12CommandAllocator *pCommandAllocator, @@ -21446,26 +28466,26 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device9 * This, + ID3D12Device14 * This, D3D12_FEATURE Feature, _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, UINT FeatureSupportDataSize); DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, REFIID riid, _COM_Outptr_ void **ppvHeap); DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ UINT nodeMask, _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, _In_ SIZE_T blobLengthInBytes, @@ -21474,20 +28494,20 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_opt_ ID3D12Resource *pResource, _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_opt_ ID3D12Resource *pResource, _In_opt_ ID3D12Resource *pCounterResource, _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, @@ -21495,27 +28515,27 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_opt_ ID3D12Resource *pResource, _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_opt_ ID3D12Resource *pResource, _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_SAMPLER_DESC *pDesc, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ UINT NumDestDescriptorRanges, _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, @@ -21526,7 +28546,7 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ UINT NumDescriptors, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, @@ -21535,14 +28555,14 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) #if !defined(_WIN32) D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ UINT visibleMask, _In_ UINT numResourceDescs, _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); #else D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device9 * This, + ID3D12Device14 * This, D3D12_RESOURCE_ALLOCATION_INFO * RetVal, _In_ UINT visibleMask, _In_ UINT numResourceDescs, @@ -21553,13 +28573,13 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) #if !defined(_WIN32) D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ UINT nodeMask, D3D12_HEAP_TYPE heapType); #else D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device9 * This, + ID3D12Device14 * This, D3D12_HEAP_PROPERTIES * RetVal, _In_ UINT nodeMask, D3D12_HEAP_TYPE heapType); @@ -21568,7 +28588,7 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, _In_ const D3D12_RESOURCE_DESC *pDesc, @@ -21579,14 +28599,14 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_HEAP_DESC *pDesc, REFIID riid, _COM_Outptr_opt_ void **ppvHeap); DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ ID3D12Heap *pHeap, UINT64 HeapOffset, _In_ const D3D12_RESOURCE_DESC *pDesc, @@ -21597,7 +28617,7 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_RESOURCE_DESC *pDesc, D3D12_RESOURCE_STATES InitialState, _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, @@ -21606,7 +28626,7 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ ID3D12DeviceChild *pObject, _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, DWORD Access, @@ -21615,14 +28635,14 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ HANDLE NTHandle, REFIID riid, _COM_Outptr_opt_ void **ppvObj); DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ LPCWSTR Name, DWORD Access, /* [annotation][out] */ @@ -21630,19 +28650,19 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device9 * This, + ID3D12Device14 * This, UINT NumObjects, _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); DECLSPEC_XFGVIRT(ID3D12Device, Evict) HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device9 * This, + ID3D12Device14 * This, UINT NumObjects, _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device9 * This, + ID3D12Device14 * This, UINT64 InitialValue, D3D12_FENCE_FLAGS Flags, REFIID riid, @@ -21650,11 +28670,11 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device9 * This); + ID3D12Device14 * This); DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_RESOURCE_DESC *pResourceDesc, _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, @@ -21666,19 +28686,19 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_QUERY_HEAP_DESC *pDesc, REFIID riid, _COM_Outptr_opt_ void **ppvHeap); DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device9 * This, + ID3D12Device14 * This, BOOL Enable); DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, _In_opt_ ID3D12RootSignature *pRootSignature, REFIID riid, @@ -21686,7 +28706,7 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ ID3D12Resource *pTiledResource, _Out_opt_ UINT *pNumTilesForEntireResource, _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, @@ -21698,18 +28718,18 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) #if !defined(_WIN32) LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device9 * This); + ID3D12Device14 * This); #else LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device9 * This, + ID3D12Device14 * This, LUID * RetVal); #endif DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_reads_(BlobLength) const void *pLibraryBlob, SIZE_T BlobLength, REFIID riid, @@ -21717,7 +28737,7 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_reads_(NumFences) ID3D12Fence *const *ppFences, _In_reads_(NumFences) const UINT64 *pFenceValues, UINT NumFences, @@ -21726,35 +28746,35 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( - ID3D12Device9 * This, + ID3D12Device14 * This, UINT NumObjects, _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( - ID3D12Device9 * This, + ID3D12Device14 * This, const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, REFIID riid, _COM_Outptr_ void **ppPipelineState); DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const void *pAddress, REFIID riid, _COM_Outptr_ void **ppvHeap); DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ HANDLE hFileMapping, REFIID riid, _COM_Outptr_ void **ppvHeap); DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( - ID3D12Device9 * This, + ID3D12Device14 * This, D3D12_RESIDENCY_FLAGS Flags, UINT NumObjects, _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, @@ -21763,7 +28783,7 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ UINT nodeMask, _In_ D3D12_COMMAND_LIST_TYPE type, _In_ D3D12_COMMAND_LIST_FLAGS flags, @@ -21772,14 +28792,14 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, _In_ REFIID riid, _COM_Outptr_ void **ppSession); DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, _In_ const D3D12_RESOURCE_DESC *pDesc, @@ -21791,209 +28811,803 @@ EXTERN_C const IID IID_ID3D12Device9; DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( - ID3D12Device9 * This, + ID3D12Device14 * This, _In_ const D3D12_HEAP_DESC *pDesc, _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); + _COM_Outptr_opt_ void **ppvHeap); + + DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( + ID3D12Device14 * This, + _In_ const D3D12_RESOURCE_DESC *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device14 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( + ID3D12Device14 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) + HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( + ID3D12Device14 * This, + _In_ ID3D12LifetimeOwner *pOwner, + REFIID riid, + _COM_Outptr_ void **ppvTracker); + + DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) + void ( STDMETHODCALLTYPE *RemoveDevice )( + ID3D12Device14 * This); + + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( + ID3D12Device14 * This, + _Inout_ UINT *pNumMetaCommands, + _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); + + DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) + HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( + ID3D12Device14 * This, + _In_ REFGUID CommandId, + _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, + _Out_opt_ UINT *pTotalStructureSizeInBytes, + _Inout_ UINT *pParameterCount, + _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); + + DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) + HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( + ID3D12Device14 * This, + _In_ REFGUID CommandId, + _In_ UINT NodeMask, + _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, + _In_ SIZE_T CreationParametersDataSizeInBytes, + REFIID riid, + _COM_Outptr_ void **ppMetaCommand); + + DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) + HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( + ID3D12Device14 * This, + const D3D12_STATE_OBJECT_DESC *pDesc, + REFIID riid, + _COM_Outptr_ void **ppStateObject); + + DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) + void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( + ID3D12Device14 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, + _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); + + DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) + D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( + ID3D12Device14 * This, + _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, + _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); + + DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) + HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( + ID3D12Device14 * This, + D3D12_BACKGROUND_PROCESSING_MODE Mode, + D3D12_MEASUREMENTS_ACTION MeasurementsAction, + _In_opt_ HANDLE hEventToSignalUponCompletion, + _Out_opt_ BOOL *pbFurtherMeasurementsDesired); + + DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject) + HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( + ID3D12Device14 * This, + const D3D12_STATE_OBJECT_DESC *pAddition, + ID3D12StateObject *pStateObjectToGrowFrom, + REFIID riid, + _COM_Outptr_ void **ppNewStateObject); + + DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1) + HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( + ID3D12Device14 * This, + _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppSession); + + DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2) +#if !defined(_WIN32) + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( + ID3D12Device14 * This, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#else + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( + ID3D12Device14 * This, + D3D12_RESOURCE_ALLOCATION_INFO * RetVal, + UINT visibleMask, + UINT numResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + +#endif + + DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( + ID3D12Device14 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialResourceState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( + ID3D12Device14 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_RESOURCE_STATES InitialState, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView) + void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( + ID3D12Device14 * This, + _In_opt_ ID3D12Resource *pTargetedResource, + _In_opt_ ID3D12Resource *pFeedbackResource, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1) + void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( + ID3D12Device14 * This, + _In_ const D3D12_RESOURCE_DESC1 *pResourceDesc, + _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, + _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, + UINT64 BaseOffset, + _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, + _Out_writes_opt_(NumSubresources) UINT *pNumRows, + _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, + _Out_opt_ UINT64 *pTotalBytes); + + DECLSPEC_XFGVIRT(ID3D12Device9, CreateShaderCacheSession) + HRESULT ( STDMETHODCALLTYPE *CreateShaderCacheSession )( + ID3D12Device14 * This, + _In_ const D3D12_SHADER_CACHE_SESSION_DESC *pDesc, + REFIID riid, + _COM_Outptr_opt_ void **ppvSession); + + DECLSPEC_XFGVIRT(ID3D12Device9, ShaderCacheControl) + HRESULT ( STDMETHODCALLTYPE *ShaderCacheControl )( + ID3D12Device14 * This, + D3D12_SHADER_CACHE_KIND_FLAGS Kinds, + D3D12_SHADER_CACHE_CONTROL_FLAGS Control); + + DECLSPEC_XFGVIRT(ID3D12Device9, CreateCommandQueue1) + HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue1 )( + ID3D12Device14 * This, + _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, + REFIID CreatorID, + REFIID riid, + _COM_Outptr_ void **ppCommandQueue); + + DECLSPEC_XFGVIRT(ID3D12Device10, CreateCommittedResource3) + HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource3 )( + ID3D12Device14 * This, + _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, + D3D12_HEAP_FLAGS HeapFlags, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riidResource, + _COM_Outptr_opt_ void **ppvResource); + + DECLSPEC_XFGVIRT(ID3D12Device10, CreatePlacedResource2) + HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource2 )( + ID3D12Device14 * This, + _In_ ID3D12Heap *pHeap, + UINT64 HeapOffset, + _In_ const D3D12_RESOURCE_DESC1 *pDesc, + D3D12_BARRIER_LAYOUT InitialLayout, + _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, + REFIID riid, + _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( - ID3D12Device9 * This, + DECLSPEC_XFGVIRT(ID3D12Device10, CreateReservedResource2) + HRESULT ( STDMETHODCALLTYPE *CreateReservedResource2 )( + ID3D12Device14 * This, _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, + D3D12_BARRIER_LAYOUT InitialLayout, _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + UINT32 NumCastableFormats, + _In_opt_count_(NumCastableFormats) const DXGI_FORMAT *pCastableFormats, REFIID riid, _COM_Outptr_opt_ void **ppvResource); - DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) + DECLSPEC_XFGVIRT(ID3D12Device11, CreateSampler2) + void ( STDMETHODCALLTYPE *CreateSampler2 )( + ID3D12Device14 * This, + _In_ const D3D12_SAMPLER_DESC2 *pDesc, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + + DECLSPEC_XFGVIRT(ID3D12Device12, GetResourceAllocationInfo3) #if !defined(_WIN32) - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device9 * This, + D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo3 )( + ID3D12Device14 * This, UINT visibleMask, UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _In_opt_count_(numResourceDescs) const UINT32 *pNumCastableFormats, + _In_opt_count_(numResourceDescs) const DXGI_FORMAT *const *ppCastableFormats, _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); #else - D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device9 * This, + D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo3 )( + ID3D12Device14 * This, D3D12_RESOURCE_ALLOCATION_INFO * RetVal, UINT visibleMask, UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, + _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, + _In_opt_count_(numResourceDescs) const UINT32 *pNumCastableFormats, + _In_opt_count_(numResourceDescs) const DXGI_FORMAT *const *ppCastableFormats, _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); #endif - DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) - HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( - ID3D12Device9 * This, - _In_ ID3D12LifetimeOwner *pOwner, - REFIID riid, - _COM_Outptr_ void **ppvTracker); - - DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) - void ( STDMETHODCALLTYPE *RemoveDevice )( - ID3D12Device9 * This); - - DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( - ID3D12Device9 * This, - _Inout_ UINT *pNumMetaCommands, - _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); - - DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( - ID3D12Device9 * This, - _In_ REFGUID CommandId, - _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, - _Out_opt_ UINT *pTotalStructureSizeInBytes, - _Inout_ UINT *pParameterCount, - _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); - - DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) - HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( - ID3D12Device9 * This, - _In_ REFGUID CommandId, - _In_ UINT NodeMask, - _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, - _In_ SIZE_T CreationParametersDataSizeInBytes, + DECLSPEC_XFGVIRT(ID3D12Device13, OpenExistingHeapFromAddress1) + HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress1 )( + ID3D12Device14 * This, + _In_ const void *pAddress, + SIZE_T size, REFIID riid, - _COM_Outptr_ void **ppMetaCommand); + _COM_Outptr_ void **ppvHeap); - DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) - HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( - ID3D12Device9 * This, - const D3D12_STATE_OBJECT_DESC *pDesc, + DECLSPEC_XFGVIRT(ID3D12Device14, CreateRootSignatureFromSubobjectInLibrary) + HRESULT ( STDMETHODCALLTYPE *CreateRootSignatureFromSubobjectInLibrary )( + ID3D12Device14 * This, + _In_ UINT nodeMask, + _In_reads_(blobLengthInBytes) const void *pLibraryBlob, + _In_ SIZE_T blobLengthInBytes, + _In_opt_ LPCWSTR subobjectName, REFIID riid, - _COM_Outptr_ void **ppStateObject); - - DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) - void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( - ID3D12Device9 * This, - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, - _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); + _COM_Outptr_ void **ppvRootSignature); - DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) - D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( - ID3D12Device9 * This, - _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, - _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); + END_INTERFACE + } ID3D12Device14Vtbl; + + interface ID3D12Device14 + { + CONST_VTBL struct ID3D12Device14Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Device14_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Device14_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Device14_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Device14_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12Device14_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12Device14_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12Device14_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12Device14_GetNodeCount(This) \ + ( (This)->lpVtbl -> GetNodeCount(This) ) + +#define ID3D12Device14_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) + +#define ID3D12Device14_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ + ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) + +#define ID3D12Device14_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device14_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) + +#define ID3D12Device14_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) + +#define ID3D12Device14_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) + +#define ID3D12Device14_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) + +#define ID3D12Device14_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ + ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) + +#define ID3D12Device14_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) + +#define ID3D12Device14_CreateConstantBufferView(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) + +#define ID3D12Device14_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device14_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) + +#define ID3D12Device14_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device14_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) + +#define ID3D12Device14_CreateSampler(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) + +#define ID3D12Device14_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) + +#define ID3D12Device14_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ + ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) +#if !defined(_WIN32) + +#define ID3D12Device14_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) +#else +#define ID3D12Device14_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) +#endif +#if !defined(_WIN32) + +#define ID3D12Device14_GetCustomHeapProperties(This,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) +#else +#define ID3D12Device14_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ + ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) +#endif + +#define ID3D12Device14_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) + +#define ID3D12Device14_CreateHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device14_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device14_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device14_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ + ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) + +#define ID3D12Device14_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ + ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) + +#define ID3D12Device14_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ + ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) + +#define ID3D12Device14_MakeResident(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) + +#define ID3D12Device14_Evict(This,NumObjects,ppObjects) \ + ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) + +#define ID3D12Device14_CreateFence(This,InitialValue,Flags,riid,ppFence) \ + ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) + +#define ID3D12Device14_GetDeviceRemovedReason(This) \ + ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) + +#define ID3D12Device14_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + +#define ID3D12Device14_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) + +#define ID3D12Device14_SetStablePowerState(This,Enable) \ + ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) + +#define ID3D12Device14_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ + ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) + +#define ID3D12Device14_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ + ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) +#if !defined(_WIN32) + +#define ID3D12Device14_GetAdapterLuid(This) \ + ( (This)->lpVtbl -> GetAdapterLuid(This) ) +#else +#define ID3D12Device14_GetAdapterLuid(This,RetVal) \ + ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) +#endif + + +#define ID3D12Device14_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ + ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) + +#define ID3D12Device14_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ + ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) + +#define ID3D12Device14_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ + ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) + + +#define ID3D12Device14_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ + ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) + + +#define ID3D12Device14_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) + +#define ID3D12Device14_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) + +#define ID3D12Device14_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ + ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) + + +#define ID3D12Device14_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ + ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) + +#define ID3D12Device14_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) + +#define ID3D12Device14_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) + +#define ID3D12Device14_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ + ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) + +#define ID3D12Device14_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) +#if !defined(_WIN32) + +#define ID3D12Device14_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device14_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif + + +#define ID3D12Device14_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ + ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) + +#define ID3D12Device14_RemoveDevice(This) \ + ( (This)->lpVtbl -> RemoveDevice(This) ) + +#define ID3D12Device14_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) + +#define ID3D12Device14_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ + ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) + +#define ID3D12Device14_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ + ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) + +#define ID3D12Device14_CreateStateObject(This,pDesc,riid,ppStateObject) \ + ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) + +#define ID3D12Device14_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ + ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) + +#define ID3D12Device14_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ + ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) + + +#define ID3D12Device14_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ + ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) + + +#define ID3D12Device14_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) \ + ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) + +#define ID3D12Device14_CreateProtectedResourceSession1(This,pDesc,riid,ppSession) \ + ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) + +#if !defined(_WIN32) + +#define ID3D12Device14_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#else +#define ID3D12Device14_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#endif + +#define ID3D12Device14_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) + +#define ID3D12Device14_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) + +#define ID3D12Device14_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) + +#define ID3D12Device14_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ + ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) + + +#define ID3D12Device14_CreateShaderCacheSession(This,pDesc,riid,ppvSession) \ + ( (This)->lpVtbl -> CreateShaderCacheSession(This,pDesc,riid,ppvSession) ) + +#define ID3D12Device14_ShaderCacheControl(This,Kinds,Control) \ + ( (This)->lpVtbl -> ShaderCacheControl(This,Kinds,Control) ) + +#define ID3D12Device14_CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) \ + ( (This)->lpVtbl -> CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) ) + + +#define ID3D12Device14_CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) \ + ( (This)->lpVtbl -> CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) ) + +#define ID3D12Device14_CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) \ + ( (This)->lpVtbl -> CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) ) + +#define ID3D12Device14_CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) \ + ( (This)->lpVtbl -> CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) ) + + +#define ID3D12Device14_CreateSampler2(This,pDesc,DestDescriptor) \ + ( (This)->lpVtbl -> CreateSampler2(This,pDesc,DestDescriptor) ) + +#if !defined(_WIN32) + +#define ID3D12Device14_GetResourceAllocationInfo3(This,visibleMask,numResourceDescs,pResourceDescs,pNumCastableFormats,ppCastableFormats,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo3(This,visibleMask,numResourceDescs,pResourceDescs,pNumCastableFormats,ppCastableFormats,pResourceAllocationInfo1) ) +#else +#define ID3D12Device14_GetResourceAllocationInfo3(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pNumCastableFormats,ppCastableFormats,pResourceAllocationInfo1) \ + ( (This)->lpVtbl -> GetResourceAllocationInfo3(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pNumCastableFormats,ppCastableFormats,pResourceAllocationInfo1) ) +#endif + + +#define ID3D12Device14_OpenExistingHeapFromAddress1(This,pAddress,size,riid,ppvHeap) \ + ( (This)->lpVtbl -> OpenExistingHeapFromAddress1(This,pAddress,size,riid,ppvHeap) ) + + +#define ID3D12Device14_CreateRootSignatureFromSubobjectInLibrary(This,nodeMask,pLibraryBlob,blobLengthInBytes,subobjectName,riid,ppvRootSignature) \ + ( (This)->lpVtbl -> CreateRootSignatureFromSubobjectInLibrary(This,nodeMask,pLibraryBlob,blobLengthInBytes,subobjectName,riid,ppvRootSignature) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Device14_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0063 */ +/* [local] */ + +typedef union D3D12_VERSION_NUMBER + { + UINT64 Version; + UINT16 VersionParts[ 4 ]; + } D3D12_VERSION_NUMBER; + +typedef struct D3D12_FEATURE_DATA_SHADERCACHE_ABI_SUPPORT + { + WCHAR szAdapterFamily[ 128 ]; + UINT64 MinimumABISupportVersion; + UINT64 MaximumABISupportVersion; + D3D12_VERSION_NUMBER CompilerVersion; + D3D12_VERSION_NUMBER ApplicationProfileVersion; + } D3D12_FEATURE_DATA_SHADERCACHE_ABI_SUPPORT; + +typedef void ( __stdcall *D3D12PipelineStateFunc )( + _In_reads_bytes_(KeySize) const void *pKey, + UINT KeySize, + UINT Version, + const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, + _Inout_opt_ void *pContext); + +typedef void ( __stdcall *D3D12StateObjectFunc )( + _In_reads_bytes_(KeySize) const void *pKey, + UINT KeySize, + UINT Version, + const D3D12_STATE_OBJECT_DESC *pDesc, + _In_reads_bytes_(ParentKeySize) const void *pParentKey, + UINT ParentKeySize, + _Inout_opt_ void *pContext); + +typedef struct D3D12_APPLICATION_DESC + { + LPCWSTR pExeFilename; + LPCWSTR pName; + D3D12_VERSION_NUMBER Version; + LPCWSTR pEngineName; + D3D12_VERSION_NUMBER EngineVersion; + } D3D12_APPLICATION_DESC; + +typedef void ( __stdcall *D3D12ApplicationDescFunc )( + _In_ const D3D12_APPLICATION_DESC *pApplicationDesc, + _Inout_opt_ void *pContext); + +typedef struct D3D12_EXISTING_COLLECTION_BY_KEY_DESC + { + _Field_size_bytes_full_(KeySize) const void *pKey; + UINT KeySize; + UINT NumExports; + _In_reads_(NumExports) const D3D12_EXPORT_DESC *pExports; + } D3D12_EXISTING_COLLECTION_BY_KEY_DESC; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0063_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0063_v0_0_s_ifspec; + +#ifndef __ID3D12StateObjectDatabase_INTERFACE_DEFINED__ +#define __ID3D12StateObjectDatabase_INTERFACE_DEFINED__ + +/* interface ID3D12StateObjectDatabase */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12StateObjectDatabase; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c56060b7-b5fc-4135-98e0-a1e9997eace0") + ID3D12StateObjectDatabase : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetApplicationDesc( + _In_ const D3D12_APPLICATION_DESC *pApplicationDesc) = 0; - DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) - HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( - ID3D12Device9 * This, - D3D12_BACKGROUND_PROCESSING_MODE Mode, - D3D12_MEASUREMENTS_ACTION MeasurementsAction, - _In_opt_ HANDLE hEventToSignalUponCompletion, - _Out_opt_ BOOL *pbFurtherMeasurementsDesired); + virtual HRESULT STDMETHODCALLTYPE GetApplicationDesc( + _In_ D3D12ApplicationDescFunc CallbackFunc, + _Inout_opt_ void *pContext) = 0; - DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject) - HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( - ID3D12Device9 * This, - const D3D12_STATE_OBJECT_DESC *pAddition, - ID3D12StateObject *pStateObjectToGrowFrom, - REFIID riid, - _COM_Outptr_ void **ppNewStateObject); + virtual HRESULT STDMETHODCALLTYPE StorePipelineStateDesc( + _In_reads_(KeySize) const void *pKey, + UINT KeySize, + UINT Version, + _In_ const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc) = 0; - DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1) - HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( - ID3D12Device9 * This, - _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, - _In_ REFIID riid, - _COM_Outptr_ void **ppSession); + virtual HRESULT STDMETHODCALLTYPE FindPipelineStateDesc( + _In_reads_(KeySize) const void *pKey, + UINT KeySize, + _In_ D3D12PipelineStateFunc CallbackFunc, + _Inout_opt_ void *pContext) = 0; - DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2) -#if !defined(_WIN32) - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( - ID3D12Device9 * This, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + virtual HRESULT STDMETHODCALLTYPE StoreStateObjectDesc( + _In_reads_(KeySize) const void *pKey, + UINT KeySize, + UINT Version, + _In_ const D3D12_STATE_OBJECT_DESC *pDesc, + _In_reads_opt_(StateObjectToGrowFromKeySize) const void *pStateObjectToGrowFromKey, + UINT StateObjectToGrowFromKeySize) = 0; -#else - D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( - ID3D12Device9 * This, - D3D12_RESOURCE_ALLOCATION_INFO * RetVal, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + virtual HRESULT STDMETHODCALLTYPE FindStateObjectDesc( + _In_reads_(keySize) const void *pKey, + UINT KeySize, + D3D12StateObjectFunc CallbackFunc, + _Inout_opt_ void *pContext) = 0; -#endif + virtual HRESULT STDMETHODCALLTYPE FindObjectVersion( + _In_reads_(keySize) const void *pKey, + UINT KeySize, + _Out_ UINT *pVersion) = 0; - DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( - ID3D12Device9 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); + }; + + +#else /* C style interface */ + + typedef struct ID3D12StateObjectDatabaseVtbl + { + BEGIN_INTERFACE - DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1) - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( - ID3D12Device9 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12StateObjectDatabase * This, REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + _COM_Outptr_ void **ppvObject); - DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView) - void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( - ID3D12Device9 * This, - _In_opt_ ID3D12Resource *pTargetedResource, - _In_opt_ ID3D12Resource *pFeedbackResource, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12StateObjectDatabase * This); - DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1) - void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( - ID3D12Device9 * This, - _In_ const D3D12_RESOURCE_DESC1 *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12StateObjectDatabase * This); + + DECLSPEC_XFGVIRT(ID3D12StateObjectDatabase, SetApplicationDesc) + HRESULT ( STDMETHODCALLTYPE *SetApplicationDesc )( + ID3D12StateObjectDatabase * This, + _In_ const D3D12_APPLICATION_DESC *pApplicationDesc); + + DECLSPEC_XFGVIRT(ID3D12StateObjectDatabase, GetApplicationDesc) + HRESULT ( STDMETHODCALLTYPE *GetApplicationDesc )( + ID3D12StateObjectDatabase * This, + _In_ D3D12ApplicationDescFunc CallbackFunc, + _Inout_opt_ void *pContext); + + DECLSPEC_XFGVIRT(ID3D12StateObjectDatabase, StorePipelineStateDesc) + HRESULT ( STDMETHODCALLTYPE *StorePipelineStateDesc )( + ID3D12StateObjectDatabase * This, + _In_reads_(KeySize) const void *pKey, + UINT KeySize, + UINT Version, + _In_ const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc); - DECLSPEC_XFGVIRT(ID3D12Device9, CreateShaderCacheSession) - HRESULT ( STDMETHODCALLTYPE *CreateShaderCacheSession )( - ID3D12Device9 * This, - _In_ const D3D12_SHADER_CACHE_SESSION_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvSession); + DECLSPEC_XFGVIRT(ID3D12StateObjectDatabase, FindPipelineStateDesc) + HRESULT ( STDMETHODCALLTYPE *FindPipelineStateDesc )( + ID3D12StateObjectDatabase * This, + _In_reads_(KeySize) const void *pKey, + UINT KeySize, + _In_ D3D12PipelineStateFunc CallbackFunc, + _Inout_opt_ void *pContext); - DECLSPEC_XFGVIRT(ID3D12Device9, ShaderCacheControl) - HRESULT ( STDMETHODCALLTYPE *ShaderCacheControl )( - ID3D12Device9 * This, - D3D12_SHADER_CACHE_KIND_FLAGS Kinds, - D3D12_SHADER_CACHE_CONTROL_FLAGS Control); + DECLSPEC_XFGVIRT(ID3D12StateObjectDatabase, StoreStateObjectDesc) + HRESULT ( STDMETHODCALLTYPE *StoreStateObjectDesc )( + ID3D12StateObjectDatabase * This, + _In_reads_(KeySize) const void *pKey, + UINT KeySize, + UINT Version, + _In_ const D3D12_STATE_OBJECT_DESC *pDesc, + _In_reads_opt_(StateObjectToGrowFromKeySize) const void *pStateObjectToGrowFromKey, + UINT StateObjectToGrowFromKeySize); + + DECLSPEC_XFGVIRT(ID3D12StateObjectDatabase, FindStateObjectDesc) + HRESULT ( STDMETHODCALLTYPE *FindStateObjectDesc )( + ID3D12StateObjectDatabase * This, + _In_reads_(keySize) const void *pKey, + UINT KeySize, + D3D12StateObjectFunc CallbackFunc, + _Inout_opt_ void *pContext); - DECLSPEC_XFGVIRT(ID3D12Device9, CreateCommandQueue1) - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue1 )( - ID3D12Device9 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID CreatorID, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); + DECLSPEC_XFGVIRT(ID3D12StateObjectDatabase, FindObjectVersion) + HRESULT ( STDMETHODCALLTYPE *FindObjectVersion )( + ID3D12StateObjectDatabase * This, + _In_reads_(keySize) const void *pKey, + UINT KeySize, + _Out_ UINT *pVersion); END_INTERFACE - } ID3D12Device9Vtbl; + } ID3D12StateObjectDatabaseVtbl; - interface ID3D12Device9 + interface ID3D12StateObjectDatabase { - CONST_VTBL struct ID3D12Device9Vtbl *lpVtbl; + CONST_VTBL struct ID3D12StateObjectDatabaseVtbl *lpVtbl; }; @@ -22001,269 +29615,338 @@ EXTERN_C const IID IID_ID3D12Device9; #ifdef COBJMACROS -#define ID3D12Device9_QueryInterface(This,riid,ppvObject) \ +#define ID3D12StateObjectDatabase_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12Device9_AddRef(This) \ +#define ID3D12StateObjectDatabase_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12Device9_Release(This) \ +#define ID3D12StateObjectDatabase_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Device9_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) - -#define ID3D12Device9_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) +#define ID3D12StateObjectDatabase_SetApplicationDesc(This,pApplicationDesc) \ + ( (This)->lpVtbl -> SetApplicationDesc(This,pApplicationDesc) ) -#define ID3D12Device9_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) +#define ID3D12StateObjectDatabase_GetApplicationDesc(This,CallbackFunc,pContext) \ + ( (This)->lpVtbl -> GetApplicationDesc(This,CallbackFunc,pContext) ) -#define ID3D12Device9_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) +#define ID3D12StateObjectDatabase_StorePipelineStateDesc(This,pKey,KeySize,Version,pDesc) \ + ( (This)->lpVtbl -> StorePipelineStateDesc(This,pKey,KeySize,Version,pDesc) ) +#define ID3D12StateObjectDatabase_FindPipelineStateDesc(This,pKey,KeySize,CallbackFunc,pContext) \ + ( (This)->lpVtbl -> FindPipelineStateDesc(This,pKey,KeySize,CallbackFunc,pContext) ) -#define ID3D12Device9_GetNodeCount(This) \ - ( (This)->lpVtbl -> GetNodeCount(This) ) +#define ID3D12StateObjectDatabase_StoreStateObjectDesc(This,pKey,KeySize,Version,pDesc,pStateObjectToGrowFromKey,StateObjectToGrowFromKeySize) \ + ( (This)->lpVtbl -> StoreStateObjectDesc(This,pKey,KeySize,Version,pDesc,pStateObjectToGrowFromKey,StateObjectToGrowFromKeySize) ) -#define ID3D12Device9_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) +#define ID3D12StateObjectDatabase_FindStateObjectDesc(This,pKey,KeySize,CallbackFunc,pContext) \ + ( (This)->lpVtbl -> FindStateObjectDesc(This,pKey,KeySize,CallbackFunc,pContext) ) -#define ID3D12Device9_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ - ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) +#define ID3D12StateObjectDatabase_FindObjectVersion(This,pKey,KeySize,pVersion) \ + ( (This)->lpVtbl -> FindObjectVersion(This,pKey,KeySize,pVersion) ) -#define ID3D12Device9_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) +#endif /* COBJMACROS */ -#define ID3D12Device9_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12Device9_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) +#endif /* C style interface */ -#define ID3D12Device9_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ - ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) -#define ID3D12Device9_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) -#define ID3D12Device9_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ - ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) -#define ID3D12Device9_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ - ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) +#endif /* __ID3D12StateObjectDatabase_INTERFACE_DEFINED__ */ -#define ID3D12Device9_CreateConstantBufferView(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) -#define ID3D12Device9_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) +#ifndef __ID3D12VirtualizationGuestDevice_INTERFACE_DEFINED__ +#define __ID3D12VirtualizationGuestDevice_INTERFACE_DEFINED__ -#define ID3D12Device9_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) +/* interface ID3D12VirtualizationGuestDevice */ +/* [unique][local][object][uuid] */ -#define ID3D12Device9_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12Device9_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) +EXTERN_C const IID IID_ID3D12VirtualizationGuestDevice; -#define ID3D12Device9_CreateSampler(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("bc66d368-7373-4943-8757-fc87dc79e476") + ID3D12VirtualizationGuestDevice : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ShareWithHost( + _In_ ID3D12DeviceChild *pObject, + _Out_ HANDLE *pHandle) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateFenceFd( + _In_ ID3D12Fence *pFence, + UINT64 FenceValue, + _Out_ int *pFenceFd) = 0; + + }; + + +#else /* C style interface */ -#define ID3D12Device9_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) + typedef struct ID3D12VirtualizationGuestDeviceVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12VirtualizationGuestDevice * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12VirtualizationGuestDevice * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12VirtualizationGuestDevice * This); + + DECLSPEC_XFGVIRT(ID3D12VirtualizationGuestDevice, ShareWithHost) + HRESULT ( STDMETHODCALLTYPE *ShareWithHost )( + ID3D12VirtualizationGuestDevice * This, + _In_ ID3D12DeviceChild *pObject, + _Out_ HANDLE *pHandle); + + DECLSPEC_XFGVIRT(ID3D12VirtualizationGuestDevice, CreateFenceFd) + HRESULT ( STDMETHODCALLTYPE *CreateFenceFd )( + ID3D12VirtualizationGuestDevice * This, + _In_ ID3D12Fence *pFence, + UINT64 FenceValue, + _Out_ int *pFenceFd); + + END_INTERFACE + } ID3D12VirtualizationGuestDeviceVtbl; -#define ID3D12Device9_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) -#if !defined(_WIN32) + interface ID3D12VirtualizationGuestDevice + { + CONST_VTBL struct ID3D12VirtualizationGuestDeviceVtbl *lpVtbl; + }; -#define ID3D12Device9_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) -#else -#define ID3D12Device9_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) -#endif -#if !defined(_WIN32) + -#define ID3D12Device9_GetCustomHeapProperties(This,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) -#else -#define ID3D12Device9_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) -#endif +#ifdef COBJMACROS -#define ID3D12Device9_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) -#define ID3D12Device9_CreateHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) +#define ID3D12VirtualizationGuestDevice_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12Device9_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12VirtualizationGuestDevice_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12Device9_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12VirtualizationGuestDevice_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Device9_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ - ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) -#define ID3D12Device9_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ - ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) +#define ID3D12VirtualizationGuestDevice_ShareWithHost(This,pObject,pHandle) \ + ( (This)->lpVtbl -> ShareWithHost(This,pObject,pHandle) ) -#define ID3D12Device9_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ - ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) +#define ID3D12VirtualizationGuestDevice_CreateFenceFd(This,pFence,FenceValue,pFenceFd) \ + ( (This)->lpVtbl -> CreateFenceFd(This,pFence,FenceValue,pFenceFd) ) -#define ID3D12Device9_MakeResident(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) +#endif /* COBJMACROS */ -#define ID3D12Device9_Evict(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) -#define ID3D12Device9_CreateFence(This,InitialValue,Flags,riid,ppFence) \ - ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) +#endif /* C style interface */ -#define ID3D12Device9_GetDeviceRemovedReason(This) \ - ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) -#define ID3D12Device9_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) -#define ID3D12Device9_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) -#define ID3D12Device9_SetStablePowerState(This,Enable) \ - ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) +#endif /* __ID3D12VirtualizationGuestDevice_INTERFACE_DEFINED__ */ -#define ID3D12Device9_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ - ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) -#define ID3D12Device9_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ - ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) -#if !defined(_WIN32) +#ifndef __ID3D12Tools_INTERFACE_DEFINED__ +#define __ID3D12Tools_INTERFACE_DEFINED__ -#define ID3D12Device9_GetAdapterLuid(This) \ - ( (This)->lpVtbl -> GetAdapterLuid(This) ) -#else -#define ID3D12Device9_GetAdapterLuid(This,RetVal) \ - ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) -#endif +/* interface ID3D12Tools */ +/* [unique][local][object][uuid] */ -#define ID3D12Device9_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ - ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) +EXTERN_C const IID IID_ID3D12Tools; -#define ID3D12Device9_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ - ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7071e1f0-e84b-4b33-974f-12fa49de65c5") + ID3D12Tools : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE EnableShaderInstrumentation( + BOOL bEnable) = 0; + + virtual BOOL STDMETHODCALLTYPE ShaderInstrumentationEnabled( void) = 0; + + }; + + +#else /* C style interface */ -#define ID3D12Device9_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ - ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) + typedef struct ID3D12ToolsVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Tools * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Tools * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Tools * This); + + DECLSPEC_XFGVIRT(ID3D12Tools, EnableShaderInstrumentation) + void ( STDMETHODCALLTYPE *EnableShaderInstrumentation )( + ID3D12Tools * This, + BOOL bEnable); + + DECLSPEC_XFGVIRT(ID3D12Tools, ShaderInstrumentationEnabled) + BOOL ( STDMETHODCALLTYPE *ShaderInstrumentationEnabled )( + ID3D12Tools * This); + + END_INTERFACE + } ID3D12ToolsVtbl; + interface ID3D12Tools + { + CONST_VTBL struct ID3D12ToolsVtbl *lpVtbl; + }; -#define ID3D12Device9_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) + +#ifdef COBJMACROS -#define ID3D12Device9_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) -#define ID3D12Device9_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) +#define ID3D12Tools_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12Device9_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ - ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) +#define ID3D12Tools_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) +#define ID3D12Tools_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Device9_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) -#define ID3D12Device9_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ - ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) +#define ID3D12Tools_EnableShaderInstrumentation(This,bEnable) \ + ( (This)->lpVtbl -> EnableShaderInstrumentation(This,bEnable) ) -#define ID3D12Device9_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) +#define ID3D12Tools_ShaderInstrumentationEnabled(This) \ + ( (This)->lpVtbl -> ShaderInstrumentationEnabled(This) ) -#define ID3D12Device9_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) +#endif /* COBJMACROS */ -#define ID3D12Device9_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) -#if !defined(_WIN32) -#define ID3D12Device9_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) -#else -#define ID3D12Device9_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) -#endif +#endif /* C style interface */ -#define ID3D12Device9_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ - ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) -#define ID3D12Device9_RemoveDevice(This) \ - ( (This)->lpVtbl -> RemoveDevice(This) ) -#define ID3D12Device9_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) +#endif /* __ID3D12Tools_INTERFACE_DEFINED__ */ -#define ID3D12Device9_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) -#define ID3D12Device9_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ - ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) +#ifndef __ID3D12Tools1_INTERFACE_DEFINED__ +#define __ID3D12Tools1_INTERFACE_DEFINED__ -#define ID3D12Device9_CreateStateObject(This,pDesc,riid,ppStateObject) \ - ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) +/* interface ID3D12Tools1 */ +/* [unique][local][object][uuid] */ -#define ID3D12Device9_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ - ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) -#define ID3D12Device9_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ - ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) +EXTERN_C const IID IID_ID3D12Tools1; +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e4fbc019-dd3c-43e1-8f32-7f649575f0a0") + ID3D12Tools1 : public ID3D12Tools + { + public: + virtual HRESULT STDMETHODCALLTYPE ReserveGPUVARangesAtCreate( + _In_reads_(uiNumRanges) D3D12_GPU_VIRTUAL_ADDRESS_RANGE *pRanges, + _In_ UINT uiNumRanges) = 0; + + virtual void STDMETHODCALLTYPE ClearReservedGPUVARangesList( void) = 0; + + }; + + +#else /* C style interface */ -#define ID3D12Device9_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ - ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) + typedef struct ID3D12Tools1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Tools1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Tools1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Tools1 * This); + + DECLSPEC_XFGVIRT(ID3D12Tools, EnableShaderInstrumentation) + void ( STDMETHODCALLTYPE *EnableShaderInstrumentation )( + ID3D12Tools1 * This, + BOOL bEnable); + + DECLSPEC_XFGVIRT(ID3D12Tools, ShaderInstrumentationEnabled) + BOOL ( STDMETHODCALLTYPE *ShaderInstrumentationEnabled )( + ID3D12Tools1 * This); + + DECLSPEC_XFGVIRT(ID3D12Tools1, ReserveGPUVARangesAtCreate) + HRESULT ( STDMETHODCALLTYPE *ReserveGPUVARangesAtCreate )( + ID3D12Tools1 * This, + _In_reads_(uiNumRanges) D3D12_GPU_VIRTUAL_ADDRESS_RANGE *pRanges, + _In_ UINT uiNumRanges); + + DECLSPEC_XFGVIRT(ID3D12Tools1, ClearReservedGPUVARangesList) + void ( STDMETHODCALLTYPE *ClearReservedGPUVARangesList )( + ID3D12Tools1 * This); + + END_INTERFACE + } ID3D12Tools1Vtbl; + interface ID3D12Tools1 + { + CONST_VTBL struct ID3D12Tools1Vtbl *lpVtbl; + }; -#define ID3D12Device9_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) \ - ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) + -#define ID3D12Device9_CreateProtectedResourceSession1(This,pDesc,riid,ppSession) \ - ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) +#ifdef COBJMACROS -#if !defined(_WIN32) -#define ID3D12Device9_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) -#else -#define ID3D12Device9_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) -#endif +#define ID3D12Tools1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12Device9_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) +#define ID3D12Tools1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12Device9_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12Tools1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Device9_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) -#define ID3D12Device9_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) +#define ID3D12Tools1_EnableShaderInstrumentation(This,bEnable) \ + ( (This)->lpVtbl -> EnableShaderInstrumentation(This,bEnable) ) +#define ID3D12Tools1_ShaderInstrumentationEnabled(This) \ + ( (This)->lpVtbl -> ShaderInstrumentationEnabled(This) ) -#define ID3D12Device9_CreateShaderCacheSession(This,pDesc,riid,ppvSession) \ - ( (This)->lpVtbl -> CreateShaderCacheSession(This,pDesc,riid,ppvSession) ) -#define ID3D12Device9_ShaderCacheControl(This,Kinds,Control) \ - ( (This)->lpVtbl -> ShaderCacheControl(This,Kinds,Control) ) +#define ID3D12Tools1_ReserveGPUVARangesAtCreate(This,pRanges,uiNumRanges) \ + ( (This)->lpVtbl -> ReserveGPUVARangesAtCreate(This,pRanges,uiNumRanges) ) -#define ID3D12Device9_CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) ) +#define ID3D12Tools1_ClearReservedGPUVARangesList(This) \ + ( (This)->lpVtbl -> ClearReservedGPUVARangesList(This) ) #endif /* COBJMACROS */ @@ -22273,736 +29956,887 @@ EXTERN_C const IID IID_ID3D12Device9; -#endif /* __ID3D12Device9_INTERFACE_DEFINED__ */ +#endif /* __ID3D12Tools1_INTERFACE_DEFINED__ */ -#ifndef __ID3D12Device10_INTERFACE_DEFINED__ -#define __ID3D12Device10_INTERFACE_DEFINED__ +#ifndef __ID3D12Tools2_INTERFACE_DEFINED__ +#define __ID3D12Tools2_INTERFACE_DEFINED__ -/* interface ID3D12Device10 */ +/* interface ID3D12Tools2 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12Device10; +EXTERN_C const IID IID_ID3D12Tools2; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("517f8718-aa66-49f9-b02b-a7ab89c06031") - ID3D12Device10 : public ID3D12Device9 + MIDL_INTERFACE("01d393c5-c9b0-42a1-958c-c26b02d4d097") + ID3D12Tools2 : public ID3D12Tools1 { public: - virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource3( - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_BARRIER_LAYOUT InitialLayout, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - UINT32 NumCastableFormats, - _In_opt_count_(NumCastableFormats) DXGI_FORMAT *pCastableFormats, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreatePlacedResource2( - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_BARRIER_LAYOUT InitialLayout, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - UINT32 NumCastableFormats, - _In_opt_count_(NumCastableFormats) DXGI_FORMAT *pCastableFormats, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateReservedResource2( - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_BARRIER_LAYOUT InitialLayout, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - UINT32 NumCastableFormats, - _In_opt_count_(NumCastableFormats) DXGI_FORMAT *pCastableFormats, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource) = 0; + virtual HRESULT STDMETHODCALLTYPE SetApplicationSpecificDriverState( + _In_ IUnknown *pAdapter, + _In_opt_ ID3DBlob *pBlob) = 0; }; #else /* C style interface */ - typedef struct ID3D12Device10Vtbl + typedef struct ID3D12Tools2Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device10 * This, + ID3D12Tools2 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device10 * This); - - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device10 * This); - - DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) - HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device10 * This, - _In_ REFGUID guid, - _Inout_ UINT *pDataSize, - _Out_writes_bytes_opt_( *pDataSize ) void *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) - HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device10 * This, - _In_ REFGUID guid, - _In_ UINT DataSize, - _In_reads_bytes_opt_( DataSize ) const void *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) - HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device10 * This, - _In_ REFGUID guid, - _In_opt_ const IUnknown *pData); - - DECLSPEC_XFGVIRT(ID3D12Object, SetName) - HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device10 * This, - _In_z_ LPCWSTR Name); - - DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) - UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device10 * This); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device10 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) - HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device10 * This, - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) - HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device10 * This, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) - HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device10 * This, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) - HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device10 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, - REFIID riid, - _COM_Outptr_ void **ppCommandList); - - DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) - HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device10 * This, - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) - HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device10 * This, - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) - UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device10 * This, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) - HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device10 * This, - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, - REFIID riid, - _COM_Outptr_ void **ppvRootSignature); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) - void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device10 * This, - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) - void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device10 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) - void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device10 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) - void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device10 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) - void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device10 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) - void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device10 * This, - _In_ const D3D12_SAMPLER_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) - void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device10 * This, - _In_ UINT NumDestDescriptorRanges, - _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, - _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, - _In_ UINT NumSrcDescriptorRanges, - _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, - _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) - void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device10 * This, - _In_ UINT NumDescriptors, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); - - DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) -#if !defined(_WIN32) - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device10 * This, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); - -#else - D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device10 * This, - D3D12_RESOURCE_ALLOCATION_INFO * RetVal, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + ID3D12Tools2 * This); -#endif + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Tools2 * This); - DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) -#if !defined(_WIN32) - D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device10 * This, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); + DECLSPEC_XFGVIRT(ID3D12Tools, EnableShaderInstrumentation) + void ( STDMETHODCALLTYPE *EnableShaderInstrumentation )( + ID3D12Tools2 * This, + BOOL bEnable); -#else - D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device10 * This, - D3D12_HEAP_PROPERTIES * RetVal, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); + DECLSPEC_XFGVIRT(ID3D12Tools, ShaderInstrumentationEnabled) + BOOL ( STDMETHODCALLTYPE *ShaderInstrumentationEnabled )( + ID3D12Tools2 * This); -#endif + DECLSPEC_XFGVIRT(ID3D12Tools1, ReserveGPUVARangesAtCreate) + HRESULT ( STDMETHODCALLTYPE *ReserveGPUVARangesAtCreate )( + ID3D12Tools2 * This, + _In_reads_(uiNumRanges) D3D12_GPU_VIRTUAL_ADDRESS_RANGE *pRanges, + _In_ UINT uiNumRanges); - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device10 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12Tools1, ClearReservedGPUVARangesList) + void ( STDMETHODCALLTYPE *ClearReservedGPUVARangesList )( + ID3D12Tools2 * This); - DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) - HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device10 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12Tools2, SetApplicationSpecificDriverState) + HRESULT ( STDMETHODCALLTYPE *SetApplicationSpecificDriverState )( + ID3D12Tools2 * This, + _In_ IUnknown *pAdapter, + _In_opt_ ID3DBlob *pBlob); - DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device10 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + END_INTERFACE + } ID3D12Tools2Vtbl; + + interface ID3D12Tools2 + { + CONST_VTBL struct ID3D12Tools2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Tools2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Tools2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Tools2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Tools2_EnableShaderInstrumentation(This,bEnable) \ + ( (This)->lpVtbl -> EnableShaderInstrumentation(This,bEnable) ) + +#define ID3D12Tools2_ShaderInstrumentationEnabled(This) \ + ( (This)->lpVtbl -> ShaderInstrumentationEnabled(This) ) + + +#define ID3D12Tools2_ReserveGPUVARangesAtCreate(This,pRanges,uiNumRanges) \ + ( (This)->lpVtbl -> ReserveGPUVARangesAtCreate(This,pRanges,uiNumRanges) ) + +#define ID3D12Tools2_ClearReservedGPUVARangesList(This) \ + ( (This)->lpVtbl -> ClearReservedGPUVARangesList(This) ) + + +#define ID3D12Tools2_SetApplicationSpecificDriverState(This,pAdapter,pBlob) \ + ( (This)->lpVtbl -> SetApplicationSpecificDriverState(This,pAdapter,pBlob) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Tools2_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12PageableTools_INTERFACE_DEFINED__ +#define __ID3D12PageableTools_INTERFACE_DEFINED__ + +/* interface ID3D12PageableTools */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12PageableTools; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8f1359db-d8d1-42f9-b5cf-79f4cbad0d3d") + ID3D12PageableTools : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetAllocation( + _Inout_ D3D12_GPU_VIRTUAL_ADDRESS_RANGE *pAllocation) = 0; - DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device10 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, + }; + + +#else /* C style interface */ + + typedef struct ID3D12PageableToolsVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12PageableTools * This, REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + _COM_Outptr_ void **ppvObject); - DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) - HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device10 * This, - _In_ ID3D12DeviceChild *pObject, - _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, - DWORD Access, - _In_opt_ LPCWSTR Name, - _Out_ HANDLE *pHandle); + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12PageableTools * This); - DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device10 * This, - _In_ HANDLE NTHandle, - REFIID riid, - _COM_Outptr_opt_ void **ppvObj); + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12PageableTools * This); - DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device10 * This, - _In_ LPCWSTR Name, - DWORD Access, - /* [annotation][out] */ - _Out_ HANDLE *pNTHandle); + DECLSPEC_XFGVIRT(ID3D12PageableTools, GetAllocation) + HRESULT ( STDMETHODCALLTYPE *GetAllocation )( + ID3D12PageableTools * This, + _Inout_ D3D12_GPU_VIRTUAL_ADDRESS_RANGE *pAllocation); - DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) - HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device10 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + END_INTERFACE + } ID3D12PageableToolsVtbl; + + interface ID3D12PageableTools + { + CONST_VTBL struct ID3D12PageableToolsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12PageableTools_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12PageableTools_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12PageableTools_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12PageableTools_GetAllocation(This,pAllocation) \ + ( (This)->lpVtbl -> GetAllocation(This,pAllocation) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12PageableTools_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DeviceTools_INTERFACE_DEFINED__ +#define __ID3D12DeviceTools_INTERFACE_DEFINED__ + +/* interface ID3D12DeviceTools */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DeviceTools; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2ea68e9c-19c3-4e47-a109-6cdadff0aca9") + ID3D12DeviceTools : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE SetNextAllocationAddress( + _In_ D3D12_GPU_VIRTUAL_ADDRESS nextAllocationVirtualAddress) = 0; - DECLSPEC_XFGVIRT(ID3D12Device, Evict) - HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device10 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + }; + + +#else /* C style interface */ + + typedef struct ID3D12DeviceToolsVtbl + { + BEGIN_INTERFACE - DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) - HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device10 * This, - UINT64 InitialValue, - D3D12_FENCE_FLAGS Flags, + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceTools * This, REFIID riid, - _COM_Outptr_ void **ppFence); + _COM_Outptr_ void **ppvObject); - DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) - HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device10 * This); + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceTools * This); - DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) - void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device10 * This, - _In_ const D3D12_RESOURCE_DESC *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceTools * This); + + DECLSPEC_XFGVIRT(ID3D12DeviceTools, SetNextAllocationAddress) + void ( STDMETHODCALLTYPE *SetNextAllocationAddress )( + ID3D12DeviceTools * This, + _In_ D3D12_GPU_VIRTUAL_ADDRESS nextAllocationVirtualAddress); + + END_INTERFACE + } ID3D12DeviceToolsVtbl; + + interface ID3D12DeviceTools + { + CONST_VTBL struct ID3D12DeviceToolsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DeviceTools_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DeviceTools_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DeviceTools_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DeviceTools_SetNextAllocationAddress(This,nextAllocationVirtualAddress) \ + ( (This)->lpVtbl -> SetNextAllocationAddress(This,nextAllocationVirtualAddress) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DeviceTools_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0070 */ +/* [local] */ + +typedef +enum D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_STATUS + { + D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_UNKNOWN = 1, + D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_USED = 2, + D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_IGNORED = 3, + D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_NOT_SPECIFIED = 4 + } D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_STATUS; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0070_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0070_v0_0_s_ifspec; + +#ifndef __ID3D12DeviceTools1_INTERFACE_DEFINED__ +#define __ID3D12DeviceTools1_INTERFACE_DEFINED__ + +/* interface ID3D12DeviceTools1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DeviceTools1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e30e9fc7-e641-4d6e-8a81-9dd9206ec47a") + ID3D12DeviceTools1 : public ID3D12DeviceTools + { + public: + virtual HRESULT STDMETHODCALLTYPE GetApplicationSpecificDriverState( + _COM_Outptr_ ID3DBlob **ppBlob) = 0; - DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) - HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device10 * This, - _In_ const D3D12_QUERY_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); + virtual D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_STATUS STDMETHODCALLTYPE GetApplicationSpecificDriverBlobStatus( void) = 0; - DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) - HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device10 * This, - BOOL Enable); + }; + + +#else /* C style interface */ + + typedef struct ID3D12DeviceTools1Vtbl + { + BEGIN_INTERFACE - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) - HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device10 * This, - _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, - _In_opt_ ID3D12RootSignature *pRootSignature, + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceTools1 * This, REFIID riid, - _COM_Outptr_opt_ void **ppvCommandSignature); + _COM_Outptr_ void **ppvObject); - DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) - void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device10 * This, - _In_ ID3D12Resource *pTiledResource, - _Out_opt_ UINT *pNumTilesForEntireResource, - _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, - _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, - _Inout_opt_ UINT *pNumSubresourceTilings, - _In_ UINT FirstSubresourceTilingToGet, - _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceTools1 * This); - DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) -#if !defined(_WIN32) - LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device10 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceTools1 * This); -#else - LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device10 * This, - LUID * RetVal); + DECLSPEC_XFGVIRT(ID3D12DeviceTools, SetNextAllocationAddress) + void ( STDMETHODCALLTYPE *SetNextAllocationAddress )( + ID3D12DeviceTools1 * This, + _In_ D3D12_GPU_VIRTUAL_ADDRESS nextAllocationVirtualAddress); -#endif + DECLSPEC_XFGVIRT(ID3D12DeviceTools1, GetApplicationSpecificDriverState) + HRESULT ( STDMETHODCALLTYPE *GetApplicationSpecificDriverState )( + ID3D12DeviceTools1 * This, + _COM_Outptr_ ID3DBlob **ppBlob); + + DECLSPEC_XFGVIRT(ID3D12DeviceTools1, GetApplicationSpecificDriverBlobStatus) + D3D12_APPLICATION_SPECIFIC_DRIVER_BLOB_STATUS ( STDMETHODCALLTYPE *GetApplicationSpecificDriverBlobStatus )( + ID3D12DeviceTools1 * This); + + END_INTERFACE + } ID3D12DeviceTools1Vtbl; + + interface ID3D12DeviceTools1 + { + CONST_VTBL struct ID3D12DeviceTools1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DeviceTools1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DeviceTools1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DeviceTools1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DeviceTools1_SetNextAllocationAddress(This,nextAllocationVirtualAddress) \ + ( (This)->lpVtbl -> SetNextAllocationAddress(This,nextAllocationVirtualAddress) ) + + +#define ID3D12DeviceTools1_GetApplicationSpecificDriverState(This,ppBlob) \ + ( (This)->lpVtbl -> GetApplicationSpecificDriverState(This,ppBlob) ) + +#define ID3D12DeviceTools1_GetApplicationSpecificDriverBlobStatus(This) \ + ( (This)->lpVtbl -> GetApplicationSpecificDriverBlobStatus(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DeviceTools1_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0071 */ +/* [local] */ + +typedef struct D3D12_SUBRESOURCE_DATA + { + const void *pData; + LONG_PTR RowPitch; + LONG_PTR SlicePitch; + } D3D12_SUBRESOURCE_DATA; + +typedef struct D3D12_MEMCPY_DEST + { + void *pData; + SIZE_T RowPitch; + SIZE_T SlicePitch; + } D3D12_MEMCPY_DEST; + +#if !defined( D3D12_IGNORE_SDK_LAYERS ) +#include "d3d12sdklayers.h" +#endif + +/////////////////////////////////////////////////////////////////////////// +// D3D12CreateDevice +// ------------------ +// +// pAdapter +// If NULL, D3D12CreateDevice will choose the primary adapter. +// If non-NULL, D3D12CreateDevice will use the provided adapter. +// MinimumFeatureLevel +// The minimum feature level required for successful device creation. +// riid +// The interface IID of the device to be returned. Expected: ID3D12Device. +// ppDevice +// Pointer to returned interface. May be NULL. +// +// Return Values +// Any of those documented for +// CreateDXGIFactory1 +// IDXGIFactory::EnumAdapters +// D3D12CreateDevice +// +/////////////////////////////////////////////////////////////////////////// +typedef HRESULT (WINAPI* PFN_D3D12_CREATE_DEVICE)( _In_opt_ IUnknown*, + D3D_FEATURE_LEVEL, + _In_ REFIID, _COM_Outptr_opt_ void** ); + +HRESULT WINAPI D3D12CreateDevice( + _In_opt_ IUnknown* pAdapter, + D3D_FEATURE_LEVEL MinimumFeatureLevel, + _In_ REFIID riid, // Expected: ID3D12Device + _COM_Outptr_opt_ void** ppDevice ); + + +typedef HRESULT (WINAPI* PFN_D3D12_GET_DEBUG_INTERFACE)( _In_ REFIID, _COM_Outptr_opt_ void** ); + +HRESULT WINAPI D3D12GetDebugInterface( _In_ REFIID riid, _COM_Outptr_opt_ void** ppvDebug ); + +// -------------------------------------------------------------------------------------------------------------------------------- +// D3D12EnableExperimentalFeatures +// +// Pass in a list of feature GUIDs to be enabled together. +// +// If a particular feature requires some configuration information on enablement, it will have +// a configuration struct that can be passed alongside the GUID. +// +// Some features might use an interface IID as the GUID. For these, once the feature is enabled via +// D3D12EnableExperimentalFeatures, D3D12GetDebugInterface can then be called with the IID to retrieve the interface +// for manipulating the feature. This allows for control that might not cleanly be expressed by just +// the configuration struct that D3D12EnableExperimentalFeatures provides. +// +// If this method is called and a change to existing feature enablement is made, +// all current D3D12 devices are set to DEVICE_REMOVED state, since under the covers there is really only one +// singleton device for a process. Removing the devices when configuration changes prevents +// mismatched expectations of how a device is supposed to work after it has been created from the app's point of view. +// +// The call returns E_NOINTERFACE if an unrecognized feature is passed in or Windows Developer mode is not on. +// The call returns E_INVALIDARG if the configuration of a feature is incorrect, the set of features passed +// in are known to be incompatible with each other, or other errors. +// Returns S_OK otherwise. +// +// -------------------------------------------------------------------------------------------------------------------------------- +HRESULT WINAPI D3D12EnableExperimentalFeatures( + UINT NumFeatures, + _In_count_(NumFeatures) const IID* pIIDs, + _In_opt_count_(NumFeatures) void* pConfigurationStructs, + _In_opt_count_(NumFeatures) UINT* pConfigurationStructSizes); + +// -------------------------------------------------------------------------------------------------------------------------------- +// Experimental Feature: D3D12ExperimentalShaderModels +// +// Use with D3D12EnableExperimentalFeatures to enable experimental shader model support, +// meaning shader models that haven't been finalized for use in retail. +// +// Enabling D3D12ExperimentalShaderModels needs no configuration struct, pass NULL in the pConfigurationStructs array. +// +// -------------------------------------------------------------------------------------------------------------------------------- +static const UUID D3D12ExperimentalShaderModels = { /* 76f5573e-f13a-40f5-b297-81ce9e18933f */ + 0x76f5573e, + 0xf13a, + 0x40f5, + { 0xb2, 0x97, 0x81, 0xce, 0x9e, 0x18, 0x93, 0x3f } +}; +// -------------------------------------------------------------------------------------------------------------------------------- +// Experimental Feature: D3D12TiledResourceTier4 +// +// Use with D3D12EnableExperimentalFeatures to enable tiled resource tier 4 support, +// meaning texture tile data-inheritance is allowed. +// +// Enabling D3D12TiledResourceTier4 needs no configuration struct, pass NULL in the pConfigurationStructs array. +// +// -------------------------------------------------------------------------------------------------------------------------------- +static const UUID D3D12TiledResourceTier4 = { /* c9c4725f-a81a-4f56-8c5b-c51039d694fb */ + 0xc9c4725f, + 0xa81a, + 0x4f56, + { 0x8c, 0x5b, 0xc5, 0x10, 0x39, 0xd6, 0x94, 0xfb } +}; +// -------------------------------------------------------------------------------------------------------------------------------- +// Experimental Feature: D3D12GPUUploadHeapsOnUnsupportedOS +// +// Use with D3D12EnableExperimentalFeatures to enable GPU upload heaps support on an unsupported OS, +// driver support is still required for this feature. +// +// Enabling D3D12GPUUploadHeapsOnUnsupportedOS needs no configuration struct, pass NULL in the pConfigurationStructs array. +// +// -------------------------------------------------------------------------------------------------------------------------------- +static const UUID D3D12GPUUploadHeapsOnUnsupportedOS = { /* 45dc51f3-767f-4588-b206-0baa2b16fbae */ + 0x45dc51f3, + 0x767f, + 0x4588, + { 0xb2, 0x06, 0x0b, 0xaa, 0x2b, 0x16, 0xfb, 0xae } +}; +// -------------------------------------------------------------------------------------------------------------------------------- +// D3D12GetInterface +// +// Retrieve Global D3D12 Interface. +// + +DEFINE_GUID(CLSID_D3D12Debug, 0xf2352aeb, 0xdd84, 0x49fe, 0xb9, 0x7b, 0xa9, 0xdc, 0xfd, 0xcc, 0x1b, 0x4f); +DEFINE_GUID(CLSID_D3D12Tools, 0xe38216b1, 0x3c8c, 0x4833, 0xaa, 0x09, 0x0a, 0x06, 0xb6, 0x5d, 0x96, 0xc8); +DEFINE_GUID(CLSID_D3D12DeviceRemovedExtendedData, 0x4a75bbc4, 0x9ff4, 0x4ad8, 0x9f, 0x18, 0xab, 0xae, 0x84, 0xdc, 0x5f, 0xf2); +DEFINE_GUID(CLSID_D3D12SDKConfiguration, 0x7cda6aca, 0xa03e, 0x49c8, 0x94, 0x58, 0x03, 0x34, 0xd2, 0x0e, 0x07, 0xce); +DEFINE_GUID(CLSID_D3D12DeviceFactory, 0x114863bf, 0xc386, 0x4aee, 0xb3, 0x9d, 0x8f, 0x0b, 0xbb, 0x06, 0x29, 0x55); +DEFINE_GUID(CLSID_D3D12DSRDeviceFactory, 0xbb6dd27e, 0x94a9, 0x41a6, 0x9f, 0x1b, 0x13, 0x37, 0x72, 0x17, 0x24, 0x28); +DEFINE_GUID(CLSID_D3D12StateObjectFactory, 0x54e1c9f3, 0x1303, 0x4112, 0xbf, 0x8e, 0x7b, 0xf2, 0xbb, 0x60, 0x6a, 0x73); + +typedef HRESULT (WINAPI* PFN_D3D12_GET_INTERFACE)( _In_ REFCLSID, _In_ REFIID, _COM_Outptr_opt_ void** ); + +HRESULT WINAPI D3D12GetInterface( _In_ REFCLSID rclsid, _In_ REFIID riid, _COM_Outptr_opt_ void** ppvDebug ); + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0071_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0071_v0_0_s_ifspec; + +#ifndef __ID3D12SDKConfiguration_INTERFACE_DEFINED__ +#define __ID3D12SDKConfiguration_INTERFACE_DEFINED__ + +/* interface ID3D12SDKConfiguration */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12SDKConfiguration; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e9eb5314-33aa-42b2-a718-d77f58b1f1c7") + ID3D12SDKConfiguration : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetSDKVersion( + UINT SDKVersion, + _In_z_ LPCSTR SDKPath) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12SDKConfigurationVtbl + { + BEGIN_INTERFACE - DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) - HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( - ID3D12Device10 * This, - _In_reads_(BlobLength) const void *pLibraryBlob, - SIZE_T BlobLength, + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12SDKConfiguration * This, REFIID riid, - _COM_Outptr_ void **ppPipelineLibrary); + _COM_Outptr_ void **ppvObject); - DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) - HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( - ID3D12Device10 * This, - _In_reads_(NumFences) ID3D12Fence *const *ppFences, - _In_reads_(NumFences) const UINT64 *pFenceValues, - UINT NumFences, - D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, - HANDLE hEvent); + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12SDKConfiguration * This); - DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) - HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( - ID3D12Device10 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12SDKConfiguration * This); - DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) - HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( - ID3D12Device10 * This, - const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); + DECLSPEC_XFGVIRT(ID3D12SDKConfiguration, SetSDKVersion) + HRESULT ( STDMETHODCALLTYPE *SetSDKVersion )( + ID3D12SDKConfiguration * This, + UINT SDKVersion, + _In_z_ LPCSTR SDKPath); - DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( - ID3D12Device10 * This, - _In_ const void *pAddress, + END_INTERFACE + } ID3D12SDKConfigurationVtbl; + + interface ID3D12SDKConfiguration + { + CONST_VTBL struct ID3D12SDKConfigurationVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12SDKConfiguration_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12SDKConfiguration_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12SDKConfiguration_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12SDKConfiguration_SetSDKVersion(This,SDKVersion,SDKPath) \ + ( (This)->lpVtbl -> SetSDKVersion(This,SDKVersion,SDKPath) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12SDKConfiguration_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12SDKConfiguration1_INTERFACE_DEFINED__ +#define __ID3D12SDKConfiguration1_INTERFACE_DEFINED__ + +/* interface ID3D12SDKConfiguration1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12SDKConfiguration1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8aaf9303-ad25-48b9-9a57-d9c37e009d9f") + ID3D12SDKConfiguration1 : public ID3D12SDKConfiguration + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateDeviceFactory( + UINT SDKVersion, + _In_ LPCSTR SDKPath, REFIID riid, - _COM_Outptr_ void **ppvHeap); + _COM_Outptr_ void **ppvFactory) = 0; - DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( - ID3D12Device10 * This, - _In_ HANDLE hFileMapping, - REFIID riid, - _COM_Outptr_ void **ppvHeap); + virtual void STDMETHODCALLTYPE FreeUnusedSDKs( void) = 0; - DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) - HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( - ID3D12Device10 * This, - D3D12_RESIDENCY_FLAGS Flags, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_ ID3D12Fence *pFenceToSignal, - UINT64 FenceValueToSignal); + }; + + +#else /* C style interface */ + + typedef struct ID3D12SDKConfiguration1Vtbl + { + BEGIN_INTERFACE - DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) - HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( - ID3D12Device10 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ D3D12_COMMAND_LIST_FLAGS flags, + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12SDKConfiguration1 * This, REFIID riid, - _COM_Outptr_ void **ppCommandList); + _COM_Outptr_ void **ppvObject); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) - HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( - ID3D12Device10 * This, - _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, - _In_ REFIID riid, - _COM_Outptr_ void **ppSession); + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12SDKConfiguration1 * This); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( - ID3D12Device10 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12SDKConfiguration1 * This); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) - HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( - ID3D12Device10 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12SDKConfiguration, SetSDKVersion) + HRESULT ( STDMETHODCALLTYPE *SetSDKVersion )( + ID3D12SDKConfiguration1 * This, + UINT SDKVersion, + _In_z_ LPCSTR SDKPath); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( - ID3D12Device10 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, + DECLSPEC_XFGVIRT(ID3D12SDKConfiguration1, CreateDeviceFactory) + HRESULT ( STDMETHODCALLTYPE *CreateDeviceFactory )( + ID3D12SDKConfiguration1 * This, + UINT SDKVersion, + _In_ LPCSTR SDKPath, REFIID riid, - _COM_Outptr_opt_ void **ppvResource); - - DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) -#if !defined(_WIN32) - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device10 * This, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + _COM_Outptr_ void **ppvFactory); -#else - D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device10 * This, - D3D12_RESOURCE_ALLOCATION_INFO * RetVal, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + DECLSPEC_XFGVIRT(ID3D12SDKConfiguration1, FreeUnusedSDKs) + void ( STDMETHODCALLTYPE *FreeUnusedSDKs )( + ID3D12SDKConfiguration1 * This); -#endif + END_INTERFACE + } ID3D12SDKConfiguration1Vtbl; + + interface ID3D12SDKConfiguration1 + { + CONST_VTBL struct ID3D12SDKConfiguration1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12SDKConfiguration1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12SDKConfiguration1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12SDKConfiguration1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12SDKConfiguration1_SetSDKVersion(This,SDKVersion,SDKPath) \ + ( (This)->lpVtbl -> SetSDKVersion(This,SDKVersion,SDKPath) ) + + +#define ID3D12SDKConfiguration1_CreateDeviceFactory(This,SDKVersion,SDKPath,riid,ppvFactory) \ + ( (This)->lpVtbl -> CreateDeviceFactory(This,SDKVersion,SDKPath,riid,ppvFactory) ) + +#define ID3D12SDKConfiguration1_FreeUnusedSDKs(This) \ + ( (This)->lpVtbl -> FreeUnusedSDKs(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12SDKConfiguration1_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0073 */ +/* [local] */ + +typedef +enum D3D12_DEVICE_FACTORY_FLAGS + { + D3D12_DEVICE_FACTORY_FLAG_NONE = 0, + D3D12_DEVICE_FACTORY_FLAG_ALLOW_RETURNING_EXISTING_DEVICE = 0x1, + D3D12_DEVICE_FACTORY_FLAG_ALLOW_RETURNING_INCOMPATIBLE_EXISTING_DEVICE = 0x2, + D3D12_DEVICE_FACTORY_FLAG_DISALLOW_STORING_NEW_DEVICE_AS_SINGLETON = 0x4 + } D3D12_DEVICE_FACTORY_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_DEVICE_FACTORY_FLAGS ) + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0073_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0073_v0_0_s_ifspec; + +#ifndef __ID3D12DeviceFactory_INTERFACE_DEFINED__ +#define __ID3D12DeviceFactory_INTERFACE_DEFINED__ + +/* interface ID3D12DeviceFactory */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DeviceFactory; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("61f307d3-d34e-4e7c-8374-3ba4de23cccb") + ID3D12DeviceFactory : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE InitializeFromGlobalState( void) = 0; - DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) - HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( - ID3D12Device10 * This, - _In_ ID3D12LifetimeOwner *pOwner, - REFIID riid, - _COM_Outptr_ void **ppvTracker); + virtual HRESULT STDMETHODCALLTYPE ApplyToGlobalState( void) = 0; - DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) - void ( STDMETHODCALLTYPE *RemoveDevice )( - ID3D12Device10 * This); + virtual HRESULT STDMETHODCALLTYPE SetFlags( + D3D12_DEVICE_FACTORY_FLAGS flags) = 0; - DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( - ID3D12Device10 * This, - _Inout_ UINT *pNumMetaCommands, - _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); + virtual D3D12_DEVICE_FACTORY_FLAGS STDMETHODCALLTYPE GetFlags( void) = 0; - DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( - ID3D12Device10 * This, - _In_ REFGUID CommandId, - _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, - _Out_opt_ UINT *pTotalStructureSizeInBytes, - _Inout_ UINT *pParameterCount, - _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); + virtual HRESULT STDMETHODCALLTYPE GetConfigurationInterface( + REFCLSID clsid, + REFIID iid, + _COM_Outptr_ void **ppv) = 0; - DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) - HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( - ID3D12Device10 * This, - _In_ REFGUID CommandId, - _In_ UINT NodeMask, - _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, - _In_ SIZE_T CreationParametersDataSizeInBytes, - REFIID riid, - _COM_Outptr_ void **ppMetaCommand); + virtual HRESULT STDMETHODCALLTYPE EnableExperimentalFeatures( + UINT NumFeatures, + _In_reads_(NumFeatures) const IID *pIIDs, + _In_reads_opt_(NumFeatures) void *pConfigurationStructs, + _In_reads_opt_(NumFeatures) UINT *pConfigurationStructSizes) = 0; - DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) - HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( - ID3D12Device10 * This, - const D3D12_STATE_OBJECT_DESC *pDesc, + virtual HRESULT STDMETHODCALLTYPE CreateDevice( + _In_opt_ IUnknown *adapter, + D3D_FEATURE_LEVEL FeatureLevel, REFIID riid, - _COM_Outptr_ void **ppStateObject); - - DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) - void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( - ID3D12Device10 * This, - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, - _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); - - DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) - D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( - ID3D12Device10 * This, - _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, - _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); + _COM_Outptr_opt_ void **ppvDevice) = 0; - DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) - HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( - ID3D12Device10 * This, - D3D12_BACKGROUND_PROCESSING_MODE Mode, - D3D12_MEASUREMENTS_ACTION MeasurementsAction, - _In_opt_ HANDLE hEventToSignalUponCompletion, - _Out_opt_ BOOL *pbFurtherMeasurementsDesired); + }; + + +#else /* C style interface */ + + typedef struct ID3D12DeviceFactoryVtbl + { + BEGIN_INTERFACE - DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject) - HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( - ID3D12Device10 * This, - const D3D12_STATE_OBJECT_DESC *pAddition, - ID3D12StateObject *pStateObjectToGrowFrom, + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceFactory * This, REFIID riid, - _COM_Outptr_ void **ppNewStateObject); - - DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1) - HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( - ID3D12Device10 * This, - _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, - _In_ REFIID riid, - _COM_Outptr_ void **ppSession); - - DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2) -#if !defined(_WIN32) - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( - ID3D12Device10 * This, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - -#else - D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( - ID3D12Device10 * This, - D3D12_RESOURCE_ALLOCATION_INFO * RetVal, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); - -#endif - - DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( - ID3D12Device10 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); + _COM_Outptr_ void **ppvObject); - DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1) - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( - ID3D12Device10 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceFactory * This); - DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView) - void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( - ID3D12Device10 * This, - _In_opt_ ID3D12Resource *pTargetedResource, - _In_opt_ ID3D12Resource *pFeedbackResource, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceFactory * This); - DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1) - void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( - ID3D12Device10 * This, - _In_ const D3D12_RESOURCE_DESC1 *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); + DECLSPEC_XFGVIRT(ID3D12DeviceFactory, InitializeFromGlobalState) + HRESULT ( STDMETHODCALLTYPE *InitializeFromGlobalState )( + ID3D12DeviceFactory * This); - DECLSPEC_XFGVIRT(ID3D12Device9, CreateShaderCacheSession) - HRESULT ( STDMETHODCALLTYPE *CreateShaderCacheSession )( - ID3D12Device10 * This, - _In_ const D3D12_SHADER_CACHE_SESSION_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvSession); + DECLSPEC_XFGVIRT(ID3D12DeviceFactory, ApplyToGlobalState) + HRESULT ( STDMETHODCALLTYPE *ApplyToGlobalState )( + ID3D12DeviceFactory * This); - DECLSPEC_XFGVIRT(ID3D12Device9, ShaderCacheControl) - HRESULT ( STDMETHODCALLTYPE *ShaderCacheControl )( - ID3D12Device10 * This, - D3D12_SHADER_CACHE_KIND_FLAGS Kinds, - D3D12_SHADER_CACHE_CONTROL_FLAGS Control); + DECLSPEC_XFGVIRT(ID3D12DeviceFactory, SetFlags) + HRESULT ( STDMETHODCALLTYPE *SetFlags )( + ID3D12DeviceFactory * This, + D3D12_DEVICE_FACTORY_FLAGS flags); - DECLSPEC_XFGVIRT(ID3D12Device9, CreateCommandQueue1) - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue1 )( - ID3D12Device10 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID CreatorID, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); + DECLSPEC_XFGVIRT(ID3D12DeviceFactory, GetFlags) + D3D12_DEVICE_FACTORY_FLAGS ( STDMETHODCALLTYPE *GetFlags )( + ID3D12DeviceFactory * This); - DECLSPEC_XFGVIRT(ID3D12Device10, CreateCommittedResource3) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource3 )( - ID3D12Device10 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_BARRIER_LAYOUT InitialLayout, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - UINT32 NumCastableFormats, - _In_opt_count_(NumCastableFormats) DXGI_FORMAT *pCastableFormats, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12DeviceFactory, GetConfigurationInterface) + HRESULT ( STDMETHODCALLTYPE *GetConfigurationInterface )( + ID3D12DeviceFactory * This, + REFCLSID clsid, + REFIID iid, + _COM_Outptr_ void **ppv); - DECLSPEC_XFGVIRT(ID3D12Device10, CreatePlacedResource2) - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource2 )( - ID3D12Device10 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_BARRIER_LAYOUT InitialLayout, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - UINT32 NumCastableFormats, - _In_opt_count_(NumCastableFormats) DXGI_FORMAT *pCastableFormats, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12DeviceFactory, EnableExperimentalFeatures) + HRESULT ( STDMETHODCALLTYPE *EnableExperimentalFeatures )( + ID3D12DeviceFactory * This, + UINT NumFeatures, + _In_reads_(NumFeatures) const IID *pIIDs, + _In_reads_opt_(NumFeatures) void *pConfigurationStructs, + _In_reads_opt_(NumFeatures) UINT *pConfigurationStructSizes); - DECLSPEC_XFGVIRT(ID3D12Device10, CreateReservedResource2) - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource2 )( - ID3D12Device10 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_BARRIER_LAYOUT InitialLayout, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - UINT32 NumCastableFormats, - _In_opt_count_(NumCastableFormats) DXGI_FORMAT *pCastableFormats, + DECLSPEC_XFGVIRT(ID3D12DeviceFactory, CreateDevice) + HRESULT ( STDMETHODCALLTYPE *CreateDevice )( + ID3D12DeviceFactory * This, + _In_opt_ IUnknown *adapter, + D3D_FEATURE_LEVEL FeatureLevel, REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + _COM_Outptr_opt_ void **ppvDevice); END_INTERFACE - } ID3D12Device10Vtbl; + } ID3D12DeviceFactoryVtbl; - interface ID3D12Device10 + interface ID3D12DeviceFactory { - CONST_VTBL struct ID3D12Device10Vtbl *lpVtbl; + CONST_VTBL struct ID3D12DeviceFactoryVtbl *lpVtbl; }; @@ -23010,279 +30844,461 @@ EXTERN_C const IID IID_ID3D12Device10; #ifdef COBJMACROS -#define ID3D12Device10_QueryInterface(This,riid,ppvObject) \ +#define ID3D12DeviceFactory_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12Device10_AddRef(This) \ +#define ID3D12DeviceFactory_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12Device10_Release(This) \ +#define ID3D12DeviceFactory_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Device10_GetPrivateData(This,guid,pDataSize,pData) \ - ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) +#define ID3D12DeviceFactory_InitializeFromGlobalState(This) \ + ( (This)->lpVtbl -> InitializeFromGlobalState(This) ) -#define ID3D12Device10_SetPrivateData(This,guid,DataSize,pData) \ - ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) +#define ID3D12DeviceFactory_ApplyToGlobalState(This) \ + ( (This)->lpVtbl -> ApplyToGlobalState(This) ) -#define ID3D12Device10_SetPrivateDataInterface(This,guid,pData) \ - ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) +#define ID3D12DeviceFactory_SetFlags(This,flags) \ + ( (This)->lpVtbl -> SetFlags(This,flags) ) -#define ID3D12Device10_SetName(This,Name) \ - ( (This)->lpVtbl -> SetName(This,Name) ) +#define ID3D12DeviceFactory_GetFlags(This) \ + ( (This)->lpVtbl -> GetFlags(This) ) +#define ID3D12DeviceFactory_GetConfigurationInterface(This,clsid,iid,ppv) \ + ( (This)->lpVtbl -> GetConfigurationInterface(This,clsid,iid,ppv) ) -#define ID3D12Device10_GetNodeCount(This) \ - ( (This)->lpVtbl -> GetNodeCount(This) ) +#define ID3D12DeviceFactory_EnableExperimentalFeatures(This,NumFeatures,pIIDs,pConfigurationStructs,pConfigurationStructSizes) \ + ( (This)->lpVtbl -> EnableExperimentalFeatures(This,NumFeatures,pIIDs,pConfigurationStructs,pConfigurationStructSizes) ) -#define ID3D12Device10_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) +#define ID3D12DeviceFactory_CreateDevice(This,adapter,FeatureLevel,riid,ppvDevice) \ + ( (This)->lpVtbl -> CreateDevice(This,adapter,FeatureLevel,riid,ppvDevice) ) -#define ID3D12Device10_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ - ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) +#endif /* COBJMACROS */ -#define ID3D12Device10_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12Device10_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) +#endif /* C style interface */ -#define ID3D12Device10_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) -#define ID3D12Device10_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ - ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) -#define ID3D12Device10_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) -#define ID3D12Device10_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ - ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) +#endif /* __ID3D12DeviceFactory_INTERFACE_DEFINED__ */ -#define ID3D12Device10_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ - ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) -#define ID3D12Device10_CreateConstantBufferView(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) +/* interface __MIDL_itf_d3d12_0000_0074 */ +/* [local] */ -#define ID3D12Device10_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) +typedef +enum D3D12_DEVICE_FLAGS + { + D3D12_DEVICE_FLAG_NONE = 0, + D3D12_DEVICE_FLAG_DEBUG_LAYER_ENABLED = 0x1, + D3D12_DEVICE_FLAG_GPU_BASED_VALIDATION_ENABLED = 0x2, + D3D12_DEVICE_FLAG_SYNCHRONIZED_COMMAND_QUEUE_VALIDATION_DISABLED = 0x4, + D3D12_DEVICE_FLAG_DRED_AUTO_BREADCRUMBS_ENABLED = 0x8, + D3D12_DEVICE_FLAG_DRED_PAGE_FAULT_REPORTING_ENABLED = 0x10, + D3D12_DEVICE_FLAG_DRED_WATSON_REPORTING_ENABLED = 0x20, + D3D12_DEVICE_FLAG_DRED_BREADCRUMB_CONTEXT_ENABLED = 0x40, + D3D12_DEVICE_FLAG_DRED_USE_MARKERS_ONLY_BREADCRUMBS = 0x80, + D3D12_DEVICE_FLAG_SHADER_INSTRUMENTATION_ENABLED = 0x100, + D3D12_DEVICE_FLAG_AUTO_DEBUG_NAME_ENABLED = 0x200, + D3D12_DEVICE_FLAG_FORCE_LEGACY_STATE_VALIDATION = 0x400 + } D3D12_DEVICE_FLAGS; -#define ID3D12Device10_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) +DEFINE_ENUM_FLAG_OPERATORS( D3D12_DEVICE_FLAGS ) +typedef struct D3D12_DEVICE_CONFIGURATION_DESC + { + D3D12_DEVICE_FLAGS Flags; + UINT GpuBasedValidationFlags; + UINT SDKVersion; + UINT NumEnabledExperimentalFeatures; + } D3D12_DEVICE_CONFIGURATION_DESC; -#define ID3D12Device10_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12Device10_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) -#define ID3D12Device10_CreateSampler(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0074_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0074_v0_0_s_ifspec; -#define ID3D12Device10_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) +#ifndef __ID3D12DeviceConfiguration_INTERFACE_DEFINED__ +#define __ID3D12DeviceConfiguration_INTERFACE_DEFINED__ -#define ID3D12Device10_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) -#if !defined(_WIN32) +/* interface ID3D12DeviceConfiguration */ +/* [unique][local][object][uuid] */ -#define ID3D12Device10_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) + +EXTERN_C const IID IID_ID3D12DeviceConfiguration; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("78dbf87b-f766-422b-a61c-c8c446bdb9ad") + ID3D12DeviceConfiguration : public IUnknown + { + public: +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) + virtual D3D12_DEVICE_CONFIGURATION_DESC STDMETHODCALLTYPE GetDesc( void) = 0; #else -#define ID3D12Device10_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) + virtual D3D12_DEVICE_CONFIGURATION_DESC *STDMETHODCALLTYPE GetDesc( + D3D12_DEVICE_CONFIGURATION_DESC * RetVal) = 0; #endif -#if !defined(_WIN32) + + virtual HRESULT STDMETHODCALLTYPE GetEnabledExperimentalFeatures( + _Out_writes_(NumGuids) GUID *pGuids, + UINT NumGuids) = 0; + + virtual HRESULT STDMETHODCALLTYPE SerializeVersionedRootSignature( + _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *pDesc, + _COM_Outptr_ ID3DBlob **ppResult, + _Always_(_Outptr_opt_result_maybenull_) ID3DBlob **ppError) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateVersionedRootSignatureDeserializer( + _In_reads_bytes_(Size) const void *pBlob, + SIZE_T Size, + REFIID riid, + _COM_Outptr_ void **ppvDeserializer) = 0; + + }; + + +#else /* C style interface */ -#define ID3D12Device10_GetCustomHeapProperties(This,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) + typedef struct ID3D12DeviceConfigurationVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceConfiguration * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceConfiguration * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceConfiguration * This); + + DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, GetDesc) +#if !defined(_WIN32) + D3D12_DEVICE_CONFIGURATION_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12DeviceConfiguration * This); + #else -#define ID3D12Device10_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) + D3D12_DEVICE_CONFIGURATION_DESC *( STDMETHODCALLTYPE *GetDesc )( + ID3D12DeviceConfiguration * This, + D3D12_DEVICE_CONFIGURATION_DESC * RetVal); + #endif + + DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, GetEnabledExperimentalFeatures) + HRESULT ( STDMETHODCALLTYPE *GetEnabledExperimentalFeatures )( + ID3D12DeviceConfiguration * This, + _Out_writes_(NumGuids) GUID *pGuids, + UINT NumGuids); + + DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, SerializeVersionedRootSignature) + HRESULT ( STDMETHODCALLTYPE *SerializeVersionedRootSignature )( + ID3D12DeviceConfiguration * This, + _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *pDesc, + _COM_Outptr_ ID3DBlob **ppResult, + _Always_(_Outptr_opt_result_maybenull_) ID3DBlob **ppError); + + DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, CreateVersionedRootSignatureDeserializer) + HRESULT ( STDMETHODCALLTYPE *CreateVersionedRootSignatureDeserializer )( + ID3D12DeviceConfiguration * This, + _In_reads_bytes_(Size) const void *pBlob, + SIZE_T Size, + REFIID riid, + _COM_Outptr_ void **ppvDeserializer); + + END_INTERFACE + } ID3D12DeviceConfigurationVtbl; -#define ID3D12Device10_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) + interface ID3D12DeviceConfiguration + { + CONST_VTBL struct ID3D12DeviceConfigurationVtbl *lpVtbl; + }; -#define ID3D12Device10_CreateHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) + -#define ID3D12Device10_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#ifdef COBJMACROS -#define ID3D12Device10_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) -#define ID3D12Device10_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ - ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) +#define ID3D12DeviceConfiguration_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12Device10_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ - ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) +#define ID3D12DeviceConfiguration_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12Device10_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ - ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) +#define ID3D12DeviceConfiguration_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Device10_MakeResident(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) +#if !defined(_WIN32) -#define ID3D12Device10_Evict(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) +#define ID3D12DeviceConfiguration_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) +#else +#define ID3D12DeviceConfiguration_GetDesc(This,RetVal) \ + ( (This)->lpVtbl -> GetDesc(This,RetVal) ) +#endif -#define ID3D12Device10_CreateFence(This,InitialValue,Flags,riid,ppFence) \ - ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) +#define ID3D12DeviceConfiguration_GetEnabledExperimentalFeatures(This,pGuids,NumGuids) \ + ( (This)->lpVtbl -> GetEnabledExperimentalFeatures(This,pGuids,NumGuids) ) -#define ID3D12Device10_GetDeviceRemovedReason(This) \ - ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) +#define ID3D12DeviceConfiguration_SerializeVersionedRootSignature(This,pDesc,ppResult,ppError) \ + ( (This)->lpVtbl -> SerializeVersionedRootSignature(This,pDesc,ppResult,ppError) ) + +#define ID3D12DeviceConfiguration_CreateVersionedRootSignatureDeserializer(This,pBlob,Size,riid,ppvDeserializer) \ + ( (This)->lpVtbl -> CreateVersionedRootSignatureDeserializer(This,pBlob,Size,riid,ppvDeserializer) ) -#define ID3D12Device10_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) +#endif /* COBJMACROS */ -#define ID3D12Device10_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) -#define ID3D12Device10_SetStablePowerState(This,Enable) \ - ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) +#endif /* C style interface */ -#define ID3D12Device10_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ - ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) -#define ID3D12Device10_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ - ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) -#if !defined(_WIN32) -#define ID3D12Device10_GetAdapterLuid(This) \ - ( (This)->lpVtbl -> GetAdapterLuid(This) ) -#else -#define ID3D12Device10_GetAdapterLuid(This,RetVal) \ - ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) -#endif +#endif /* __ID3D12DeviceConfiguration_INTERFACE_DEFINED__ */ -#define ID3D12Device10_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ - ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) -#define ID3D12Device10_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ - ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) +#ifndef __ID3D12DeviceConfiguration1_INTERFACE_DEFINED__ +#define __ID3D12DeviceConfiguration1_INTERFACE_DEFINED__ -#define ID3D12Device10_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ - ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) +/* interface ID3D12DeviceConfiguration1 */ +/* [unique][local][object][uuid] */ -#define ID3D12Device10_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) +EXTERN_C const IID IID_ID3D12DeviceConfiguration1; +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ed342442-6343-4e16-bb82-a3a577874e56") + ID3D12DeviceConfiguration1 : public ID3D12DeviceConfiguration + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateVersionedRootSignatureDeserializerFromSubobjectInLibrary( + _In_reads_bytes_(Size) const void *pLibraryBlob, + SIZE_T Size, + LPCWSTR RootSignatureSubobjectName, + REFIID riid, + _COM_Outptr_ void **ppvDeserializer) = 0; + + }; + + +#else /* C style interface */ -#define ID3D12Device10_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) + typedef struct ID3D12DeviceConfiguration1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DeviceConfiguration1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DeviceConfiguration1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DeviceConfiguration1 * This); + + DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, GetDesc) +#if !defined(_WIN32) + D3D12_DEVICE_CONFIGURATION_DESC ( STDMETHODCALLTYPE *GetDesc )( + ID3D12DeviceConfiguration1 * This); + +#else + D3D12_DEVICE_CONFIGURATION_DESC *( STDMETHODCALLTYPE *GetDesc )( + ID3D12DeviceConfiguration1 * This, + D3D12_DEVICE_CONFIGURATION_DESC * RetVal); + +#endif + + DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, GetEnabledExperimentalFeatures) + HRESULT ( STDMETHODCALLTYPE *GetEnabledExperimentalFeatures )( + ID3D12DeviceConfiguration1 * This, + _Out_writes_(NumGuids) GUID *pGuids, + UINT NumGuids); + + DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, SerializeVersionedRootSignature) + HRESULT ( STDMETHODCALLTYPE *SerializeVersionedRootSignature )( + ID3D12DeviceConfiguration1 * This, + _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *pDesc, + _COM_Outptr_ ID3DBlob **ppResult, + _Always_(_Outptr_opt_result_maybenull_) ID3DBlob **ppError); + + DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, CreateVersionedRootSignatureDeserializer) + HRESULT ( STDMETHODCALLTYPE *CreateVersionedRootSignatureDeserializer )( + ID3D12DeviceConfiguration1 * This, + _In_reads_bytes_(Size) const void *pBlob, + SIZE_T Size, + REFIID riid, + _COM_Outptr_ void **ppvDeserializer); + + DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration1, CreateVersionedRootSignatureDeserializerFromSubobjectInLibrary) + HRESULT ( STDMETHODCALLTYPE *CreateVersionedRootSignatureDeserializerFromSubobjectInLibrary )( + ID3D12DeviceConfiguration1 * This, + _In_reads_bytes_(Size) const void *pLibraryBlob, + SIZE_T Size, + LPCWSTR RootSignatureSubobjectName, + REFIID riid, + _COM_Outptr_ void **ppvDeserializer); + + END_INTERFACE + } ID3D12DeviceConfiguration1Vtbl; -#define ID3D12Device10_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) + interface ID3D12DeviceConfiguration1 + { + CONST_VTBL struct ID3D12DeviceConfiguration1Vtbl *lpVtbl; + }; -#define ID3D12Device10_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ - ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) + +#ifdef COBJMACROS -#define ID3D12Device10_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) -#define ID3D12Device10_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ - ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) +#define ID3D12DeviceConfiguration1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12Device10_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) +#define ID3D12DeviceConfiguration1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12Device10_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) +#define ID3D12DeviceConfiguration1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Device10_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) #if !defined(_WIN32) -#define ID3D12Device10_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#define ID3D12DeviceConfiguration1_GetDesc(This) \ + ( (This)->lpVtbl -> GetDesc(This) ) #else -#define ID3D12Device10_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) +#define ID3D12DeviceConfiguration1_GetDesc(This,RetVal) \ + ( (This)->lpVtbl -> GetDesc(This,RetVal) ) #endif +#define ID3D12DeviceConfiguration1_GetEnabledExperimentalFeatures(This,pGuids,NumGuids) \ + ( (This)->lpVtbl -> GetEnabledExperimentalFeatures(This,pGuids,NumGuids) ) -#define ID3D12Device10_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ - ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) +#define ID3D12DeviceConfiguration1_SerializeVersionedRootSignature(This,pDesc,ppResult,ppError) \ + ( (This)->lpVtbl -> SerializeVersionedRootSignature(This,pDesc,ppResult,ppError) ) -#define ID3D12Device10_RemoveDevice(This) \ - ( (This)->lpVtbl -> RemoveDevice(This) ) +#define ID3D12DeviceConfiguration1_CreateVersionedRootSignatureDeserializer(This,pBlob,Size,riid,ppvDeserializer) \ + ( (This)->lpVtbl -> CreateVersionedRootSignatureDeserializer(This,pBlob,Size,riid,ppvDeserializer) ) -#define ID3D12Device10_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) -#define ID3D12Device10_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) +#define ID3D12DeviceConfiguration1_CreateVersionedRootSignatureDeserializerFromSubobjectInLibrary(This,pLibraryBlob,Size,RootSignatureSubobjectName,riid,ppvDeserializer) \ + ( (This)->lpVtbl -> CreateVersionedRootSignatureDeserializerFromSubobjectInLibrary(This,pLibraryBlob,Size,RootSignatureSubobjectName,riid,ppvDeserializer) ) -#define ID3D12Device10_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ - ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) +#endif /* COBJMACROS */ -#define ID3D12Device10_CreateStateObject(This,pDesc,riid,ppStateObject) \ - ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) -#define ID3D12Device10_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ - ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) +#endif /* C style interface */ -#define ID3D12Device10_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ - ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) -#define ID3D12Device10_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ - ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) +#endif /* __ID3D12DeviceConfiguration1_INTERFACE_DEFINED__ */ -#define ID3D12Device10_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) \ - ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) -#define ID3D12Device10_CreateProtectedResourceSession1(This,pDesc,riid,ppSession) \ - ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) +/* interface __MIDL_itf_d3d12_0000_0076 */ +/* [local] */ -#if !defined(_WIN32) +typedef +enum D3D12_STATE_OBJECT_DATABASE_FLAGS + { + D3D12_STATE_OBJECT_DATABASE_FLAG_NONE = 0, + D3D12_STATE_OBJECT_DATABASE_FLAG_READ_ONLY = 0x1 + } D3D12_STATE_OBJECT_DATABASE_FLAGS; -#define ID3D12Device10_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) -#else -#define ID3D12Device10_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) -#endif +DEFINE_ENUM_FLAG_OPERATORS( D3D12_STATE_OBJECT_DATABASE_FLAGS ) -#define ID3D12Device10_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) -#define ID3D12Device10_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0076_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0076_v0_0_s_ifspec; -#define ID3D12Device10_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) +#ifndef __ID3D12StateObjectDatabaseFactory_INTERFACE_DEFINED__ +#define __ID3D12StateObjectDatabaseFactory_INTERFACE_DEFINED__ -#define ID3D12Device10_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) +/* interface ID3D12StateObjectDatabaseFactory */ +/* [unique][local][object][uuid] */ -#define ID3D12Device10_CreateShaderCacheSession(This,pDesc,riid,ppvSession) \ - ( (This)->lpVtbl -> CreateShaderCacheSession(This,pDesc,riid,ppvSession) ) +EXTERN_C const IID IID_ID3D12StateObjectDatabaseFactory; -#define ID3D12Device10_ShaderCacheControl(This,Kinds,Control) \ - ( (This)->lpVtbl -> ShaderCacheControl(This,Kinds,Control) ) +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("f5b066f0-648a-4611-bd41-27fd0948b9eb") + ID3D12StateObjectDatabaseFactory : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateStateObjectDatabaseFromFile( + LPCWSTR pDatabaseFile, + D3D12_STATE_OBJECT_DATABASE_FLAGS flags, + REFIID riid, + _COM_Outptr_ void **ppvStateObjectDatabase) = 0; + + }; + + +#else /* C style interface */ -#define ID3D12Device10_CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) ) + typedef struct ID3D12StateObjectDatabaseFactoryVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12StateObjectDatabaseFactory * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12StateObjectDatabaseFactory * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12StateObjectDatabaseFactory * This); + + DECLSPEC_XFGVIRT(ID3D12StateObjectDatabaseFactory, CreateStateObjectDatabaseFromFile) + HRESULT ( STDMETHODCALLTYPE *CreateStateObjectDatabaseFromFile )( + ID3D12StateObjectDatabaseFactory * This, + LPCWSTR pDatabaseFile, + D3D12_STATE_OBJECT_DATABASE_FLAGS flags, + REFIID riid, + _COM_Outptr_ void **ppvStateObjectDatabase); + + END_INTERFACE + } ID3D12StateObjectDatabaseFactoryVtbl; + interface ID3D12StateObjectDatabaseFactory + { + CONST_VTBL struct ID3D12StateObjectDatabaseFactoryVtbl *lpVtbl; + }; -#define ID3D12Device10_CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) ) + -#define ID3D12Device10_CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) ) +#ifdef COBJMACROS + + +#define ID3D12StateObjectDatabaseFactory_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12StateObjectDatabaseFactory_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12StateObjectDatabaseFactory_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Device10_CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) ) + +#define ID3D12StateObjectDatabaseFactory_CreateStateObjectDatabaseFromFile(This,pDatabaseFile,flags,riid,ppvStateObjectDatabase) \ + ( (This)->lpVtbl -> CreateStateObjectDatabaseFromFile(This,pDatabaseFile,flags,riid,ppvStateObjectDatabase) ) #endif /* COBJMACROS */ @@ -23292,713 +31308,621 @@ EXTERN_C const IID IID_ID3D12Device10; -#endif /* __ID3D12Device10_INTERFACE_DEFINED__ */ +#endif /* __ID3D12StateObjectDatabaseFactory_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12_0000_0077 */ +/* [local] */ + +typedef +enum D3D12_AXIS_SHADING_RATE + { + D3D12_AXIS_SHADING_RATE_1X = 0, + D3D12_AXIS_SHADING_RATE_2X = 0x1, + D3D12_AXIS_SHADING_RATE_4X = 0x2 + } D3D12_AXIS_SHADING_RATE; + +#define D3D12_SHADING_RATE_X_AXIS_SHIFT 2 +#define D3D12_SHADING_RATE_VALID_MASK 3 +#define D3D12_MAKE_COARSE_SHADING_RATE(x,y) ((x) << D3D12_SHADING_RATE_X_AXIS_SHIFT | (y)) +#define D3D12_GET_COARSE_SHADING_RATE_X_AXIS(x) (((x) >> D3D12_SHADING_RATE_X_AXIS_SHIFT) & D3D12_SHADING_RATE_VALID_MASK) +#define D3D12_GET_COARSE_SHADING_RATE_Y_AXIS(y) ((y) & D3D12_SHADING_RATE_VALID_MASK) +typedef +enum D3D12_SHADING_RATE + { + D3D12_SHADING_RATE_1X1 = 0, + D3D12_SHADING_RATE_1X2 = 0x1, + D3D12_SHADING_RATE_2X1 = 0x4, + D3D12_SHADING_RATE_2X2 = 0x5, + D3D12_SHADING_RATE_2X4 = 0x6, + D3D12_SHADING_RATE_4X2 = 0x9, + D3D12_SHADING_RATE_4X4 = 0xa + } D3D12_SHADING_RATE; + +typedef +enum D3D12_SHADING_RATE_COMBINER + { + D3D12_SHADING_RATE_COMBINER_PASSTHROUGH = 0, + D3D12_SHADING_RATE_COMBINER_OVERRIDE = 1, + D3D12_SHADING_RATE_COMBINER_MIN = 2, + D3D12_SHADING_RATE_COMBINER_MAX = 3, + D3D12_SHADING_RATE_COMBINER_SUM = 4 + } D3D12_SHADING_RATE_COMBINER; + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0077_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0077_v0_0_s_ifspec; -#ifndef __ID3D12Device11_INTERFACE_DEFINED__ -#define __ID3D12Device11_INTERFACE_DEFINED__ +#ifndef __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__ -/* interface ID3D12Device11 */ +/* interface ID3D12GraphicsCommandList5 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12Device11; +EXTERN_C const IID IID_ID3D12GraphicsCommandList5; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("5405c344-d457-444e-b4dd-2366e45aee39") - ID3D12Device11 : public ID3D12Device10 + MIDL_INTERFACE("55050859-4024-474c-87f5-6472eaee44ea") + ID3D12GraphicsCommandList5 : public ID3D12GraphicsCommandList4 { public: - virtual void STDMETHODCALLTYPE CreateSampler2( - _In_ const D3D12_SAMPLER_DESC2 *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) = 0; + virtual void STDMETHODCALLTYPE RSSetShadingRate( + _In_ D3D12_SHADING_RATE baseShadingRate, + _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT) const D3D12_SHADING_RATE_COMBINER *combiners) = 0; + + virtual void STDMETHODCALLTYPE RSSetShadingRateImage( + _In_opt_ ID3D12Resource *shadingRateImage) = 0; }; #else /* C style interface */ - typedef struct ID3D12Device11Vtbl + typedef struct ID3D12GraphicsCommandList5Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Device11 * This, + ID3D12GraphicsCommandList5 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Device11 * This); + ID3D12GraphicsCommandList5 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Device11 * This); + ID3D12GraphicsCommandList5 * This); DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12Device11 * This, + ID3D12GraphicsCommandList5 * This, _In_ REFGUID guid, _Inout_ UINT *pDataSize, _Out_writes_bytes_opt_( *pDataSize ) void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12Device11 * This, + ID3D12GraphicsCommandList5 * This, _In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_( DataSize ) const void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12Device11 * This, + ID3D12GraphicsCommandList5 * This, _In_ REFGUID guid, _In_opt_ const IUnknown *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetName) HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12Device11 * This, + ID3D12GraphicsCommandList5 * This, _In_z_ LPCWSTR Name); - DECLSPEC_XFGVIRT(ID3D12Device, GetNodeCount) - UINT ( STDMETHODCALLTYPE *GetNodeCount )( - ID3D12Device11 * This); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandQueue) - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue )( - ID3D12Device11 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandAllocator) - HRESULT ( STDMETHODCALLTYPE *CreateCommandAllocator )( - ID3D12Device11 * This, - _In_ D3D12_COMMAND_LIST_TYPE type, - REFIID riid, - _COM_Outptr_ void **ppCommandAllocator); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateGraphicsPipelineState) - HRESULT ( STDMETHODCALLTYPE *CreateGraphicsPipelineState )( - ID3D12Device11 * This, - _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateComputePipelineState) - HRESULT ( STDMETHODCALLTYPE *CreateComputePipelineState )( - ID3D12Device11 * This, - _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandList) - HRESULT ( STDMETHODCALLTYPE *CreateCommandList )( - ID3D12Device11 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ ID3D12CommandAllocator *pCommandAllocator, - _In_opt_ ID3D12PipelineState *pInitialState, - REFIID riid, - _COM_Outptr_ void **ppCommandList); - - DECLSPEC_XFGVIRT(ID3D12Device, CheckFeatureSupport) - HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( - ID3D12Device11 * This, - D3D12_FEATURE Feature, - _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, - UINT FeatureSupportDataSize); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateDescriptorHeap) - HRESULT ( STDMETHODCALLTYPE *CreateDescriptorHeap )( - ID3D12Device11 * This, - _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc, - REFIID riid, - _COM_Outptr_ void **ppvHeap); - - DECLSPEC_XFGVIRT(ID3D12Device, GetDescriptorHandleIncrementSize) - UINT ( STDMETHODCALLTYPE *GetDescriptorHandleIncrementSize )( - ID3D12Device11 * This, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateRootSignature) - HRESULT ( STDMETHODCALLTYPE *CreateRootSignature )( - ID3D12Device11 * This, - _In_ UINT nodeMask, - _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature, - _In_ SIZE_T blobLengthInBytes, + DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12GraphicsCommandList5 * This, REFIID riid, - _COM_Outptr_ void **ppvRootSignature); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateConstantBufferView) - void ( STDMETHODCALLTYPE *CreateConstantBufferView )( - ID3D12Device11 * This, - _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateShaderResourceView) - void ( STDMETHODCALLTYPE *CreateShaderResourceView )( - ID3D12Device11 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); - - DECLSPEC_XFGVIRT(ID3D12Device, CreateUnorderedAccessView) - void ( STDMETHODCALLTYPE *CreateUnorderedAccessView )( - ID3D12Device11 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ ID3D12Resource *pCounterResource, - _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + _COM_Outptr_opt_ void **ppvDevice); - DECLSPEC_XFGVIRT(ID3D12Device, CreateRenderTargetView) - void ( STDMETHODCALLTYPE *CreateRenderTargetView )( - ID3D12Device11 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12CommandList, GetType) + D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( + ID3D12GraphicsCommandList5 * This); - DECLSPEC_XFGVIRT(ID3D12Device, CreateDepthStencilView) - void ( STDMETHODCALLTYPE *CreateDepthStencilView )( - ID3D12Device11 * This, - _In_opt_ ID3D12Resource *pResource, - _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close) + HRESULT ( STDMETHODCALLTYPE *Close )( + ID3D12GraphicsCommandList5 * This); - DECLSPEC_XFGVIRT(ID3D12Device, CreateSampler) - void ( STDMETHODCALLTYPE *CreateSampler )( - ID3D12Device11 * This, - _In_ const D3D12_SAMPLER_DESC *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset) + HRESULT ( STDMETHODCALLTYPE *Reset )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12CommandAllocator *pAllocator, + _In_opt_ ID3D12PipelineState *pInitialState); - DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptors) - void ( STDMETHODCALLTYPE *CopyDescriptors )( - ID3D12Device11 * This, - _In_ UINT NumDestDescriptorRanges, - _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts, - _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes, - _In_ UINT NumSrcDescriptorRanges, - _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts, - _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState) + void ( STDMETHODCALLTYPE *ClearState )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ ID3D12PipelineState *pPipelineState); - DECLSPEC_XFGVIRT(ID3D12Device, CopyDescriptorsSimple) - void ( STDMETHODCALLTYPE *CopyDescriptorsSimple )( - ID3D12Device11 * This, - _In_ UINT NumDescriptors, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, - _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced) + void ( STDMETHODCALLTYPE *DrawInstanced )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT VertexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartVertexLocation, + _In_ UINT StartInstanceLocation); - DECLSPEC_XFGVIRT(ID3D12Device, GetResourceAllocationInfo) -#if !defined(_WIN32) - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device11 * This, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced) + void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT IndexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartIndexLocation, + _In_ INT BaseVertexLocation, + _In_ UINT StartInstanceLocation); -#else - D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo )( - ID3D12Device11 * This, - D3D12_RESOURCE_ALLOCATION_INFO * RetVal, - _In_ UINT visibleMask, - _In_ UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch) + void ( STDMETHODCALLTYPE *Dispatch )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ); -#endif + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion) + void ( STDMETHODCALLTYPE *CopyBufferRegion )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT64 NumBytes); - DECLSPEC_XFGVIRT(ID3D12Device, GetCustomHeapProperties) -#if !defined(_WIN32) - D3D12_HEAP_PROPERTIES ( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device11 * This, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion) + void ( STDMETHODCALLTYPE *CopyTextureRegion )( + ID3D12GraphicsCommandList5 * This, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, + UINT DstX, + UINT DstY, + UINT DstZ, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, + _In_opt_ const D3D12_BOX *pSrcBox); -#else - D3D12_HEAP_PROPERTIES *( STDMETHODCALLTYPE *GetCustomHeapProperties )( - ID3D12Device11 * This, - D3D12_HEAP_PROPERTIES * RetVal, - _In_ UINT nodeMask, - D3D12_HEAP_TYPE heapType); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource) + void ( STDMETHODCALLTYPE *CopyResource )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pDstResource, + _In_ ID3D12Resource *pSrcResource); -#endif + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles) + void ( STDMETHODCALLTYPE *CopyTiles )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pTiledResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, + _In_ ID3D12Resource *pBuffer, + UINT64 BufferStartOffsetInBytes, + D3D12_TILE_COPY_FLAGS Flags); - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommittedResource) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource )( - ID3D12Device11 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource) + void ( STDMETHODCALLTYPE *ResolveSubresource )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_ DXGI_FORMAT Format); - DECLSPEC_XFGVIRT(ID3D12Device, CreateHeap) - HRESULT ( STDMETHODCALLTYPE *CreateHeap )( - ID3D12Device11 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology) + void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); - DECLSPEC_XFGVIRT(ID3D12Device, CreatePlacedResource) - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource )( - ID3D12Device11 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports) + void ( STDMETHODCALLTYPE *RSSetViewports )( + ID3D12GraphicsCommandList5 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, + _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); - DECLSPEC_XFGVIRT(ID3D12Device, CreateReservedResource) - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource )( - ID3D12Device11 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects) + void ( STDMETHODCALLTYPE *RSSetScissorRects )( + ID3D12GraphicsCommandList5 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, + _In_reads_( NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(ID3D12Device, CreateSharedHandle) - HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( - ID3D12Device11 * This, - _In_ ID3D12DeviceChild *pObject, - _In_opt_ const SECURITY_ATTRIBUTES *pAttributes, - DWORD Access, - _In_opt_ LPCWSTR Name, - _Out_ HANDLE *pHandle); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor) + void ( STDMETHODCALLTYPE *OMSetBlendFactor )( + ID3D12GraphicsCommandList5 * This, + _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); - DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandle) - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandle )( - ID3D12Device11 * This, - _In_ HANDLE NTHandle, - REFIID riid, - _COM_Outptr_opt_ void **ppvObj); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef) + void ( STDMETHODCALLTYPE *OMSetStencilRef )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT StencilRef); - DECLSPEC_XFGVIRT(ID3D12Device, OpenSharedHandleByName) - HRESULT ( STDMETHODCALLTYPE *OpenSharedHandleByName )( - ID3D12Device11 * This, - _In_ LPCWSTR Name, - DWORD Access, - /* [annotation][out] */ - _Out_ HANDLE *pNTHandle); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState) + void ( STDMETHODCALLTYPE *SetPipelineState )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12PipelineState *pPipelineState); - DECLSPEC_XFGVIRT(ID3D12Device, MakeResident) - HRESULT ( STDMETHODCALLTYPE *MakeResident )( - ID3D12Device11 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier) + void ( STDMETHODCALLTYPE *ResourceBarrier )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT NumBarriers, + _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); - DECLSPEC_XFGVIRT(ID3D12Device, Evict) - HRESULT ( STDMETHODCALLTYPE *Evict )( - ID3D12Device11 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle) + void ( STDMETHODCALLTYPE *ExecuteBundle )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12GraphicsCommandList *pCommandList); - DECLSPEC_XFGVIRT(ID3D12Device, CreateFence) - HRESULT ( STDMETHODCALLTYPE *CreateFence )( - ID3D12Device11 * This, - UINT64 InitialValue, - D3D12_FENCE_FLAGS Flags, - REFIID riid, - _COM_Outptr_ void **ppFence); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps) + void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT NumDescriptorHeaps, + _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); - DECLSPEC_XFGVIRT(ID3D12Device, GetDeviceRemovedReason) - HRESULT ( STDMETHODCALLTYPE *GetDeviceRemovedReason )( - ID3D12Device11 * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature) + void ( STDMETHODCALLTYPE *SetComputeRootSignature )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); - DECLSPEC_XFGVIRT(ID3D12Device, GetCopyableFootprints) - void ( STDMETHODCALLTYPE *GetCopyableFootprints )( - ID3D12Device11 * This, - _In_ const D3D12_RESOURCE_DESC *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature) + void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); - DECLSPEC_XFGVIRT(ID3D12Device, CreateQueryHeap) - HRESULT ( STDMETHODCALLTYPE *CreateQueryHeap )( - ID3D12Device11 * This, - _In_ const D3D12_QUERY_HEAP_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable) + void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - DECLSPEC_XFGVIRT(ID3D12Device, SetStablePowerState) - HRESULT ( STDMETHODCALLTYPE *SetStablePowerState )( - ID3D12Device11 * This, - BOOL Enable); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable) + void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - DECLSPEC_XFGVIRT(ID3D12Device, CreateCommandSignature) - HRESULT ( STDMETHODCALLTYPE *CreateCommandSignature )( - ID3D12Device11 * This, - _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc, - _In_opt_ ID3D12RootSignature *pRootSignature, - REFIID riid, - _COM_Outptr_opt_ void **ppvCommandSignature); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant) + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); - DECLSPEC_XFGVIRT(ID3D12Device, GetResourceTiling) - void ( STDMETHODCALLTYPE *GetResourceTiling )( - ID3D12Device11 * This, - _In_ ID3D12Resource *pTiledResource, - _Out_opt_ UINT *pNumTilesForEntireResource, - _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc, - _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips, - _Inout_opt_ UINT *pNumSubresourceTilings, - _In_ UINT FirstSubresourceTilingToGet, - _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant) + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); - DECLSPEC_XFGVIRT(ID3D12Device, GetAdapterLuid) -#if !defined(_WIN32) - LUID ( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device11 * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants) + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); -#else - LUID *( STDMETHODCALLTYPE *GetAdapterLuid )( - ID3D12Device11 * This, - LUID * RetVal); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants) + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); -#endif + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView) + void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device1, CreatePipelineLibrary) - HRESULT ( STDMETHODCALLTYPE *CreatePipelineLibrary )( - ID3D12Device11 * This, - _In_reads_(BlobLength) const void *pLibraryBlob, - SIZE_T BlobLength, - REFIID riid, - _COM_Outptr_ void **ppPipelineLibrary); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView) + void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device1, SetEventOnMultipleFenceCompletion) - HRESULT ( STDMETHODCALLTYPE *SetEventOnMultipleFenceCompletion )( - ID3D12Device11 * This, - _In_reads_(NumFences) ID3D12Fence *const *ppFences, - _In_reads_(NumFences) const UINT64 *pFenceValues, - UINT NumFences, - D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, - HANDLE hEvent); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView) + void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device1, SetResidencyPriority) - HRESULT ( STDMETHODCALLTYPE *SetResidencyPriority )( - ID3D12Device11 * This, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_reads_(NumObjects) const D3D12_RESIDENCY_PRIORITY *pPriorities); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView) + void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device2, CreatePipelineState) - HRESULT ( STDMETHODCALLTYPE *CreatePipelineState )( - ID3D12Device11 * This, - const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppPipelineState); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView) + void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromAddress) - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromAddress )( - ID3D12Device11 * This, - _In_ const void *pAddress, - REFIID riid, - _COM_Outptr_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView) + void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); - DECLSPEC_XFGVIRT(ID3D12Device3, OpenExistingHeapFromFileMapping) - HRESULT ( STDMETHODCALLTYPE *OpenExistingHeapFromFileMapping )( - ID3D12Device11 * This, - _In_ HANDLE hFileMapping, - REFIID riid, - _COM_Outptr_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer) + void ( STDMETHODCALLTYPE *IASetIndexBuffer )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); - DECLSPEC_XFGVIRT(ID3D12Device3, EnqueueMakeResident) - HRESULT ( STDMETHODCALLTYPE *EnqueueMakeResident )( - ID3D12Device11 * This, - D3D12_RESIDENCY_FLAGS Flags, - UINT NumObjects, - _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects, - _In_ ID3D12Fence *pFenceToSignal, - UINT64 FenceValueToSignal); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers) + void ( STDMETHODCALLTYPE *IASetVertexBuffers )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommandList1) - HRESULT ( STDMETHODCALLTYPE *CreateCommandList1 )( - ID3D12Device11 * This, - _In_ UINT nodeMask, - _In_ D3D12_COMMAND_LIST_TYPE type, - _In_ D3D12_COMMAND_LIST_FLAGS flags, - REFIID riid, - _COM_Outptr_ void **ppCommandList); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets) + void ( STDMETHODCALLTYPE *SOSetTargets )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateProtectedResourceSession) - HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession )( - ID3D12Device11 * This, - _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC *pDesc, - _In_ REFIID riid, - _COM_Outptr_ void **ppSession); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets) + void ( STDMETHODCALLTYPE *OMSetRenderTargets )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT NumRenderTargetDescriptors, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, + _In_ BOOL RTsSingleHandleToDescriptorRange, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateCommittedResource1) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource1 )( - ID3D12Device11 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView) + void ( STDMETHODCALLTYPE *ClearDepthStencilView )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, + _In_ D3D12_CLEAR_FLAGS ClearFlags, + _In_ FLOAT Depth, + _In_ UINT8 Stencil, + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateHeap1) - HRESULT ( STDMETHODCALLTYPE *CreateHeap1 )( - ID3D12Device11 * This, - _In_ const D3D12_HEAP_DESC *pDesc, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvHeap); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView) + void ( STDMETHODCALLTYPE *ClearRenderTargetView )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, + _In_ const FLOAT ColorRGBA[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(ID3D12Device4, CreateReservedResource1) - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource1 )( - ID3D12Device11 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint) + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const UINT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(ID3D12Device4, GetResourceAllocationInfo1) -#if !defined(_WIN32) - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device11 * This, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat) + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const FLOAT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); -#else - D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo1 )( - ID3D12Device11 * This, - D3D12_RESOURCE_ALLOCATION_INFO * RetVal, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource) + void ( STDMETHODCALLTYPE *DiscardResource )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DISCARD_REGION *pRegion); -#endif + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery) + void ( STDMETHODCALLTYPE *BeginQuery )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); - DECLSPEC_XFGVIRT(ID3D12Device5, CreateLifetimeTracker) - HRESULT ( STDMETHODCALLTYPE *CreateLifetimeTracker )( - ID3D12Device11 * This, - _In_ ID3D12LifetimeOwner *pOwner, - REFIID riid, - _COM_Outptr_ void **ppvTracker); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery) + void ( STDMETHODCALLTYPE *EndQuery )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); - DECLSPEC_XFGVIRT(ID3D12Device5, RemoveDevice) - void ( STDMETHODCALLTYPE *RemoveDevice )( - ID3D12Device11 * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData) + void ( STDMETHODCALLTYPE *ResolveQueryData )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT StartIndex, + _In_ UINT NumQueries, + _In_ ID3D12Resource *pDestinationBuffer, + _In_ UINT64 AlignedDestinationBufferOffset); - DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommands) - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( - ID3D12Device11 * This, - _Inout_ UINT *pNumMetaCommands, - _Out_writes_opt_(*pNumMetaCommands) D3D12_META_COMMAND_DESC *pDescs); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication) + void ( STDMETHODCALLTYPE *SetPredication )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ ID3D12Resource *pBuffer, + _In_ UINT64 AlignedBufferOffset, + _In_ D3D12_PREDICATION_OP Operation); - DECLSPEC_XFGVIRT(ID3D12Device5, EnumerateMetaCommandParameters) - HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandParameters )( - ID3D12Device11 * This, - _In_ REFGUID CommandId, - _In_ D3D12_META_COMMAND_PARAMETER_STAGE Stage, - _Out_opt_ UINT *pTotalStructureSizeInBytes, - _Inout_ UINT *pParameterCount, - _Out_writes_opt_(*pParameterCount) D3D12_META_COMMAND_PARAMETER_DESC *pParameterDescs); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker) + void ( STDMETHODCALLTYPE *SetMarker )( + ID3D12GraphicsCommandList5 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); - DECLSPEC_XFGVIRT(ID3D12Device5, CreateMetaCommand) - HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( - ID3D12Device11 * This, - _In_ REFGUID CommandId, - _In_ UINT NodeMask, - _In_reads_bytes_opt_(CreationParametersDataSizeInBytes) const void *pCreationParametersData, - _In_ SIZE_T CreationParametersDataSizeInBytes, - REFIID riid, - _COM_Outptr_ void **ppMetaCommand); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent) + void ( STDMETHODCALLTYPE *BeginEvent )( + ID3D12GraphicsCommandList5 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); - DECLSPEC_XFGVIRT(ID3D12Device5, CreateStateObject) - HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( - ID3D12Device11 * This, - const D3D12_STATE_OBJECT_DESC *pDesc, - REFIID riid, - _COM_Outptr_ void **ppStateObject); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent) + void ( STDMETHODCALLTYPE *EndEvent )( + ID3D12GraphicsCommandList5 * This); - DECLSPEC_XFGVIRT(ID3D12Device5, GetRaytracingAccelerationStructurePrebuildInfo) - void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( - ID3D12Device11 * This, - _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *pDesc, - _Out_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect) + void ( STDMETHODCALLTYPE *ExecuteIndirect )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12CommandSignature *pCommandSignature, + _In_ UINT MaxCommandCount, + _In_ ID3D12Resource *pArgumentBuffer, + _In_ UINT64 ArgumentBufferOffset, + _In_opt_ ID3D12Resource *pCountBuffer, + _In_ UINT64 CountBufferOffset); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT) + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - DECLSPEC_XFGVIRT(ID3D12Device5, CheckDriverMatchingIdentifier) - D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS ( STDMETHODCALLTYPE *CheckDriverMatchingIdentifier )( - ID3D12Device11 * This, - _In_ D3D12_SERIALIZED_DATA_TYPE SerializedDataType, - _In_ const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *pIdentifierToCheck); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64) + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - DECLSPEC_XFGVIRT(ID3D12Device6, SetBackgroundProcessingMode) - HRESULT ( STDMETHODCALLTYPE *SetBackgroundProcessingMode )( - ID3D12Device11 * This, - D3D12_BACKGROUND_PROCESSING_MODE Mode, - D3D12_MEASUREMENTS_ACTION MeasurementsAction, - _In_opt_ HANDLE hEventToSignalUponCompletion, - _Out_opt_ BOOL *pbFurtherMeasurementsDesired); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds) + void ( STDMETHODCALLTYPE *OMSetDepthBounds )( + ID3D12GraphicsCommandList5 * This, + _In_ FLOAT Min, + _In_ FLOAT Max); - DECLSPEC_XFGVIRT(ID3D12Device7, AddToStateObject) - HRESULT ( STDMETHODCALLTYPE *AddToStateObject )( - ID3D12Device11 * This, - const D3D12_STATE_OBJECT_DESC *pAddition, - ID3D12StateObject *pStateObjectToGrowFrom, - REFIID riid, - _COM_Outptr_ void **ppNewStateObject); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions) + void ( STDMETHODCALLTYPE *SetSamplePositions )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT NumSamplesPerPixel, + _In_ UINT NumPixels, + _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); - DECLSPEC_XFGVIRT(ID3D12Device7, CreateProtectedResourceSession1) - HRESULT ( STDMETHODCALLTYPE *CreateProtectedResourceSession1 )( - ID3D12Device11 * This, - _In_ const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *pDesc, - _In_ REFIID riid, - _COM_Outptr_ void **ppSession); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion) + void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ UINT DstX, + _In_ UINT DstY, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_opt_ D3D12_RECT *pSrcRect, + _In_ DXGI_FORMAT Format, + _In_ D3D12_RESOLVE_MODE ResolveMode); - DECLSPEC_XFGVIRT(ID3D12Device8, GetResourceAllocationInfo2) -#if !defined(_WIN32) - D3D12_RESOURCE_ALLOCATION_INFO ( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( - ID3D12Device11 * This, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask) + void ( STDMETHODCALLTYPE *SetViewInstanceMask )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT Mask); -#else - D3D12_RESOURCE_ALLOCATION_INFO *( STDMETHODCALLTYPE *GetResourceAllocationInfo2 )( - ID3D12Device11 * This, - D3D12_RESOURCE_ALLOCATION_INFO * RetVal, - UINT visibleMask, - UINT numResourceDescs, - _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC1 *pResourceDescs, - _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate) + void ( STDMETHODCALLTYPE *WriteBufferImmediate )( + ID3D12GraphicsCommandList5 * This, + UINT Count, + _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, + _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); -#endif + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession) + void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); - DECLSPEC_XFGVIRT(ID3D12Device8, CreateCommittedResource2) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource2 )( - ID3D12Device11 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_RESOURCE_STATES InitialResourceState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BeginRenderPass) + void ( STDMETHODCALLTYPE *BeginRenderPass )( + ID3D12GraphicsCommandList5 * This, + _In_ UINT NumRenderTargets, + _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, + _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, + D3D12_RENDER_PASS_FLAGS Flags); - DECLSPEC_XFGVIRT(ID3D12Device8, CreatePlacedResource1) - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource1 )( - ID3D12Device11 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_RESOURCE_STATES InitialState, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EndRenderPass) + void ( STDMETHODCALLTYPE *EndRenderPass )( + ID3D12GraphicsCommandList5 * This); - DECLSPEC_XFGVIRT(ID3D12Device8, CreateSamplerFeedbackUnorderedAccessView) - void ( STDMETHODCALLTYPE *CreateSamplerFeedbackUnorderedAccessView )( - ID3D12Device11 * This, - _In_opt_ ID3D12Resource *pTargetedResource, - _In_opt_ ID3D12Resource *pFeedbackResource, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, InitializeMetaCommand) + void ( STDMETHODCALLTYPE *InitializeMetaCommand )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, + _In_ SIZE_T InitializationParametersDataSizeInBytes); - DECLSPEC_XFGVIRT(ID3D12Device8, GetCopyableFootprints1) - void ( STDMETHODCALLTYPE *GetCopyableFootprints1 )( - ID3D12Device11 * This, - _In_ const D3D12_RESOURCE_DESC1 *pResourceDesc, - _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource, - _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources, - UINT64 BaseOffset, - _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts, - _Out_writes_opt_(NumSubresources) UINT *pNumRows, - _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes, - _Out_opt_ UINT64 *pTotalBytes); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, ExecuteMetaCommand) + void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, + _In_ SIZE_T ExecutionParametersDataSizeInBytes); - DECLSPEC_XFGVIRT(ID3D12Device9, CreateShaderCacheSession) - HRESULT ( STDMETHODCALLTYPE *CreateShaderCacheSession )( - ID3D12Device11 * This, - _In_ const D3D12_SHADER_CACHE_SESSION_DESC *pDesc, - REFIID riid, - _COM_Outptr_opt_ void **ppvSession); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BuildRaytracingAccelerationStructure) + void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( + ID3D12GraphicsCommandList5 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, + _In_ UINT NumPostbuildInfoDescs, + _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs); - DECLSPEC_XFGVIRT(ID3D12Device9, ShaderCacheControl) - HRESULT ( STDMETHODCALLTYPE *ShaderCacheControl )( - ID3D12Device11 * This, - D3D12_SHADER_CACHE_KIND_FLAGS Kinds, - D3D12_SHADER_CACHE_CONTROL_FLAGS Control); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EmitRaytracingAccelerationStructurePostbuildInfo) + void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( + ID3D12GraphicsCommandList5 * This, + _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, + _In_ UINT NumSourceAccelerationStructures, + _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData); - DECLSPEC_XFGVIRT(ID3D12Device9, CreateCommandQueue1) - HRESULT ( STDMETHODCALLTYPE *CreateCommandQueue1 )( - ID3D12Device11 * This, - _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc, - REFIID CreatorID, - REFIID riid, - _COM_Outptr_ void **ppCommandQueue); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, CopyRaytracingAccelerationStructure) + void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, + _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, + _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode); - DECLSPEC_XFGVIRT(ID3D12Device10, CreateCommittedResource3) - HRESULT ( STDMETHODCALLTYPE *CreateCommittedResource3 )( - ID3D12Device11 * This, - _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, - D3D12_HEAP_FLAGS HeapFlags, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_BARRIER_LAYOUT InitialLayout, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - UINT32 NumCastableFormats, - _In_opt_count_(NumCastableFormats) DXGI_FORMAT *pCastableFormats, - REFIID riidResource, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, SetPipelineState1) + void ( STDMETHODCALLTYPE *SetPipelineState1 )( + ID3D12GraphicsCommandList5 * This, + _In_ ID3D12StateObject *pStateObject); - DECLSPEC_XFGVIRT(ID3D12Device10, CreatePlacedResource2) - HRESULT ( STDMETHODCALLTYPE *CreatePlacedResource2 )( - ID3D12Device11 * This, - _In_ ID3D12Heap *pHeap, - UINT64 HeapOffset, - _In_ const D3D12_RESOURCE_DESC1 *pDesc, - D3D12_BARRIER_LAYOUT InitialLayout, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - UINT32 NumCastableFormats, - _In_opt_count_(NumCastableFormats) DXGI_FORMAT *pCastableFormats, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, DispatchRays) + void ( STDMETHODCALLTYPE *DispatchRays )( + ID3D12GraphicsCommandList5 * This, + _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc); - DECLSPEC_XFGVIRT(ID3D12Device10, CreateReservedResource2) - HRESULT ( STDMETHODCALLTYPE *CreateReservedResource2 )( - ID3D12Device11 * This, - _In_ const D3D12_RESOURCE_DESC *pDesc, - D3D12_BARRIER_LAYOUT InitialLayout, - _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue, - _In_opt_ ID3D12ProtectedResourceSession *pProtectedSession, - UINT32 NumCastableFormats, - _In_opt_count_(NumCastableFormats) DXGI_FORMAT *pCastableFormats, - REFIID riid, - _COM_Outptr_opt_ void **ppvResource); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRate) + void ( STDMETHODCALLTYPE *RSSetShadingRate )( + ID3D12GraphicsCommandList5 * This, + _In_ D3D12_SHADING_RATE baseShadingRate, + _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT) const D3D12_SHADING_RATE_COMBINER *combiners); - DECLSPEC_XFGVIRT(ID3D12Device11, CreateSampler2) - void ( STDMETHODCALLTYPE *CreateSampler2 )( - ID3D12Device11 * This, - _In_ const D3D12_SAMPLER_DESC2 *pDesc, - _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRateImage) + void ( STDMETHODCALLTYPE *RSSetShadingRateImage )( + ID3D12GraphicsCommandList5 * This, + _In_opt_ ID3D12Resource *shadingRateImage); END_INTERFACE - } ID3D12Device11Vtbl; + } ID3D12GraphicsCommandList5Vtbl; - interface ID3D12Device11 + interface ID3D12GraphicsCommandList5 { - CONST_VTBL struct ID3D12Device11Vtbl *lpVtbl; + CONST_VTBL struct ID3D12GraphicsCommandList5Vtbl *lpVtbl; }; @@ -24006,780 +31930,852 @@ EXTERN_C const IID IID_ID3D12Device11; #ifdef COBJMACROS -#define ID3D12Device11_QueryInterface(This,riid,ppvObject) \ +#define ID3D12GraphicsCommandList5_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12Device11_AddRef(This) \ +#define ID3D12GraphicsCommandList5_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12Device11_Release(This) \ +#define ID3D12GraphicsCommandList5_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12Device11_GetPrivateData(This,guid,pDataSize,pData) \ +#define ID3D12GraphicsCommandList5_GetPrivateData(This,guid,pDataSize,pData) \ ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12Device11_SetPrivateData(This,guid,DataSize,pData) \ +#define ID3D12GraphicsCommandList5_SetPrivateData(This,guid,DataSize,pData) \ ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12Device11_SetPrivateDataInterface(This,guid,pData) \ +#define ID3D12GraphicsCommandList5_SetPrivateDataInterface(This,guid,pData) \ ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12Device11_SetName(This,Name) \ +#define ID3D12GraphicsCommandList5_SetName(This,Name) \ ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12Device11_GetNodeCount(This) \ - ( (This)->lpVtbl -> GetNodeCount(This) ) +#define ID3D12GraphicsCommandList5_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) -#define ID3D12Device11_CreateCommandQueue(This,pDesc,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue(This,pDesc,riid,ppCommandQueue) ) -#define ID3D12Device11_CreateCommandAllocator(This,type,riid,ppCommandAllocator) \ - ( (This)->lpVtbl -> CreateCommandAllocator(This,type,riid,ppCommandAllocator) ) +#define ID3D12GraphicsCommandList5_GetType(This) \ + ( (This)->lpVtbl -> GetType(This) ) -#define ID3D12Device11_CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateGraphicsPipelineState(This,pDesc,riid,ppPipelineState) ) -#define ID3D12Device11_CreateComputePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreateComputePipelineState(This,pDesc,riid,ppPipelineState) ) +#define ID3D12GraphicsCommandList5_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) -#define ID3D12Device11_CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList(This,nodeMask,type,pCommandAllocator,pInitialState,riid,ppCommandList) ) +#define ID3D12GraphicsCommandList5_Reset(This,pAllocator,pInitialState) \ + ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) -#define ID3D12Device11_CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) \ - ( (This)->lpVtbl -> CheckFeatureSupport(This,Feature,pFeatureSupportData,FeatureSupportDataSize) ) +#define ID3D12GraphicsCommandList5_ClearState(This,pPipelineState) \ + ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) -#define ID3D12Device11_CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateDescriptorHeap(This,pDescriptorHeapDesc,riid,ppvHeap) ) +#define ID3D12GraphicsCommandList5_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) -#define ID3D12Device11_GetDescriptorHandleIncrementSize(This,DescriptorHeapType) \ - ( (This)->lpVtbl -> GetDescriptorHandleIncrementSize(This,DescriptorHeapType) ) +#define ID3D12GraphicsCommandList5_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) -#define ID3D12Device11_CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) \ - ( (This)->lpVtbl -> CreateRootSignature(This,nodeMask,pBlobWithRootSignature,blobLengthInBytes,riid,ppvRootSignature) ) +#define ID3D12GraphicsCommandList5_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ + ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) -#define ID3D12Device11_CreateConstantBufferView(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateConstantBufferView(This,pDesc,DestDescriptor) ) +#define ID3D12GraphicsCommandList5_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ + ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) -#define ID3D12Device11_CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateShaderResourceView(This,pResource,pDesc,DestDescriptor) ) +#define ID3D12GraphicsCommandList5_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ + ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) -#define ID3D12Device11_CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateUnorderedAccessView(This,pResource,pCounterResource,pDesc,DestDescriptor) ) +#define ID3D12GraphicsCommandList5_CopyResource(This,pDstResource,pSrcResource) \ + ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) -#define ID3D12Device11_CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateRenderTargetView(This,pResource,pDesc,DestDescriptor) ) +#define ID3D12GraphicsCommandList5_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ + ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) -#define ID3D12Device11_CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateDepthStencilView(This,pResource,pDesc,DestDescriptor) ) +#define ID3D12GraphicsCommandList5_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ + ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) -#define ID3D12Device11_CreateSampler(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSampler(This,pDesc,DestDescriptor) ) +#define ID3D12GraphicsCommandList5_IASetPrimitiveTopology(This,PrimitiveTopology) \ + ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) -#define ID3D12Device11_CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptors(This,NumDestDescriptorRanges,pDestDescriptorRangeStarts,pDestDescriptorRangeSizes,NumSrcDescriptorRanges,pSrcDescriptorRangeStarts,pSrcDescriptorRangeSizes,DescriptorHeapsType) ) +#define ID3D12GraphicsCommandList5_RSSetViewports(This,NumViewports,pViewports) \ + ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) -#define ID3D12Device11_CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) \ - ( (This)->lpVtbl -> CopyDescriptorsSimple(This,NumDescriptors,DestDescriptorRangeStart,SrcDescriptorRangeStart,DescriptorHeapsType) ) -#if !defined(_WIN32) +#define ID3D12GraphicsCommandList5_RSSetScissorRects(This,NumRects,pRects) \ + ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) -#define ID3D12Device11_GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,visibleMask,numResourceDescs,pResourceDescs) ) -#else -#define ID3D12Device11_GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo(This,RetVal,visibleMask,numResourceDescs,pResourceDescs) ) -#endif -#if !defined(_WIN32) +#define ID3D12GraphicsCommandList5_OMSetBlendFactor(This,BlendFactor) \ + ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) -#define ID3D12Device11_GetCustomHeapProperties(This,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,nodeMask,heapType) ) -#else -#define ID3D12Device11_GetCustomHeapProperties(This,RetVal,nodeMask,heapType) \ - ( (This)->lpVtbl -> GetCustomHeapProperties(This,RetVal,nodeMask,heapType) ) -#endif +#define ID3D12GraphicsCommandList5_OMSetStencilRef(This,StencilRef) \ + ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) -#define ID3D12Device11_CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,riidResource,ppvResource) ) +#define ID3D12GraphicsCommandList5_SetPipelineState(This,pPipelineState) \ + ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) -#define ID3D12Device11_CreateHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap(This,pDesc,riid,ppvHeap) ) +#define ID3D12GraphicsCommandList5_ResourceBarrier(This,NumBarriers,pBarriers) \ + ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) -#define ID3D12Device11_CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12GraphicsCommandList5_ExecuteBundle(This,pCommandList) \ + ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) -#define ID3D12Device11_CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource(This,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12GraphicsCommandList5_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ + ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) -#define ID3D12Device11_CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) \ - ( (This)->lpVtbl -> CreateSharedHandle(This,pObject,pAttributes,Access,Name,pHandle) ) +#define ID3D12GraphicsCommandList5_SetComputeRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) -#define ID3D12Device11_OpenSharedHandle(This,NTHandle,riid,ppvObj) \ - ( (This)->lpVtbl -> OpenSharedHandle(This,NTHandle,riid,ppvObj) ) +#define ID3D12GraphicsCommandList5_SetGraphicsRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) -#define ID3D12Device11_OpenSharedHandleByName(This,Name,Access,pNTHandle) \ - ( (This)->lpVtbl -> OpenSharedHandleByName(This,Name,Access,pNTHandle) ) +#define ID3D12GraphicsCommandList5_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12Device11_MakeResident(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> MakeResident(This,NumObjects,ppObjects) ) +#define ID3D12GraphicsCommandList5_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12Device11_Evict(This,NumObjects,ppObjects) \ - ( (This)->lpVtbl -> Evict(This,NumObjects,ppObjects) ) +#define ID3D12GraphicsCommandList5_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12Device11_CreateFence(This,InitialValue,Flags,riid,ppFence) \ - ( (This)->lpVtbl -> CreateFence(This,InitialValue,Flags,riid,ppFence) ) +#define ID3D12GraphicsCommandList5_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12Device11_GetDeviceRemovedReason(This) \ - ( (This)->lpVtbl -> GetDeviceRemovedReason(This) ) +#define ID3D12GraphicsCommandList5_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) -#define ID3D12Device11_GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) +#define ID3D12GraphicsCommandList5_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) -#define ID3D12Device11_CreateQueryHeap(This,pDesc,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateQueryHeap(This,pDesc,riid,ppvHeap) ) +#define ID3D12GraphicsCommandList5_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12Device11_SetStablePowerState(This,Enable) \ - ( (This)->lpVtbl -> SetStablePowerState(This,Enable) ) +#define ID3D12GraphicsCommandList5_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12Device11_CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) \ - ( (This)->lpVtbl -> CreateCommandSignature(This,pDesc,pRootSignature,riid,ppvCommandSignature) ) +#define ID3D12GraphicsCommandList5_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12Device11_GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) \ - ( (This)->lpVtbl -> GetResourceTiling(This,pTiledResource,pNumTilesForEntireResource,pPackedMipDesc,pStandardTileShapeForNonPackedMips,pNumSubresourceTilings,FirstSubresourceTilingToGet,pSubresourceTilingsForNonPackedMips) ) -#if !defined(_WIN32) +#define ID3D12GraphicsCommandList5_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12Device11_GetAdapterLuid(This) \ - ( (This)->lpVtbl -> GetAdapterLuid(This) ) -#else -#define ID3D12Device11_GetAdapterLuid(This,RetVal) \ - ( (This)->lpVtbl -> GetAdapterLuid(This,RetVal) ) -#endif +#define ID3D12GraphicsCommandList5_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) +#define ID3D12GraphicsCommandList5_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12Device11_CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) \ - ( (This)->lpVtbl -> CreatePipelineLibrary(This,pLibraryBlob,BlobLength,riid,ppPipelineLibrary) ) +#define ID3D12GraphicsCommandList5_IASetIndexBuffer(This,pView) \ + ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) -#define ID3D12Device11_SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) \ - ( (This)->lpVtbl -> SetEventOnMultipleFenceCompletion(This,ppFences,pFenceValues,NumFences,Flags,hEvent) ) +#define ID3D12GraphicsCommandList5_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) -#define ID3D12Device11_SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) \ - ( (This)->lpVtbl -> SetResidencyPriority(This,NumObjects,ppObjects,pPriorities) ) +#define ID3D12GraphicsCommandList5_SOSetTargets(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) +#define ID3D12GraphicsCommandList5_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ + ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) -#define ID3D12Device11_CreatePipelineState(This,pDesc,riid,ppPipelineState) \ - ( (This)->lpVtbl -> CreatePipelineState(This,pDesc,riid,ppPipelineState) ) +#define ID3D12GraphicsCommandList5_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) +#define ID3D12GraphicsCommandList5_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) -#define ID3D12Device11_OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromAddress(This,pAddress,riid,ppvHeap) ) +#define ID3D12GraphicsCommandList5_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) -#define ID3D12Device11_OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) \ - ( (This)->lpVtbl -> OpenExistingHeapFromFileMapping(This,hFileMapping,riid,ppvHeap) ) +#define ID3D12GraphicsCommandList5_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) -#define ID3D12Device11_EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) \ - ( (This)->lpVtbl -> EnqueueMakeResident(This,Flags,NumObjects,ppObjects,pFenceToSignal,FenceValueToSignal) ) +#define ID3D12GraphicsCommandList5_DiscardResource(This,pResource,pRegion) \ + ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) +#define ID3D12GraphicsCommandList5_BeginQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) -#define ID3D12Device11_CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) \ - ( (This)->lpVtbl -> CreateCommandList1(This,nodeMask,type,flags,riid,ppCommandList) ) +#define ID3D12GraphicsCommandList5_EndQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) -#define ID3D12Device11_CreateProtectedResourceSession(This,pDesc,riid,ppSession) \ - ( (This)->lpVtbl -> CreateProtectedResourceSession(This,pDesc,riid,ppSession) ) +#define ID3D12GraphicsCommandList5_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ + ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) -#define ID3D12Device11_CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource1(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) +#define ID3D12GraphicsCommandList5_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ + ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) -#define ID3D12Device11_CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) \ - ( (This)->lpVtbl -> CreateHeap1(This,pDesc,pProtectedSession,riid,ppvHeap) ) +#define ID3D12GraphicsCommandList5_SetMarker(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) -#define ID3D12Device11_CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource1(This,pDesc,InitialState,pOptimizedClearValue,pProtectedSession,riid,ppvResource) ) -#if !defined(_WIN32) +#define ID3D12GraphicsCommandList5_BeginEvent(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) -#define ID3D12Device11_GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) -#else -#define ID3D12Device11_GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo1(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) -#endif +#define ID3D12GraphicsCommandList5_EndEvent(This) \ + ( (This)->lpVtbl -> EndEvent(This) ) +#define ID3D12GraphicsCommandList5_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ + ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) -#define ID3D12Device11_CreateLifetimeTracker(This,pOwner,riid,ppvTracker) \ - ( (This)->lpVtbl -> CreateLifetimeTracker(This,pOwner,riid,ppvTracker) ) -#define ID3D12Device11_RemoveDevice(This) \ - ( (This)->lpVtbl -> RemoveDevice(This) ) +#define ID3D12GraphicsCommandList5_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -#define ID3D12Device11_EnumerateMetaCommands(This,pNumMetaCommands,pDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) +#define ID3D12GraphicsCommandList5_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -#define ID3D12Device11_EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) \ - ( (This)->lpVtbl -> EnumerateMetaCommandParameters(This,CommandId,Stage,pTotalStructureSizeInBytes,pParameterCount,pParameterDescs) ) +#define ID3D12GraphicsCommandList5_OMSetDepthBounds(This,Min,Max) \ + ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) -#define ID3D12Device11_CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) \ - ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,NodeMask,pCreationParametersData,CreationParametersDataSizeInBytes,riid,ppMetaCommand) ) +#define ID3D12GraphicsCommandList5_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ + ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) -#define ID3D12Device11_CreateStateObject(This,pDesc,riid,ppStateObject) \ - ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) +#define ID3D12GraphicsCommandList5_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ + ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) -#define ID3D12Device11_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) \ - ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) +#define ID3D12GraphicsCommandList5_SetViewInstanceMask(This,Mask) \ + ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) -#define ID3D12Device11_CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) \ - ( (This)->lpVtbl -> CheckDriverMatchingIdentifier(This,SerializedDataType,pIdentifierToCheck) ) +#define ID3D12GraphicsCommandList5_WriteBufferImmediate(This,Count,pParams,pModes) \ + ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) -#define ID3D12Device11_SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) \ - ( (This)->lpVtbl -> SetBackgroundProcessingMode(This,Mode,MeasurementsAction,hEventToSignalUponCompletion,pbFurtherMeasurementsDesired) ) +#define ID3D12GraphicsCommandList5_SetProtectedResourceSession(This,pProtectedResourceSession) \ + ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) -#define ID3D12Device11_AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) \ - ( (This)->lpVtbl -> AddToStateObject(This,pAddition,pStateObjectToGrowFrom,riid,ppNewStateObject) ) -#define ID3D12Device11_CreateProtectedResourceSession1(This,pDesc,riid,ppSession) \ - ( (This)->lpVtbl -> CreateProtectedResourceSession1(This,pDesc,riid,ppSession) ) +#define ID3D12GraphicsCommandList5_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ + ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) -#if !defined(_WIN32) +#define ID3D12GraphicsCommandList5_EndRenderPass(This) \ + ( (This)->lpVtbl -> EndRenderPass(This) ) -#define ID3D12Device11_GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) -#else -#define ID3D12Device11_GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) \ - ( (This)->lpVtbl -> GetResourceAllocationInfo2(This,RetVal,visibleMask,numResourceDescs,pResourceDescs,pResourceAllocationInfo1) ) -#endif +#define ID3D12GraphicsCommandList5_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ + ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) -#define ID3D12Device11_CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource2(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pProtectedSession,riidResource,ppvResource) ) +#define ID3D12GraphicsCommandList5_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ + ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) -#define ID3D12Device11_CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource1(This,pHeap,HeapOffset,pDesc,InitialState,pOptimizedClearValue,riid,ppvResource) ) +#define ID3D12GraphicsCommandList5_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ + ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) -#define ID3D12Device11_CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSamplerFeedbackUnorderedAccessView(This,pTargetedResource,pFeedbackResource,DestDescriptor) ) +#define ID3D12GraphicsCommandList5_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ + ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) -#define ID3D12Device11_GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) \ - ( (This)->lpVtbl -> GetCopyableFootprints1(This,pResourceDesc,FirstSubresource,NumSubresources,BaseOffset,pLayouts,pNumRows,pRowSizeInBytes,pTotalBytes) ) +#define ID3D12GraphicsCommandList5_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ + ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) +#define ID3D12GraphicsCommandList5_SetPipelineState1(This,pStateObject) \ + ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) -#define ID3D12Device11_CreateShaderCacheSession(This,pDesc,riid,ppvSession) \ - ( (This)->lpVtbl -> CreateShaderCacheSession(This,pDesc,riid,ppvSession) ) +#define ID3D12GraphicsCommandList5_DispatchRays(This,pDesc) \ + ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) -#define ID3D12Device11_ShaderCacheControl(This,Kinds,Control) \ - ( (This)->lpVtbl -> ShaderCacheControl(This,Kinds,Control) ) -#define ID3D12Device11_CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) \ - ( (This)->lpVtbl -> CreateCommandQueue1(This,pDesc,CreatorID,riid,ppCommandQueue) ) +#define ID3D12GraphicsCommandList5_RSSetShadingRate(This,baseShadingRate,combiners) \ + ( (This)->lpVtbl -> RSSetShadingRate(This,baseShadingRate,combiners) ) +#define ID3D12GraphicsCommandList5_RSSetShadingRateImage(This,shadingRateImage) \ + ( (This)->lpVtbl -> RSSetShadingRateImage(This,shadingRateImage) ) -#define ID3D12Device11_CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) \ - ( (This)->lpVtbl -> CreateCommittedResource3(This,pHeapProperties,HeapFlags,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riidResource,ppvResource) ) +#endif /* COBJMACROS */ -#define ID3D12Device11_CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) \ - ( (This)->lpVtbl -> CreatePlacedResource2(This,pHeap,HeapOffset,pDesc,InitialLayout,pOptimizedClearValue,NumCastableFormats,pCastableFormats,riid,ppvResource) ) -#define ID3D12Device11_CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) \ - ( (This)->lpVtbl -> CreateReservedResource2(This,pDesc,InitialLayout,pOptimizedClearValue,pProtectedSession,NumCastableFormats,pCastableFormats,riid,ppvResource) ) +#endif /* C style interface */ -#define ID3D12Device11_CreateSampler2(This,pDesc,DestDescriptor) \ - ( (This)->lpVtbl -> CreateSampler2(This,pDesc,DestDescriptor) ) -#endif /* COBJMACROS */ +#endif /* __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__ */ -#endif /* C style interface */ +/* interface __MIDL_itf_d3d12_0000_0078 */ +/* [local] */ +typedef struct D3D12_DISPATCH_MESH_ARGUMENTS + { + UINT ThreadGroupCountX; + UINT ThreadGroupCountY; + UINT ThreadGroupCountZ; + } D3D12_DISPATCH_MESH_ARGUMENTS; -#endif /* __ID3D12Device11_INTERFACE_DEFINED__ */ +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0078_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0078_v0_0_s_ifspec; -#ifndef __ID3D12VirtualizationGuestDevice_INTERFACE_DEFINED__ -#define __ID3D12VirtualizationGuestDevice_INTERFACE_DEFINED__ +#ifndef __ID3D12GraphicsCommandList6_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList6_INTERFACE_DEFINED__ -/* interface ID3D12VirtualizationGuestDevice */ +/* interface ID3D12GraphicsCommandList6 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12VirtualizationGuestDevice; +EXTERN_C const IID IID_ID3D12GraphicsCommandList6; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("bc66d368-7373-4943-8757-fc87dc79e476") - ID3D12VirtualizationGuestDevice : public IUnknown + MIDL_INTERFACE("c3827890-e548-4cfa-96cf-5689a9370f80") + ID3D12GraphicsCommandList6 : public ID3D12GraphicsCommandList5 { public: - virtual HRESULT STDMETHODCALLTYPE ShareWithHost( - _In_ ID3D12DeviceChild *pObject, - _Out_ HANDLE *pHandle) = 0; + virtual void STDMETHODCALLTYPE DispatchMesh( + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12GraphicsCommandList6Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12GraphicsCommandList6 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12GraphicsCommandList6 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12GraphicsCommandList6 * This); + + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12GraphicsCommandList6 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12GraphicsCommandList6 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12GraphicsCommandList6 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12GraphicsCommandList6 * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12GraphicsCommandList6 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + DECLSPEC_XFGVIRT(ID3D12CommandList, GetType) + D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( + ID3D12GraphicsCommandList6 * This); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close) + HRESULT ( STDMETHODCALLTYPE *Close )( + ID3D12GraphicsCommandList6 * This); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset) + HRESULT ( STDMETHODCALLTYPE *Reset )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12CommandAllocator *pAllocator, + _In_opt_ ID3D12PipelineState *pInitialState); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState) + void ( STDMETHODCALLTYPE *ClearState )( + ID3D12GraphicsCommandList6 * This, + _In_opt_ ID3D12PipelineState *pPipelineState); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced) + void ( STDMETHODCALLTYPE *DrawInstanced )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT VertexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartVertexLocation, + _In_ UINT StartInstanceLocation); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced) + void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT IndexCountPerInstance, + _In_ UINT InstanceCount, + _In_ UINT StartIndexLocation, + _In_ INT BaseVertexLocation, + _In_ UINT StartInstanceLocation); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch) + void ( STDMETHODCALLTYPE *Dispatch )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion) + void ( STDMETHODCALLTYPE *CopyBufferRegion )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT64 NumBytes); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion) + void ( STDMETHODCALLTYPE *CopyTextureRegion )( + ID3D12GraphicsCommandList6 * This, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, + UINT DstX, + UINT DstY, + UINT DstZ, + _In_ const D3D12_TEXTURE_COPY_LOCATION *pSrc, + _In_opt_ const D3D12_BOX *pSrcBox); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource) + void ( STDMETHODCALLTYPE *CopyResource )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12Resource *pDstResource, + _In_ ID3D12Resource *pSrcResource); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles) + void ( STDMETHODCALLTYPE *CopyTiles )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12Resource *pTiledResource, + _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, + _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, + _In_ ID3D12Resource *pBuffer, + UINT64 BufferStartOffsetInBytes, + D3D12_TILE_COPY_FLAGS Flags); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource) + void ( STDMETHODCALLTYPE *ResolveSubresource )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_ DXGI_FORMAT Format); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology) + void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( + ID3D12GraphicsCommandList6 * This, + _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports) + void ( STDMETHODCALLTYPE *RSSetViewports )( + ID3D12GraphicsCommandList6 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, + _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects) + void ( STDMETHODCALLTYPE *RSSetScissorRects )( + ID3D12GraphicsCommandList6 * This, + _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, + _In_reads_( NumRects) const D3D12_RECT *pRects); - virtual HRESULT STDMETHODCALLTYPE CreateFenceFd( - _In_ ID3D12Fence *pFence, - UINT64 FenceValue, - _Out_ int *pFenceFd) = 0; + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor) + void ( STDMETHODCALLTYPE *OMSetBlendFactor )( + ID3D12GraphicsCommandList6 * This, + _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); - }; - - -#else /* C style interface */ - - typedef struct ID3D12VirtualizationGuestDeviceVtbl - { - BEGIN_INTERFACE + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef) + void ( STDMETHODCALLTYPE *OMSetStencilRef )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT StencilRef); - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12VirtualizationGuestDevice * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState) + void ( STDMETHODCALLTYPE *SetPipelineState )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12PipelineState *pPipelineState); - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12VirtualizationGuestDevice * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier) + void ( STDMETHODCALLTYPE *ResourceBarrier )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT NumBarriers, + _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12VirtualizationGuestDevice * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle) + void ( STDMETHODCALLTYPE *ExecuteBundle )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12GraphicsCommandList *pCommandList); - DECLSPEC_XFGVIRT(ID3D12VirtualizationGuestDevice, ShareWithHost) - HRESULT ( STDMETHODCALLTYPE *ShareWithHost )( - ID3D12VirtualizationGuestDevice * This, - _In_ ID3D12DeviceChild *pObject, - _Out_ HANDLE *pHandle); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps) + void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT NumDescriptorHeaps, + _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); - DECLSPEC_XFGVIRT(ID3D12VirtualizationGuestDevice, CreateFenceFd) - HRESULT ( STDMETHODCALLTYPE *CreateFenceFd )( - ID3D12VirtualizationGuestDevice * This, - _In_ ID3D12Fence *pFence, - UINT64 FenceValue, - _Out_ int *pFenceFd); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature) + void ( STDMETHODCALLTYPE *SetComputeRootSignature )( + ID3D12GraphicsCommandList6 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); - END_INTERFACE - } ID3D12VirtualizationGuestDeviceVtbl; - - interface ID3D12VirtualizationGuestDevice - { - CONST_VTBL struct ID3D12VirtualizationGuestDeviceVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12VirtualizationGuestDevice_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12VirtualizationGuestDevice_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12VirtualizationGuestDevice_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12VirtualizationGuestDevice_ShareWithHost(This,pObject,pHandle) \ - ( (This)->lpVtbl -> ShareWithHost(This,pObject,pHandle) ) - -#define ID3D12VirtualizationGuestDevice_CreateFenceFd(This,pFence,FenceValue,pFenceFd) \ - ( (This)->lpVtbl -> CreateFenceFd(This,pFence,FenceValue,pFenceFd) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12VirtualizationGuestDevice_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12Tools_INTERFACE_DEFINED__ -#define __ID3D12Tools_INTERFACE_DEFINED__ - -/* interface ID3D12Tools */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12Tools; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("7071e1f0-e84b-4b33-974f-12fa49de65c5") - ID3D12Tools : public IUnknown - { - public: - virtual void STDMETHODCALLTYPE EnableShaderInstrumentation( - BOOL bEnable) = 0; + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature) + void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( + ID3D12GraphicsCommandList6 * This, + _In_opt_ ID3D12RootSignature *pRootSignature); - virtual BOOL STDMETHODCALLTYPE ShaderInstrumentationEnabled( void) = 0; + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable) + void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); - }; - - -#else /* C style interface */ - - typedef struct ID3D12ToolsVtbl - { - BEGIN_INTERFACE + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable) + void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant) + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant) + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT RootParameterIndex, + _In_ UINT SrcData, + _In_ UINT DestOffsetIn32BitValues); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants) + void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants) + void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT RootParameterIndex, + _In_ UINT Num32BitValuesToSet, + _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, + _In_ UINT DestOffsetIn32BitValues); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView) + void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView) + void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView) + void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView) + void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView) + void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView) + void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT RootParameterIndex, + _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer) + void ( STDMETHODCALLTYPE *IASetIndexBuffer )( + ID3D12GraphicsCommandList6 * This, + _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers) + void ( STDMETHODCALLTYPE *IASetVertexBuffers )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets) + void ( STDMETHODCALLTYPE *SOSetTargets )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT StartSlot, + _In_ UINT NumViews, + _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets) + void ( STDMETHODCALLTYPE *OMSetRenderTargets )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT NumRenderTargetDescriptors, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, + _In_ BOOL RTsSingleHandleToDescriptorRange, + _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView) + void ( STDMETHODCALLTYPE *ClearDepthStencilView )( + ID3D12GraphicsCommandList6 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, + _In_ D3D12_CLEAR_FLAGS ClearFlags, + _In_ FLOAT Depth, + _In_ UINT8 Stencil, + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView) + void ( STDMETHODCALLTYPE *ClearRenderTargetView )( + ID3D12GraphicsCommandList6 * This, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, + _In_ const FLOAT ColorRGBA[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12Tools * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint) + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( + ID3D12GraphicsCommandList6 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const UINT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12Tools * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat) + void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( + ID3D12GraphicsCommandList6 * This, + _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, + _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, + _In_ ID3D12Resource *pResource, + _In_ const FLOAT Values[ 4 ], + _In_ UINT NumRects, + _In_reads_(NumRects) const D3D12_RECT *pRects); - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12Tools * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource) + void ( STDMETHODCALLTYPE *DiscardResource )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DISCARD_REGION *pRegion); - DECLSPEC_XFGVIRT(ID3D12Tools, EnableShaderInstrumentation) - void ( STDMETHODCALLTYPE *EnableShaderInstrumentation )( - ID3D12Tools * This, - BOOL bEnable); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery) + void ( STDMETHODCALLTYPE *BeginQuery )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); - DECLSPEC_XFGVIRT(ID3D12Tools, ShaderInstrumentationEnabled) - BOOL ( STDMETHODCALLTYPE *ShaderInstrumentationEnabled )( - ID3D12Tools * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery) + void ( STDMETHODCALLTYPE *EndQuery )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); - END_INTERFACE - } ID3D12ToolsVtbl; - - interface ID3D12Tools - { - CONST_VTBL struct ID3D12ToolsVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12Tools_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12Tools_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12Tools_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12Tools_EnableShaderInstrumentation(This,bEnable) \ - ( (This)->lpVtbl -> EnableShaderInstrumentation(This,bEnable) ) - -#define ID3D12Tools_ShaderInstrumentationEnabled(This) \ - ( (This)->lpVtbl -> ShaderInstrumentationEnabled(This) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12Tools_INTERFACE_DEFINED__ */ - - -/* interface __MIDL_itf_d3d12_0000_0057 */ -/* [local] */ - -typedef struct D3D12_SUBRESOURCE_DATA - { - const void *pData; - LONG_PTR RowPitch; - LONG_PTR SlicePitch; - } D3D12_SUBRESOURCE_DATA; - -typedef struct D3D12_MEMCPY_DEST - { - void *pData; - SIZE_T RowPitch; - SIZE_T SlicePitch; - } D3D12_MEMCPY_DEST; - -#if !defined( D3D12_IGNORE_SDK_LAYERS ) -#include "d3d12sdklayers.h" -#endif - -/////////////////////////////////////////////////////////////////////////// -// D3D12CreateDevice -// ------------------ -// -// pAdapter -// If NULL, D3D12CreateDevice will choose the primary adapter. -// If non-NULL, D3D12CreateDevice will use the provided adapter. -// MinimumFeatureLevel -// The minimum feature level required for successful device creation. -// riid -// The interface IID of the device to be returned. Expected: ID3D12Device. -// ppDevice -// Pointer to returned interface. May be NULL. -// -// Return Values -// Any of those documented for -// CreateDXGIFactory1 -// IDXGIFactory::EnumAdapters -// D3D12CreateDevice -// -/////////////////////////////////////////////////////////////////////////// -typedef HRESULT (WINAPI* PFN_D3D12_CREATE_DEVICE)( _In_opt_ IUnknown*, - D3D_FEATURE_LEVEL, - _In_ REFIID, _COM_Outptr_opt_ void** ); - -HRESULT WINAPI D3D12CreateDevice( - _In_opt_ IUnknown* pAdapter, - D3D_FEATURE_LEVEL MinimumFeatureLevel, - _In_ REFIID riid, // Expected: ID3D12Device - _COM_Outptr_opt_ void** ppDevice ); - - -typedef HRESULT (WINAPI* PFN_D3D12_GET_DEBUG_INTERFACE)( _In_ REFIID, _COM_Outptr_opt_ void** ); - -HRESULT WINAPI D3D12GetDebugInterface( _In_ REFIID riid, _COM_Outptr_opt_ void** ppvDebug ); - -// -------------------------------------------------------------------------------------------------------------------------------- -// D3D12EnableExperimentalFeatures -// -// Pass in a list of feature GUIDs to be enabled together. -// -// If a particular feature requires some configuration information on enablement, it will have -// a configuration struct that can be passed alongside the GUID. -// -// Some features might use an interface IID as the GUID. For these, once the feature is enabled via -// D3D12EnableExperimentalFeatures, D3D12GetDebugInterface can then be called with the IID to retrieve the interface -// for manipulating the feature. This allows for control that might not cleanly be expressed by just -// the configuration struct that D3D12EnableExperimentalFeatures provides. -// -// If this method is called and a change to existing feature enablement is made, -// all current D3D12 devices are set to DEVICE_REMOVED state, since under the covers there is really only one -// singleton device for a process. Removing the devices when configuration changes prevents -// mismatched expectations of how a device is supposed to work after it has been created from the app's point of view. -// -// The call returns E_NOINTERFACE if an unrecognized feature is passed in or Windows Developer mode is not on. -// The call returns E_INVALIDARG if the configuration of a feature is incorrect, the set of features passed -// in are known to be incompatible with each other, or other errors. -// Returns S_OK otherwise. -// -// -------------------------------------------------------------------------------------------------------------------------------- -HRESULT WINAPI D3D12EnableExperimentalFeatures( - UINT NumFeatures, - _In_count_(NumFeatures) const IID* pIIDs, - _In_opt_count_(NumFeatures) void* pConfigurationStructs, - _In_opt_count_(NumFeatures) UINT* pConfigurationStructSizes); - -// -------------------------------------------------------------------------------------------------------------------------------- -// Experimental Feature: D3D12ExperimentalShaderModels -// -// Use with D3D12EnableExperimentalFeatures to enable experimental shader model support, -// meaning shader models that haven't been finalized for use in retail. -// -// Enabling D3D12ExperimentalShaderModels needs no configuration struct, pass NULL in the pConfigurationStructs array. -// -// -------------------------------------------------------------------------------------------------------------------------------- -static const UUID D3D12ExperimentalShaderModels = { /* 76f5573e-f13a-40f5-b297-81ce9e18933f */ - 0x76f5573e, - 0xf13a, - 0x40f5, - { 0xb2, 0x97, 0x81, 0xce, 0x9e, 0x18, 0x93, 0x3f } -}; -// -------------------------------------------------------------------------------------------------------------------------------- -// Experimental Feature: D3D12TiledResourceTier4 -// -// Use with D3D12EnableExperimentalFeatures to enable tiled resource tier 4 support, -// meaning texture tile data-inheritance is allowed. -// -// Enabling D3D12TiledResourceTier4 needs no configuration struct, pass NULL in the pConfigurationStructs array. -// -// -------------------------------------------------------------------------------------------------------------------------------- -static const UUID D3D12TiledResourceTier4 = { /* c9c4725f-a81a-4f56-8c5b-c51039d694fb */ - 0xc9c4725f, - 0xa81a, - 0x4f56, - { 0x8c, 0x5b, 0xc5, 0x10, 0x39, 0xd6, 0x94, 0xfb } -}; -// -------------------------------------------------------------------------------------------------------------------------------- -// D3D12GetInterface -// -// Retrieve Global D3D12 Interface. -// - -DEFINE_GUID(CLSID_D3D12Debug, 0xf2352aeb, 0xdd84, 0x49fe, 0xb9, 0x7b, 0xa9, 0xdc, 0xfd, 0xcc, 0x1b, 0x4f); -DEFINE_GUID(CLSID_D3D12Tools, 0xe38216b1, 0x3c8c, 0x4833, 0xaa, 0x09, 0x0a, 0x06, 0xb6, 0x5d, 0x96, 0xc8); -DEFINE_GUID(CLSID_D3D12DeviceRemovedExtendedData, 0x4a75bbc4, 0x9ff4, 0x4ad8, 0x9f, 0x18, 0xab, 0xae, 0x84, 0xdc, 0x5f, 0xf2); -DEFINE_GUID(CLSID_D3D12SDKConfiguration, 0x7cda6aca, 0xa03e, 0x49c8, 0x94, 0x58, 0x03, 0x34, 0xd2, 0x0e, 0x07, 0xce); -DEFINE_GUID(CLSID_D3D12DeviceFactory, 0x114863bf, 0xc386, 0x4aee, 0xb3, 0x9d, 0x8f, 0x0b, 0xbb, 0x06, 0x29, 0x55); - -typedef HRESULT (WINAPI* PFN_D3D12_GET_INTERFACE)( _In_ REFCLSID, _In_ REFIID, _COM_Outptr_opt_ void** ); - -HRESULT WINAPI D3D12GetInterface( _In_ REFCLSID rclsid, _In_ REFIID riid, _COM_Outptr_opt_ void** ppvDebug ); - - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0057_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0057_v0_0_s_ifspec; - -#ifndef __ID3D12SDKConfiguration_INTERFACE_DEFINED__ -#define __ID3D12SDKConfiguration_INTERFACE_DEFINED__ - -/* interface ID3D12SDKConfiguration */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12SDKConfiguration; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("e9eb5314-33aa-42b2-a718-d77f58b1f1c7") - ID3D12SDKConfiguration : public IUnknown - { - public: - virtual HRESULT STDMETHODCALLTYPE SetSDKVersion( - UINT SDKVersion, - _In_z_ LPCSTR SDKPath) = 0; + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData) + void ( STDMETHODCALLTYPE *ResolveQueryData )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT StartIndex, + _In_ UINT NumQueries, + _In_ ID3D12Resource *pDestinationBuffer, + _In_ UINT64 AlignedDestinationBufferOffset); - }; - - -#else /* C style interface */ - - typedef struct ID3D12SDKConfigurationVtbl - { - BEGIN_INTERFACE + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication) + void ( STDMETHODCALLTYPE *SetPredication )( + ID3D12GraphicsCommandList6 * This, + _In_opt_ ID3D12Resource *pBuffer, + _In_ UINT64 AlignedBufferOffset, + _In_ D3D12_PREDICATION_OP Operation); - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12SDKConfiguration * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker) + void ( STDMETHODCALLTYPE *SetMarker )( + ID3D12GraphicsCommandList6 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12SDKConfiguration * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent) + void ( STDMETHODCALLTYPE *BeginEvent )( + ID3D12GraphicsCommandList6 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12SDKConfiguration * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent) + void ( STDMETHODCALLTYPE *EndEvent )( + ID3D12GraphicsCommandList6 * This); - DECLSPEC_XFGVIRT(ID3D12SDKConfiguration, SetSDKVersion) - HRESULT ( STDMETHODCALLTYPE *SetSDKVersion )( - ID3D12SDKConfiguration * This, - UINT SDKVersion, - _In_z_ LPCSTR SDKPath); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect) + void ( STDMETHODCALLTYPE *ExecuteIndirect )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12CommandSignature *pCommandSignature, + _In_ UINT MaxCommandCount, + _In_ ID3D12Resource *pArgumentBuffer, + _In_ UINT64 ArgumentBufferOffset, + _In_opt_ ID3D12Resource *pCountBuffer, + _In_ UINT64 CountBufferOffset); - END_INTERFACE - } ID3D12SDKConfigurationVtbl; - - interface ID3D12SDKConfiguration - { - CONST_VTBL struct ID3D12SDKConfigurationVtbl *lpVtbl; - }; - - - -#ifdef COBJMACROS - - -#define ID3D12SDKConfiguration_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) - -#define ID3D12SDKConfiguration_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) - -#define ID3D12SDKConfiguration_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) - - -#define ID3D12SDKConfiguration_SetSDKVersion(This,SDKVersion,SDKPath) \ - ( (This)->lpVtbl -> SetSDKVersion(This,SDKVersion,SDKPath) ) - -#endif /* COBJMACROS */ - - -#endif /* C style interface */ - - - - -#endif /* __ID3D12SDKConfiguration_INTERFACE_DEFINED__ */ - - -#ifndef __ID3D12SDKConfiguration1_INTERFACE_DEFINED__ -#define __ID3D12SDKConfiguration1_INTERFACE_DEFINED__ - -/* interface ID3D12SDKConfiguration1 */ -/* [unique][local][object][uuid] */ - - -EXTERN_C const IID IID_ID3D12SDKConfiguration1; - -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("8aaf9303-ad25-48b9-9a57-d9c37e009d9f") - ID3D12SDKConfiguration1 : public ID3D12SDKConfiguration - { - public: - virtual HRESULT STDMETHODCALLTYPE CreateDeviceFactory( - UINT SDKVersion, - _In_ LPCSTR SDKPath, - REFIID riid, - _COM_Outptr_ void **ppvFactory) = 0; + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT) + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - virtual void STDMETHODCALLTYPE FreeUnusedSDKs( void) = 0; + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64) + void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12Resource *pDstBuffer, + UINT64 DstOffset, + _In_ ID3D12Resource *pSrcBuffer, + UINT64 SrcOffset, + UINT Dependencies, + _In_reads_(Dependencies) ID3D12Resource *const *ppDependentResources, + _In_reads_(Dependencies) const D3D12_SUBRESOURCE_RANGE_UINT64 *pDependentSubresourceRanges); - }; - - -#else /* C style interface */ - - typedef struct ID3D12SDKConfiguration1Vtbl - { - BEGIN_INTERFACE + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds) + void ( STDMETHODCALLTYPE *OMSetDepthBounds )( + ID3D12GraphicsCommandList6 * This, + _In_ FLOAT Min, + _In_ FLOAT Max); - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12SDKConfiguration1 * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions) + void ( STDMETHODCALLTYPE *SetSamplePositions )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT NumSamplesPerPixel, + _In_ UINT NumPixels, + _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12SDKConfiguration1 * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion) + void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12Resource *pDstResource, + _In_ UINT DstSubresource, + _In_ UINT DstX, + _In_ UINT DstY, + _In_ ID3D12Resource *pSrcResource, + _In_ UINT SrcSubresource, + _In_opt_ D3D12_RECT *pSrcRect, + _In_ DXGI_FORMAT Format, + _In_ D3D12_RESOLVE_MODE ResolveMode); - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12SDKConfiguration1 * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask) + void ( STDMETHODCALLTYPE *SetViewInstanceMask )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT Mask); - DECLSPEC_XFGVIRT(ID3D12SDKConfiguration, SetSDKVersion) - HRESULT ( STDMETHODCALLTYPE *SetSDKVersion )( - ID3D12SDKConfiguration1 * This, - UINT SDKVersion, - _In_z_ LPCSTR SDKPath); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate) + void ( STDMETHODCALLTYPE *WriteBufferImmediate )( + ID3D12GraphicsCommandList6 * This, + UINT Count, + _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, + _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession) + void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( + ID3D12GraphicsCommandList6 * This, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BeginRenderPass) + void ( STDMETHODCALLTYPE *BeginRenderPass )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT NumRenderTargets, + _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, + _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, + D3D12_RENDER_PASS_FLAGS Flags); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EndRenderPass) + void ( STDMETHODCALLTYPE *EndRenderPass )( + ID3D12GraphicsCommandList6 * This); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, InitializeMetaCommand) + void ( STDMETHODCALLTYPE *InitializeMetaCommand )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, + _In_ SIZE_T InitializationParametersDataSizeInBytes); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, ExecuteMetaCommand) + void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12MetaCommand *pMetaCommand, + _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, + _In_ SIZE_T ExecutionParametersDataSizeInBytes); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BuildRaytracingAccelerationStructure) + void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( + ID3D12GraphicsCommandList6 * This, + _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, + _In_ UINT NumPostbuildInfoDescs, + _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EmitRaytracingAccelerationStructurePostbuildInfo) + void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( + ID3D12GraphicsCommandList6 * This, + _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, + _In_ UINT NumSourceAccelerationStructures, + _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, CopyRaytracingAccelerationStructure) + void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( + ID3D12GraphicsCommandList6 * This, + _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, + _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, + _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, SetPipelineState1) + void ( STDMETHODCALLTYPE *SetPipelineState1 )( + ID3D12GraphicsCommandList6 * This, + _In_ ID3D12StateObject *pStateObject); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, DispatchRays) + void ( STDMETHODCALLTYPE *DispatchRays )( + ID3D12GraphicsCommandList6 * This, + _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRate) + void ( STDMETHODCALLTYPE *RSSetShadingRate )( + ID3D12GraphicsCommandList6 * This, + _In_ D3D12_SHADING_RATE baseShadingRate, + _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT) const D3D12_SHADING_RATE_COMBINER *combiners); - DECLSPEC_XFGVIRT(ID3D12SDKConfiguration1, CreateDeviceFactory) - HRESULT ( STDMETHODCALLTYPE *CreateDeviceFactory )( - ID3D12SDKConfiguration1 * This, - UINT SDKVersion, - _In_ LPCSTR SDKPath, - REFIID riid, - _COM_Outptr_ void **ppvFactory); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRateImage) + void ( STDMETHODCALLTYPE *RSSetShadingRateImage )( + ID3D12GraphicsCommandList6 * This, + _In_opt_ ID3D12Resource *shadingRateImage); - DECLSPEC_XFGVIRT(ID3D12SDKConfiguration1, FreeUnusedSDKs) - void ( STDMETHODCALLTYPE *FreeUnusedSDKs )( - ID3D12SDKConfiguration1 * This); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList6, DispatchMesh) + void ( STDMETHODCALLTYPE *DispatchMesh )( + ID3D12GraphicsCommandList6 * This, + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ); END_INTERFACE - } ID3D12SDKConfiguration1Vtbl; + } ID3D12GraphicsCommandList6Vtbl; - interface ID3D12SDKConfiguration1 + interface ID3D12GraphicsCommandList6 { - CONST_VTBL struct ID3D12SDKConfiguration1Vtbl *lpVtbl; + CONST_VTBL struct ID3D12GraphicsCommandList6Vtbl *lpVtbl; }; @@ -24787,533 +32783,362 @@ EXTERN_C const IID IID_ID3D12SDKConfiguration1; #ifdef COBJMACROS -#define ID3D12SDKConfiguration1_QueryInterface(This,riid,ppvObject) \ +#define ID3D12GraphicsCommandList6_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12SDKConfiguration1_AddRef(This) \ +#define ID3D12GraphicsCommandList6_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12SDKConfiguration1_Release(This) \ +#define ID3D12GraphicsCommandList6_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12SDKConfiguration1_SetSDKVersion(This,SDKVersion,SDKPath) \ - ( (This)->lpVtbl -> SetSDKVersion(This,SDKVersion,SDKPath) ) +#define ID3D12GraphicsCommandList6_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) +#define ID3D12GraphicsCommandList6_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12SDKConfiguration1_CreateDeviceFactory(This,SDKVersion,SDKPath,riid,ppvFactory) \ - ( (This)->lpVtbl -> CreateDeviceFactory(This,SDKVersion,SDKPath,riid,ppvFactory) ) +#define ID3D12GraphicsCommandList6_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12SDKConfiguration1_FreeUnusedSDKs(This) \ - ( (This)->lpVtbl -> FreeUnusedSDKs(This) ) +#define ID3D12GraphicsCommandList6_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) -#endif /* COBJMACROS */ +#define ID3D12GraphicsCommandList6_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) -#endif /* C style interface */ +#define ID3D12GraphicsCommandList6_GetType(This) \ + ( (This)->lpVtbl -> GetType(This) ) +#define ID3D12GraphicsCommandList6_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) -#endif /* __ID3D12SDKConfiguration1_INTERFACE_DEFINED__ */ +#define ID3D12GraphicsCommandList6_Reset(This,pAllocator,pInitialState) \ + ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) +#define ID3D12GraphicsCommandList6_ClearState(This,pPipelineState) \ + ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) -/* interface __MIDL_itf_d3d12_0000_0059 */ -/* [local] */ +#define ID3D12GraphicsCommandList6_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) -typedef -enum D3D12_DEVICE_FACTORY_FLAGS - { - D3D12_DEVICE_FACTORY_FLAG_NONE = 0, - D3D12_DEVICE_FACTORY_FLAG_ALLOW_RETURNING_EXISTING_DEVICE = 0x1, - D3D12_DEVICE_FACTORY_FLAG_ALLOW_RETURNING_INCOMPATIBLE_EXISTING_DEVICE = 0x2, - D3D12_DEVICE_FACTORY_FLAG_DISALLOW_STORING_NEW_DEVICE_AS_SINGLETON = 0x4 - } D3D12_DEVICE_FACTORY_FLAGS; +#define ID3D12GraphicsCommandList6_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ + ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) -DEFINE_ENUM_FLAG_OPERATORS( D3D12_DEVICE_FACTORY_FLAGS ); +#define ID3D12GraphicsCommandList6_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ + ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) +#define ID3D12GraphicsCommandList6_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ + ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0059_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0059_v0_0_s_ifspec; +#define ID3D12GraphicsCommandList6_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ + ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) -#ifndef __ID3D12DeviceFactory_INTERFACE_DEFINED__ -#define __ID3D12DeviceFactory_INTERFACE_DEFINED__ +#define ID3D12GraphicsCommandList6_CopyResource(This,pDstResource,pSrcResource) \ + ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) -/* interface ID3D12DeviceFactory */ -/* [unique][local][object][uuid] */ +#define ID3D12GraphicsCommandList6_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ + ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) +#define ID3D12GraphicsCommandList6_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ + ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) -EXTERN_C const IID IID_ID3D12DeviceFactory; +#define ID3D12GraphicsCommandList6_IASetPrimitiveTopology(This,PrimitiveTopology) \ + ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("61f307d3-d34e-4e7c-8374-3ba4de23cccb") - ID3D12DeviceFactory : public IUnknown - { - public: - virtual HRESULT STDMETHODCALLTYPE InitializeFromGlobalState( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE ApplyToGlobalState( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE SetFlags( - D3D12_DEVICE_FACTORY_FLAGS flags) = 0; - - virtual D3D12_DEVICE_FACTORY_FLAGS STDMETHODCALLTYPE GetFlags( void) = 0; - - virtual HRESULT STDMETHODCALLTYPE GetConfigurationInterface( - REFCLSID clsid, - REFIID iid, - _COM_Outptr_ void **ppv) = 0; - - virtual HRESULT STDMETHODCALLTYPE EnableExperimentalFeatures( - UINT NumFeatures, - _In_reads_(NumFeatures) const IID *pIIDs, - _In_reads_opt_(NumFeatures) void *pConfigurationStructs, - _In_reads_opt_(NumFeatures) UINT *pConfigurationStructSizes) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateDevice( - _In_opt_ IUnknown *adapter, - D3D_FEATURE_LEVEL FeatureLevel, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice) = 0; - - }; - - -#else /* C style interface */ +#define ID3D12GraphicsCommandList6_RSSetViewports(This,NumViewports,pViewports) \ + ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) - typedef struct ID3D12DeviceFactoryVtbl - { - BEGIN_INTERFACE - - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DeviceFactory * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DeviceFactory * This); - - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DeviceFactory * This); - - DECLSPEC_XFGVIRT(ID3D12DeviceFactory, InitializeFromGlobalState) - HRESULT ( STDMETHODCALLTYPE *InitializeFromGlobalState )( - ID3D12DeviceFactory * This); - - DECLSPEC_XFGVIRT(ID3D12DeviceFactory, ApplyToGlobalState) - HRESULT ( STDMETHODCALLTYPE *ApplyToGlobalState )( - ID3D12DeviceFactory * This); - - DECLSPEC_XFGVIRT(ID3D12DeviceFactory, SetFlags) - HRESULT ( STDMETHODCALLTYPE *SetFlags )( - ID3D12DeviceFactory * This, - D3D12_DEVICE_FACTORY_FLAGS flags); - - DECLSPEC_XFGVIRT(ID3D12DeviceFactory, GetFlags) - D3D12_DEVICE_FACTORY_FLAGS ( STDMETHODCALLTYPE *GetFlags )( - ID3D12DeviceFactory * This); - - DECLSPEC_XFGVIRT(ID3D12DeviceFactory, GetConfigurationInterface) - HRESULT ( STDMETHODCALLTYPE *GetConfigurationInterface )( - ID3D12DeviceFactory * This, - REFCLSID clsid, - REFIID iid, - _COM_Outptr_ void **ppv); - - DECLSPEC_XFGVIRT(ID3D12DeviceFactory, EnableExperimentalFeatures) - HRESULT ( STDMETHODCALLTYPE *EnableExperimentalFeatures )( - ID3D12DeviceFactory * This, - UINT NumFeatures, - _In_reads_(NumFeatures) const IID *pIIDs, - _In_reads_opt_(NumFeatures) void *pConfigurationStructs, - _In_reads_opt_(NumFeatures) UINT *pConfigurationStructSizes); - - DECLSPEC_XFGVIRT(ID3D12DeviceFactory, CreateDevice) - HRESULT ( STDMETHODCALLTYPE *CreateDevice )( - ID3D12DeviceFactory * This, - _In_opt_ IUnknown *adapter, - D3D_FEATURE_LEVEL FeatureLevel, - REFIID riid, - _COM_Outptr_opt_ void **ppvDevice); - - END_INTERFACE - } ID3D12DeviceFactoryVtbl; +#define ID3D12GraphicsCommandList6_RSSetScissorRects(This,NumRects,pRects) \ + ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) - interface ID3D12DeviceFactory - { - CONST_VTBL struct ID3D12DeviceFactoryVtbl *lpVtbl; - }; +#define ID3D12GraphicsCommandList6_OMSetBlendFactor(This,BlendFactor) \ + ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) - +#define ID3D12GraphicsCommandList6_OMSetStencilRef(This,StencilRef) \ + ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) -#ifdef COBJMACROS +#define ID3D12GraphicsCommandList6_SetPipelineState(This,pPipelineState) \ + ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) +#define ID3D12GraphicsCommandList6_ResourceBarrier(This,NumBarriers,pBarriers) \ + ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) -#define ID3D12DeviceFactory_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) +#define ID3D12GraphicsCommandList6_ExecuteBundle(This,pCommandList) \ + ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) -#define ID3D12DeviceFactory_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) +#define ID3D12GraphicsCommandList6_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ + ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) -#define ID3D12DeviceFactory_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) +#define ID3D12GraphicsCommandList6_SetComputeRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) + +#define ID3D12GraphicsCommandList6_SetGraphicsRootSignature(This,pRootSignature) \ + ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) +#define ID3D12GraphicsCommandList6_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12DeviceFactory_InitializeFromGlobalState(This) \ - ( (This)->lpVtbl -> InitializeFromGlobalState(This) ) +#define ID3D12GraphicsCommandList6_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ + ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12DeviceFactory_ApplyToGlobalState(This) \ - ( (This)->lpVtbl -> ApplyToGlobalState(This) ) +#define ID3D12GraphicsCommandList6_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12DeviceFactory_SetFlags(This,flags) \ - ( (This)->lpVtbl -> SetFlags(This,flags) ) +#define ID3D12GraphicsCommandList6_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList6_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList6_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ + ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) + +#define ID3D12GraphicsCommandList6_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList6_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList6_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) + +#define ID3D12GraphicsCommandList6_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12DeviceFactory_GetFlags(This) \ - ( (This)->lpVtbl -> GetFlags(This) ) +#define ID3D12GraphicsCommandList6_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12DeviceFactory_GetConfigurationInterface(This,clsid,iid,ppv) \ - ( (This)->lpVtbl -> GetConfigurationInterface(This,clsid,iid,ppv) ) +#define ID3D12GraphicsCommandList6_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ + ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12DeviceFactory_EnableExperimentalFeatures(This,NumFeatures,pIIDs,pConfigurationStructs,pConfigurationStructSizes) \ - ( (This)->lpVtbl -> EnableExperimentalFeatures(This,NumFeatures,pIIDs,pConfigurationStructs,pConfigurationStructSizes) ) +#define ID3D12GraphicsCommandList6_IASetIndexBuffer(This,pView) \ + ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) -#define ID3D12DeviceFactory_CreateDevice(This,adapter,FeatureLevel,riid,ppvDevice) \ - ( (This)->lpVtbl -> CreateDevice(This,adapter,FeatureLevel,riid,ppvDevice) ) +#define ID3D12GraphicsCommandList6_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) -#endif /* COBJMACROS */ +#define ID3D12GraphicsCommandList6_SOSetTargets(This,StartSlot,NumViews,pViews) \ + ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) +#define ID3D12GraphicsCommandList6_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ + ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) -#endif /* C style interface */ +#define ID3D12GraphicsCommandList6_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) +#define ID3D12GraphicsCommandList6_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) +#define ID3D12GraphicsCommandList6_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) +#define ID3D12GraphicsCommandList6_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ + ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) -#endif /* __ID3D12DeviceFactory_INTERFACE_DEFINED__ */ +#define ID3D12GraphicsCommandList6_DiscardResource(This,pResource,pRegion) \ + ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) +#define ID3D12GraphicsCommandList6_BeginQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) -/* interface __MIDL_itf_d3d12_0000_0060 */ -/* [local] */ +#define ID3D12GraphicsCommandList6_EndQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) -typedef -enum D3D12_DEVICE_FLAGS - { - D3D12_DEVICE_FLAG_NONE = 0, - D3D12_DEVICE_FLAG_DEBUG_LAYER_ENABLED = 0x1, - D3D12_DEVICE_FLAG_GPU_BASED_VALIDATION_ENABLED = 0x2, - D3D12_DEVICE_FLAG_SYNCHRONIZED_COMMAND_QUEUE_VALIDATION_DISABLED = 0x4, - D3D12_DEVICE_FLAG_DRED_AUTO_BREADCRUMBS_ENABLED = 0x8, - D3D12_DEVICE_FLAG_DRED_PAGE_FAULT_REPORTING_ENABLED = 0x10, - D3D12_DEVICE_FLAG_DRED_WATSON_REPORTING_ENABLED = 0x20, - D3D12_DEVICE_FLAG_DRED_BREADCRUMB_CONTEXT_ENABLED = 0x40, - D3D12_DEVICE_FLAG_DRED_USE_MARKERS_ONLY_BREADCRUMBS = 0x80, - D3D12_DEVICE_FLAG_SHADER_INSTRUMENTATION_ENABLED = 0x100, - D3D12_DEVICE_FLAG_AUTO_DEBUG_NAME_ENABLED = 0x200, - D3D12_DEVICE_FLAG_FORCE_LEGACY_STATE_VALIDATION = 0x400 - } D3D12_DEVICE_FLAGS; +#define ID3D12GraphicsCommandList6_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ + ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) -DEFINE_ENUM_FLAG_OPERATORS( D3D12_DEVICE_FLAGS ); -typedef struct D3D12_DEVICE_CONFIGURATION_DESC - { - D3D12_DEVICE_FLAGS Flags; - UINT GpuBasedValidationFlags; - UINT SDKVersion; - UINT NumEnabledExperimentalFeatures; - } D3D12_DEVICE_CONFIGURATION_DESC; +#define ID3D12GraphicsCommandList6_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ + ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) +#define ID3D12GraphicsCommandList6_SetMarker(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) +#define ID3D12GraphicsCommandList6_BeginEvent(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0060_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0060_v0_0_s_ifspec; +#define ID3D12GraphicsCommandList6_EndEvent(This) \ + ( (This)->lpVtbl -> EndEvent(This) ) -#ifndef __ID3D12DeviceConfiguration_INTERFACE_DEFINED__ -#define __ID3D12DeviceConfiguration_INTERFACE_DEFINED__ +#define ID3D12GraphicsCommandList6_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ + ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) -/* interface ID3D12DeviceConfiguration */ -/* [unique][local][object][uuid] */ +#define ID3D12GraphicsCommandList6_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -EXTERN_C const IID IID_ID3D12DeviceConfiguration; +#define ID3D12GraphicsCommandList6_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ + ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -#if defined(__cplusplus) && !defined(CINTERFACE) - - MIDL_INTERFACE("78dbf87b-f766-422b-a61c-c8c446bdb9ad") - ID3D12DeviceConfiguration : public IUnknown - { - public: -#if defined(_MSC_VER) - virtual D3D12_DEVICE_CONFIGURATION_DESC STDMETHODCALLTYPE GetDesc( void) = 0; -#else - virtual D3D12_DEVICE_CONFIGURATION_DESC *STDMETHODCALLTYPE GetDesc( - D3D12_DEVICE_CONFIGURATION_DESC * RetVal) = 0; -#endif - - virtual HRESULT STDMETHODCALLTYPE GetEnabledExperimentalFeatures( - _Out_writes_(NumGuids) GUID *pGuids, - UINT NumGuids) = 0; - - virtual HRESULT STDMETHODCALLTYPE SerializeVersionedRootSignature( - _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *pDesc, - _COM_Outptr_ ID3DBlob **ppResult, - _Always_(_Outptr_opt_result_maybenull_) ID3DBlob **ppError) = 0; - - virtual HRESULT STDMETHODCALLTYPE CreateVersionedRootSignatureDeserializer( - _In_reads_bytes_(Size) const void *pBlob, - SIZE_T Size, - REFIID riid, - _COM_Outptr_ void **ppvDeserializer) = 0; - - }; - - -#else /* C style interface */ +#define ID3D12GraphicsCommandList6_OMSetDepthBounds(This,Min,Max) \ + ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) - typedef struct ID3D12DeviceConfigurationVtbl - { - BEGIN_INTERFACE - - DECLSPEC_XFGVIRT(IUnknown, QueryInterface) - HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12DeviceConfiguration * This, - REFIID riid, - _COM_Outptr_ void **ppvObject); - - DECLSPEC_XFGVIRT(IUnknown, AddRef) - ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12DeviceConfiguration * This); - - DECLSPEC_XFGVIRT(IUnknown, Release) - ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12DeviceConfiguration * This); - - DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, GetDesc) -#if !defined(_WIN32) - D3D12_DEVICE_CONFIGURATION_DESC ( STDMETHODCALLTYPE *GetDesc )( - ID3D12DeviceConfiguration * This); - -#else - D3D12_DEVICE_CONFIGURATION_DESC *( STDMETHODCALLTYPE *GetDesc )( - ID3D12DeviceConfiguration * This, - D3D12_DEVICE_CONFIGURATION_DESC * RetVal); - -#endif - - DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, GetEnabledExperimentalFeatures) - HRESULT ( STDMETHODCALLTYPE *GetEnabledExperimentalFeatures )( - ID3D12DeviceConfiguration * This, - _Out_writes_(NumGuids) GUID *pGuids, - UINT NumGuids); - - DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, SerializeVersionedRootSignature) - HRESULT ( STDMETHODCALLTYPE *SerializeVersionedRootSignature )( - ID3D12DeviceConfiguration * This, - _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *pDesc, - _COM_Outptr_ ID3DBlob **ppResult, - _Always_(_Outptr_opt_result_maybenull_) ID3DBlob **ppError); - - DECLSPEC_XFGVIRT(ID3D12DeviceConfiguration, CreateVersionedRootSignatureDeserializer) - HRESULT ( STDMETHODCALLTYPE *CreateVersionedRootSignatureDeserializer )( - ID3D12DeviceConfiguration * This, - _In_reads_bytes_(Size) const void *pBlob, - SIZE_T Size, - REFIID riid, - _COM_Outptr_ void **ppvDeserializer); - - END_INTERFACE - } ID3D12DeviceConfigurationVtbl; +#define ID3D12GraphicsCommandList6_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ + ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) - interface ID3D12DeviceConfiguration - { - CONST_VTBL struct ID3D12DeviceConfigurationVtbl *lpVtbl; - }; +#define ID3D12GraphicsCommandList6_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ + ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) - +#define ID3D12GraphicsCommandList6_SetViewInstanceMask(This,Mask) \ + ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) -#ifdef COBJMACROS +#define ID3D12GraphicsCommandList6_WriteBufferImmediate(This,Count,pParams,pModes) \ + ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) -#define ID3D12DeviceConfiguration_QueryInterface(This,riid,ppvObject) \ - ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12DeviceConfiguration_AddRef(This) \ - ( (This)->lpVtbl -> AddRef(This) ) +#define ID3D12GraphicsCommandList6_SetProtectedResourceSession(This,pProtectedResourceSession) \ + ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) -#define ID3D12DeviceConfiguration_Release(This) \ - ( (This)->lpVtbl -> Release(This) ) -#if !defined(_WIN32) +#define ID3D12GraphicsCommandList6_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ + ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) -#define ID3D12DeviceConfiguration_GetDesc(This) \ - ( (This)->lpVtbl -> GetDesc(This) ) -#else -#define ID3D12DeviceConfiguration_GetDesc(This,RetVal) \ - ( (This)->lpVtbl -> GetDesc(This,RetVal) ) -#endif +#define ID3D12GraphicsCommandList6_EndRenderPass(This) \ + ( (This)->lpVtbl -> EndRenderPass(This) ) -#define ID3D12DeviceConfiguration_GetEnabledExperimentalFeatures(This,pGuids,NumGuids) \ - ( (This)->lpVtbl -> GetEnabledExperimentalFeatures(This,pGuids,NumGuids) ) +#define ID3D12GraphicsCommandList6_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ + ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) -#define ID3D12DeviceConfiguration_SerializeVersionedRootSignature(This,pDesc,ppResult,ppError) \ - ( (This)->lpVtbl -> SerializeVersionedRootSignature(This,pDesc,ppResult,ppError) ) +#define ID3D12GraphicsCommandList6_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ + ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) -#define ID3D12DeviceConfiguration_CreateVersionedRootSignatureDeserializer(This,pBlob,Size,riid,ppvDeserializer) \ - ( (This)->lpVtbl -> CreateVersionedRootSignatureDeserializer(This,pBlob,Size,riid,ppvDeserializer) ) +#define ID3D12GraphicsCommandList6_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ + ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) -#endif /* COBJMACROS */ +#define ID3D12GraphicsCommandList6_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ + ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) +#define ID3D12GraphicsCommandList6_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ + ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) -#endif /* C style interface */ +#define ID3D12GraphicsCommandList6_SetPipelineState1(This,pStateObject) \ + ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) +#define ID3D12GraphicsCommandList6_DispatchRays(This,pDesc) \ + ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) +#define ID3D12GraphicsCommandList6_RSSetShadingRate(This,baseShadingRate,combiners) \ + ( (This)->lpVtbl -> RSSetShadingRate(This,baseShadingRate,combiners) ) -#endif /* __ID3D12DeviceConfiguration_INTERFACE_DEFINED__ */ +#define ID3D12GraphicsCommandList6_RSSetShadingRateImage(This,shadingRateImage) \ + ( (This)->lpVtbl -> RSSetShadingRateImage(This,shadingRateImage) ) -/* interface __MIDL_itf_d3d12_0000_0061 */ -/* [local] */ +#define ID3D12GraphicsCommandList6_DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ + ( (This)->lpVtbl -> DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) -typedef -enum D3D12_AXIS_SHADING_RATE - { - D3D12_AXIS_SHADING_RATE_1X = 0, - D3D12_AXIS_SHADING_RATE_2X = 0x1, - D3D12_AXIS_SHADING_RATE_4X = 0x2 - } D3D12_AXIS_SHADING_RATE; +#endif /* COBJMACROS */ -#define D3D12_SHADING_RATE_X_AXIS_SHIFT 2 -#define D3D12_SHADING_RATE_VALID_MASK 3 -#define D3D12_MAKE_COARSE_SHADING_RATE(x,y) ((x) << D3D12_SHADING_RATE_X_AXIS_SHIFT | (y)) -#define D3D12_GET_COARSE_SHADING_RATE_X_AXIS(x) (((x) >> D3D12_SHADING_RATE_X_AXIS_SHIFT) & D3D12_SHADING_RATE_VALID_MASK) -#define D3D12_GET_COARSE_SHADING_RATE_Y_AXIS(y) ((y) & D3D12_SHADING_RATE_VALID_MASK) -typedef -enum D3D12_SHADING_RATE - { - D3D12_SHADING_RATE_1X1 = 0, - D3D12_SHADING_RATE_1X2 = 0x1, - D3D12_SHADING_RATE_2X1 = 0x4, - D3D12_SHADING_RATE_2X2 = 0x5, - D3D12_SHADING_RATE_2X4 = 0x6, - D3D12_SHADING_RATE_4X2 = 0x9, - D3D12_SHADING_RATE_4X4 = 0xa - } D3D12_SHADING_RATE; -typedef -enum D3D12_SHADING_RATE_COMBINER - { - D3D12_SHADING_RATE_COMBINER_PASSTHROUGH = 0, - D3D12_SHADING_RATE_COMBINER_OVERRIDE = 1, - D3D12_SHADING_RATE_COMBINER_MIN = 2, - D3D12_SHADING_RATE_COMBINER_MAX = 3, - D3D12_SHADING_RATE_COMBINER_SUM = 4 - } D3D12_SHADING_RATE_COMBINER; +#endif /* C style interface */ -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0061_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0061_v0_0_s_ifspec; -#ifndef __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__ -#define __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__ +#endif /* __ID3D12GraphicsCommandList6_INTERFACE_DEFINED__ */ -/* interface ID3D12GraphicsCommandList5 */ + +#ifndef __ID3D12GraphicsCommandList7_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList7_INTERFACE_DEFINED__ + +/* interface ID3D12GraphicsCommandList7 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12GraphicsCommandList5; +EXTERN_C const IID IID_ID3D12GraphicsCommandList7; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("55050859-4024-474c-87f5-6472eaee44ea") - ID3D12GraphicsCommandList5 : public ID3D12GraphicsCommandList4 + MIDL_INTERFACE("dd171223-8b61-4769-90e3-160ccde4e2c1") + ID3D12GraphicsCommandList7 : public ID3D12GraphicsCommandList6 { public: - virtual void STDMETHODCALLTYPE RSSetShadingRate( - _In_ D3D12_SHADING_RATE baseShadingRate, - _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT) const D3D12_SHADING_RATE_COMBINER *combiners) = 0; - - virtual void STDMETHODCALLTYPE RSSetShadingRateImage( - _In_opt_ ID3D12Resource *shadingRateImage) = 0; + virtual void STDMETHODCALLTYPE Barrier( + UINT32 NumBarrierGroups, + _In_reads_(NumBarrierGroups) const D3D12_BARRIER_GROUP *pBarrierGroups) = 0; }; #else /* C style interface */ - typedef struct ID3D12GraphicsCommandList5Vtbl + typedef struct ID3D12GraphicsCommandList7Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12GraphicsCommandList5 * This); + ID3D12GraphicsCommandList7 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12GraphicsCommandList5 * This); + ID3D12GraphicsCommandList7 * This); DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ REFGUID guid, _Inout_ UINT *pDataSize, _Out_writes_bytes_opt_( *pDataSize ) void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_( DataSize ) const void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ REFGUID guid, _In_opt_ const IUnknown *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetName) HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_z_ LPCWSTR Name); DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, REFIID riid, _COM_Outptr_opt_ void **ppvDevice); DECLSPEC_XFGVIRT(ID3D12CommandList, GetType) D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( - ID3D12GraphicsCommandList5 * This); + ID3D12GraphicsCommandList7 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close) HRESULT ( STDMETHODCALLTYPE *Close )( - ID3D12GraphicsCommandList5 * This); + ID3D12GraphicsCommandList7 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset) HRESULT ( STDMETHODCALLTYPE *Reset )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12CommandAllocator *pAllocator, _In_opt_ ID3D12PipelineState *pInitialState); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState) void ( STDMETHODCALLTYPE *ClearState )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_opt_ ID3D12PipelineState *pPipelineState); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced) void ( STDMETHODCALLTYPE *DrawInstanced )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT VertexCountPerInstance, _In_ UINT InstanceCount, _In_ UINT StartVertexLocation, @@ -25321,7 +33146,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced) void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT IndexCountPerInstance, _In_ UINT InstanceCount, _In_ UINT StartIndexLocation, @@ -25330,14 +33155,14 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch) void ( STDMETHODCALLTYPE *Dispatch )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT ThreadGroupCountX, _In_ UINT ThreadGroupCountY, _In_ UINT ThreadGroupCountZ); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion) void ( STDMETHODCALLTYPE *CopyBufferRegion )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12Resource *pDstBuffer, UINT64 DstOffset, _In_ ID3D12Resource *pSrcBuffer, @@ -25346,7 +33171,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion) void ( STDMETHODCALLTYPE *CopyTextureRegion )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, UINT DstX, UINT DstY, @@ -25356,13 +33181,13 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource) void ( STDMETHODCALLTYPE *CopyResource )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12Resource *pDstResource, _In_ ID3D12Resource *pSrcResource); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles) void ( STDMETHODCALLTYPE *CopyTiles )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12Resource *pTiledResource, _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, @@ -25372,7 +33197,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource) void ( STDMETHODCALLTYPE *ResolveSubresource )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12Resource *pDstResource, _In_ UINT DstSubresource, _In_ ID3D12Resource *pSrcResource, @@ -25381,92 +33206,92 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology) void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports) void ( STDMETHODCALLTYPE *RSSetViewports )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects) void ( STDMETHODCALLTYPE *RSSetScissorRects )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, _In_reads_( NumRects) const D3D12_RECT *pRects); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor) void ( STDMETHODCALLTYPE *OMSetBlendFactor )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef) void ( STDMETHODCALLTYPE *OMSetStencilRef )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT StencilRef); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState) void ( STDMETHODCALLTYPE *SetPipelineState )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12PipelineState *pPipelineState); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier) void ( STDMETHODCALLTYPE *ResourceBarrier )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT NumBarriers, _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle) void ( STDMETHODCALLTYPE *ExecuteBundle )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12GraphicsCommandList *pCommandList); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps) void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT NumDescriptorHeaps, _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature) void ( STDMETHODCALLTYPE *SetComputeRootSignature )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_opt_ ID3D12RootSignature *pRootSignature); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature) void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_opt_ ID3D12RootSignature *pRootSignature); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable) void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable) void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant) void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT RootParameterIndex, _In_ UINT SrcData, _In_ UINT DestOffsetIn32BitValues); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant) void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT RootParameterIndex, _In_ UINT SrcData, _In_ UINT DestOffsetIn32BitValues); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants) void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT RootParameterIndex, _In_ UINT Num32BitValuesToSet, _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, @@ -25474,7 +33299,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants) void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT RootParameterIndex, _In_ UINT Num32BitValuesToSet, _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, @@ -25482,62 +33307,62 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView) void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView) void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView) void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView) void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView) void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView) void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer) void ( STDMETHODCALLTYPE *IASetIndexBuffer )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers) void ( STDMETHODCALLTYPE *IASetVertexBuffers )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT StartSlot, _In_ UINT NumViews, _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets) void ( STDMETHODCALLTYPE *SOSetTargets )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT StartSlot, _In_ UINT NumViews, _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets) void ( STDMETHODCALLTYPE *OMSetRenderTargets )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT NumRenderTargetDescriptors, _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, _In_ BOOL RTsSingleHandleToDescriptorRange, @@ -25545,7 +33370,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView) void ( STDMETHODCALLTYPE *ClearDepthStencilView )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, _In_ D3D12_CLEAR_FLAGS ClearFlags, _In_ FLOAT Depth, @@ -25555,7 +33380,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView) void ( STDMETHODCALLTYPE *ClearRenderTargetView )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, _In_ const FLOAT ColorRGBA[ 4 ], _In_ UINT NumRects, @@ -25563,7 +33388,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint) void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, _In_ ID3D12Resource *pResource, @@ -25573,7 +33398,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat) void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, _In_ ID3D12Resource *pResource, @@ -25583,27 +33408,27 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource) void ( STDMETHODCALLTYPE *DiscardResource )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12Resource *pResource, _In_opt_ const D3D12_DISCARD_REGION *pRegion); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery) void ( STDMETHODCALLTYPE *BeginQuery )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12QueryHeap *pQueryHeap, _In_ D3D12_QUERY_TYPE Type, _In_ UINT Index); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery) void ( STDMETHODCALLTYPE *EndQuery )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12QueryHeap *pQueryHeap, _In_ D3D12_QUERY_TYPE Type, _In_ UINT Index); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData) void ( STDMETHODCALLTYPE *ResolveQueryData )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12QueryHeap *pQueryHeap, _In_ D3D12_QUERY_TYPE Type, _In_ UINT StartIndex, @@ -25613,32 +33438,32 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication) void ( STDMETHODCALLTYPE *SetPredication )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_opt_ ID3D12Resource *pBuffer, _In_ UINT64 AlignedBufferOffset, _In_ D3D12_PREDICATION_OP Operation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker) void ( STDMETHODCALLTYPE *SetMarker )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, UINT Metadata, _In_reads_bytes_opt_(Size) const void *pData, UINT Size); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent) void ( STDMETHODCALLTYPE *BeginEvent )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, UINT Metadata, _In_reads_bytes_opt_(Size) const void *pData, UINT Size); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent) void ( STDMETHODCALLTYPE *EndEvent )( - ID3D12GraphicsCommandList5 * This); + ID3D12GraphicsCommandList7 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect) void ( STDMETHODCALLTYPE *ExecuteIndirect )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12CommandSignature *pCommandSignature, _In_ UINT MaxCommandCount, _In_ ID3D12Resource *pArgumentBuffer, @@ -25648,7 +33473,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT) void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12Resource *pDstBuffer, UINT64 DstOffset, _In_ ID3D12Resource *pSrcBuffer, @@ -25659,7 +33484,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64) void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12Resource *pDstBuffer, UINT64 DstOffset, _In_ ID3D12Resource *pSrcBuffer, @@ -25670,20 +33495,20 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds) void ( STDMETHODCALLTYPE *OMSetDepthBounds )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ FLOAT Min, _In_ FLOAT Max); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions) void ( STDMETHODCALLTYPE *SetSamplePositions )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT NumSamplesPerPixel, _In_ UINT NumPixels, _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion) void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12Resource *pDstResource, _In_ UINT DstSubresource, _In_ UINT DstX, @@ -25696,24 +33521,24 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask) void ( STDMETHODCALLTYPE *SetViewInstanceMask )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT Mask); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate) void ( STDMETHODCALLTYPE *WriteBufferImmediate )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, UINT Count, _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession) void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BeginRenderPass) void ( STDMETHODCALLTYPE *BeginRenderPass )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ UINT NumRenderTargets, _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, @@ -25721,70 +33546,83 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EndRenderPass) void ( STDMETHODCALLTYPE *EndRenderPass )( - ID3D12GraphicsCommandList5 * This); + ID3D12GraphicsCommandList7 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, InitializeMetaCommand) void ( STDMETHODCALLTYPE *InitializeMetaCommand )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12MetaCommand *pMetaCommand, _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, _In_ SIZE_T InitializationParametersDataSizeInBytes); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, ExecuteMetaCommand) void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12MetaCommand *pMetaCommand, _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, _In_ SIZE_T ExecutionParametersDataSizeInBytes); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BuildRaytracingAccelerationStructure) void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, _In_ UINT NumPostbuildInfoDescs, _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EmitRaytracingAccelerationStructurePostbuildInfo) void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, _In_ UINT NumSourceAccelerationStructures, _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, CopyRaytracingAccelerationStructure) void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, SetPipelineState1) void ( STDMETHODCALLTYPE *SetPipelineState1 )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ ID3D12StateObject *pStateObject); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, DispatchRays) void ( STDMETHODCALLTYPE *DispatchRays )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRate) void ( STDMETHODCALLTYPE *RSSetShadingRate )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_ D3D12_SHADING_RATE baseShadingRate, _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT) const D3D12_SHADING_RATE_COMBINER *combiners); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRateImage) void ( STDMETHODCALLTYPE *RSSetShadingRateImage )( - ID3D12GraphicsCommandList5 * This, + ID3D12GraphicsCommandList7 * This, _In_opt_ ID3D12Resource *shadingRateImage); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList6, DispatchMesh) + void ( STDMETHODCALLTYPE *DispatchMesh )( + ID3D12GraphicsCommandList7 * This, + _In_ UINT ThreadGroupCountX, + _In_ UINT ThreadGroupCountY, + _In_ UINT ThreadGroupCountZ); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList7, Barrier) + void ( STDMETHODCALLTYPE *Barrier )( + ID3D12GraphicsCommandList7 * This, + UINT32 NumBarrierGroups, + _In_reads_(NumBarrierGroups) const D3D12_BARRIER_GROUP *pBarrierGroups); + END_INTERFACE - } ID3D12GraphicsCommandList5Vtbl; + } ID3D12GraphicsCommandList7Vtbl; - interface ID3D12GraphicsCommandList5 + interface ID3D12GraphicsCommandList7 { - CONST_VTBL struct ID3D12GraphicsCommandList5Vtbl *lpVtbl; + CONST_VTBL struct ID3D12GraphicsCommandList7Vtbl *lpVtbl; }; @@ -25792,374 +33630,366 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList5; #ifdef COBJMACROS -#define ID3D12GraphicsCommandList5_QueryInterface(This,riid,ppvObject) \ +#define ID3D12GraphicsCommandList7_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12GraphicsCommandList5_AddRef(This) \ +#define ID3D12GraphicsCommandList7_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12GraphicsCommandList5_Release(This) \ +#define ID3D12GraphicsCommandList7_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12GraphicsCommandList5_GetPrivateData(This,guid,pDataSize,pData) \ +#define ID3D12GraphicsCommandList7_GetPrivateData(This,guid,pDataSize,pData) \ ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12GraphicsCommandList5_SetPrivateData(This,guid,DataSize,pData) \ +#define ID3D12GraphicsCommandList7_SetPrivateData(This,guid,DataSize,pData) \ ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12GraphicsCommandList5_SetPrivateDataInterface(This,guid,pData) \ +#define ID3D12GraphicsCommandList7_SetPrivateDataInterface(This,guid,pData) \ ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12GraphicsCommandList5_SetName(This,Name) \ +#define ID3D12GraphicsCommandList7_SetName(This,Name) \ ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12GraphicsCommandList5_GetDevice(This,riid,ppvDevice) \ +#define ID3D12GraphicsCommandList7_GetDevice(This,riid,ppvDevice) \ ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) -#define ID3D12GraphicsCommandList5_GetType(This) \ +#define ID3D12GraphicsCommandList7_GetType(This) \ ( (This)->lpVtbl -> GetType(This) ) -#define ID3D12GraphicsCommandList5_Close(This) \ +#define ID3D12GraphicsCommandList7_Close(This) \ ( (This)->lpVtbl -> Close(This) ) -#define ID3D12GraphicsCommandList5_Reset(This,pAllocator,pInitialState) \ +#define ID3D12GraphicsCommandList7_Reset(This,pAllocator,pInitialState) \ ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) -#define ID3D12GraphicsCommandList5_ClearState(This,pPipelineState) \ +#define ID3D12GraphicsCommandList7_ClearState(This,pPipelineState) \ ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) -#define ID3D12GraphicsCommandList5_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ +#define ID3D12GraphicsCommandList7_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) -#define ID3D12GraphicsCommandList5_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ +#define ID3D12GraphicsCommandList7_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) -#define ID3D12GraphicsCommandList5_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ +#define ID3D12GraphicsCommandList7_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) -#define ID3D12GraphicsCommandList5_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ +#define ID3D12GraphicsCommandList7_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) -#define ID3D12GraphicsCommandList5_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ +#define ID3D12GraphicsCommandList7_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) -#define ID3D12GraphicsCommandList5_CopyResource(This,pDstResource,pSrcResource) \ +#define ID3D12GraphicsCommandList7_CopyResource(This,pDstResource,pSrcResource) \ ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) -#define ID3D12GraphicsCommandList5_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ +#define ID3D12GraphicsCommandList7_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) -#define ID3D12GraphicsCommandList5_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ +#define ID3D12GraphicsCommandList7_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) -#define ID3D12GraphicsCommandList5_IASetPrimitiveTopology(This,PrimitiveTopology) \ +#define ID3D12GraphicsCommandList7_IASetPrimitiveTopology(This,PrimitiveTopology) \ ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) -#define ID3D12GraphicsCommandList5_RSSetViewports(This,NumViewports,pViewports) \ +#define ID3D12GraphicsCommandList7_RSSetViewports(This,NumViewports,pViewports) \ ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) -#define ID3D12GraphicsCommandList5_RSSetScissorRects(This,NumRects,pRects) \ +#define ID3D12GraphicsCommandList7_RSSetScissorRects(This,NumRects,pRects) \ ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) -#define ID3D12GraphicsCommandList5_OMSetBlendFactor(This,BlendFactor) \ +#define ID3D12GraphicsCommandList7_OMSetBlendFactor(This,BlendFactor) \ ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) -#define ID3D12GraphicsCommandList5_OMSetStencilRef(This,StencilRef) \ +#define ID3D12GraphicsCommandList7_OMSetStencilRef(This,StencilRef) \ ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) -#define ID3D12GraphicsCommandList5_SetPipelineState(This,pPipelineState) \ +#define ID3D12GraphicsCommandList7_SetPipelineState(This,pPipelineState) \ ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) -#define ID3D12GraphicsCommandList5_ResourceBarrier(This,NumBarriers,pBarriers) \ +#define ID3D12GraphicsCommandList7_ResourceBarrier(This,NumBarriers,pBarriers) \ ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) -#define ID3D12GraphicsCommandList5_ExecuteBundle(This,pCommandList) \ +#define ID3D12GraphicsCommandList7_ExecuteBundle(This,pCommandList) \ ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) -#define ID3D12GraphicsCommandList5_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ +#define ID3D12GraphicsCommandList7_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) -#define ID3D12GraphicsCommandList5_SetComputeRootSignature(This,pRootSignature) \ +#define ID3D12GraphicsCommandList7_SetComputeRootSignature(This,pRootSignature) \ ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) -#define ID3D12GraphicsCommandList5_SetGraphicsRootSignature(This,pRootSignature) \ +#define ID3D12GraphicsCommandList7_SetGraphicsRootSignature(This,pRootSignature) \ ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) -#define ID3D12GraphicsCommandList5_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ +#define ID3D12GraphicsCommandList7_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12GraphicsCommandList5_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ +#define ID3D12GraphicsCommandList7_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12GraphicsCommandList5_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList7_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList5_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList7_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList5_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList7_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList5_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList7_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList5_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList7_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList5_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList7_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList5_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList7_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList5_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList7_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList5_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList7_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList5_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList7_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList5_IASetIndexBuffer(This,pView) \ +#define ID3D12GraphicsCommandList7_IASetIndexBuffer(This,pView) \ ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) -#define ID3D12GraphicsCommandList5_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ +#define ID3D12GraphicsCommandList7_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) -#define ID3D12GraphicsCommandList5_SOSetTargets(This,StartSlot,NumViews,pViews) \ +#define ID3D12GraphicsCommandList7_SOSetTargets(This,StartSlot,NumViews,pViews) \ ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) -#define ID3D12GraphicsCommandList5_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ +#define ID3D12GraphicsCommandList7_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) -#define ID3D12GraphicsCommandList5_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ +#define ID3D12GraphicsCommandList7_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) -#define ID3D12GraphicsCommandList5_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ +#define ID3D12GraphicsCommandList7_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) -#define ID3D12GraphicsCommandList5_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ +#define ID3D12GraphicsCommandList7_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) -#define ID3D12GraphicsCommandList5_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ +#define ID3D12GraphicsCommandList7_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) -#define ID3D12GraphicsCommandList5_DiscardResource(This,pResource,pRegion) \ +#define ID3D12GraphicsCommandList7_DiscardResource(This,pResource,pRegion) \ ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) -#define ID3D12GraphicsCommandList5_BeginQuery(This,pQueryHeap,Type,Index) \ +#define ID3D12GraphicsCommandList7_BeginQuery(This,pQueryHeap,Type,Index) \ ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) -#define ID3D12GraphicsCommandList5_EndQuery(This,pQueryHeap,Type,Index) \ +#define ID3D12GraphicsCommandList7_EndQuery(This,pQueryHeap,Type,Index) \ ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) -#define ID3D12GraphicsCommandList5_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ +#define ID3D12GraphicsCommandList7_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) -#define ID3D12GraphicsCommandList5_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ +#define ID3D12GraphicsCommandList7_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) -#define ID3D12GraphicsCommandList5_SetMarker(This,Metadata,pData,Size) \ +#define ID3D12GraphicsCommandList7_SetMarker(This,Metadata,pData,Size) \ ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) -#define ID3D12GraphicsCommandList5_BeginEvent(This,Metadata,pData,Size) \ +#define ID3D12GraphicsCommandList7_BeginEvent(This,Metadata,pData,Size) \ ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) -#define ID3D12GraphicsCommandList5_EndEvent(This) \ +#define ID3D12GraphicsCommandList7_EndEvent(This) \ ( (This)->lpVtbl -> EndEvent(This) ) -#define ID3D12GraphicsCommandList5_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ +#define ID3D12GraphicsCommandList7_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) -#define ID3D12GraphicsCommandList5_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ +#define ID3D12GraphicsCommandList7_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -#define ID3D12GraphicsCommandList5_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ +#define ID3D12GraphicsCommandList7_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -#define ID3D12GraphicsCommandList5_OMSetDepthBounds(This,Min,Max) \ +#define ID3D12GraphicsCommandList7_OMSetDepthBounds(This,Min,Max) \ ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) -#define ID3D12GraphicsCommandList5_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ +#define ID3D12GraphicsCommandList7_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) -#define ID3D12GraphicsCommandList5_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ +#define ID3D12GraphicsCommandList7_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) -#define ID3D12GraphicsCommandList5_SetViewInstanceMask(This,Mask) \ +#define ID3D12GraphicsCommandList7_SetViewInstanceMask(This,Mask) \ ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) -#define ID3D12GraphicsCommandList5_WriteBufferImmediate(This,Count,pParams,pModes) \ +#define ID3D12GraphicsCommandList7_WriteBufferImmediate(This,Count,pParams,pModes) \ ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) -#define ID3D12GraphicsCommandList5_SetProtectedResourceSession(This,pProtectedResourceSession) \ +#define ID3D12GraphicsCommandList7_SetProtectedResourceSession(This,pProtectedResourceSession) \ ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) -#define ID3D12GraphicsCommandList5_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ +#define ID3D12GraphicsCommandList7_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) -#define ID3D12GraphicsCommandList5_EndRenderPass(This) \ +#define ID3D12GraphicsCommandList7_EndRenderPass(This) \ ( (This)->lpVtbl -> EndRenderPass(This) ) -#define ID3D12GraphicsCommandList5_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ +#define ID3D12GraphicsCommandList7_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) -#define ID3D12GraphicsCommandList5_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ +#define ID3D12GraphicsCommandList7_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) -#define ID3D12GraphicsCommandList5_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ +#define ID3D12GraphicsCommandList7_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) -#define ID3D12GraphicsCommandList5_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ +#define ID3D12GraphicsCommandList7_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) -#define ID3D12GraphicsCommandList5_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ +#define ID3D12GraphicsCommandList7_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) -#define ID3D12GraphicsCommandList5_SetPipelineState1(This,pStateObject) \ +#define ID3D12GraphicsCommandList7_SetPipelineState1(This,pStateObject) \ ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) -#define ID3D12GraphicsCommandList5_DispatchRays(This,pDesc) \ +#define ID3D12GraphicsCommandList7_DispatchRays(This,pDesc) \ ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) -#define ID3D12GraphicsCommandList5_RSSetShadingRate(This,baseShadingRate,combiners) \ +#define ID3D12GraphicsCommandList7_RSSetShadingRate(This,baseShadingRate,combiners) \ ( (This)->lpVtbl -> RSSetShadingRate(This,baseShadingRate,combiners) ) -#define ID3D12GraphicsCommandList5_RSSetShadingRateImage(This,shadingRateImage) \ +#define ID3D12GraphicsCommandList7_RSSetShadingRateImage(This,shadingRateImage) \ ( (This)->lpVtbl -> RSSetShadingRateImage(This,shadingRateImage) ) -#endif /* COBJMACROS */ - -#endif /* C style interface */ +#define ID3D12GraphicsCommandList7_DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ + ( (This)->lpVtbl -> DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) +#define ID3D12GraphicsCommandList7_Barrier(This,NumBarrierGroups,pBarrierGroups) \ + ( (This)->lpVtbl -> Barrier(This,NumBarrierGroups,pBarrierGroups) ) +#endif /* COBJMACROS */ -#endif /* __ID3D12GraphicsCommandList5_INTERFACE_DEFINED__ */ +#endif /* C style interface */ -/* interface __MIDL_itf_d3d12_0000_0062 */ -/* [local] */ -typedef struct D3D12_DISPATCH_MESH_ARGUMENTS - { - UINT ThreadGroupCountX; - UINT ThreadGroupCountY; - UINT ThreadGroupCountZ; - } D3D12_DISPATCH_MESH_ARGUMENTS; +#endif /* __ID3D12GraphicsCommandList7_INTERFACE_DEFINED__ */ -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0062_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0062_v0_0_s_ifspec; -#ifndef __ID3D12GraphicsCommandList6_INTERFACE_DEFINED__ -#define __ID3D12GraphicsCommandList6_INTERFACE_DEFINED__ +#ifndef __ID3D12GraphicsCommandList8_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList8_INTERFACE_DEFINED__ -/* interface ID3D12GraphicsCommandList6 */ +/* interface ID3D12GraphicsCommandList8 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12GraphicsCommandList6; +EXTERN_C const IID IID_ID3D12GraphicsCommandList8; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("c3827890-e548-4cfa-96cf-5689a9370f80") - ID3D12GraphicsCommandList6 : public ID3D12GraphicsCommandList5 + MIDL_INTERFACE("ee936ef9-599d-4d28-938e-23c4ad05ce51") + ID3D12GraphicsCommandList8 : public ID3D12GraphicsCommandList7 { public: - virtual void STDMETHODCALLTYPE DispatchMesh( - _In_ UINT ThreadGroupCountX, - _In_ UINT ThreadGroupCountY, - _In_ UINT ThreadGroupCountZ) = 0; + virtual void STDMETHODCALLTYPE OMSetFrontAndBackStencilRef( + _In_ UINT FrontStencilRef, + _In_ UINT BackStencilRef) = 0; }; #else /* C style interface */ - typedef struct ID3D12GraphicsCommandList6Vtbl + typedef struct ID3D12GraphicsCommandList8Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12GraphicsCommandList6 * This); + ID3D12GraphicsCommandList8 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12GraphicsCommandList6 * This); + ID3D12GraphicsCommandList8 * This); DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ REFGUID guid, _Inout_ UINT *pDataSize, _Out_writes_bytes_opt_( *pDataSize ) void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_( DataSize ) const void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ REFGUID guid, _In_opt_ const IUnknown *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetName) HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_z_ LPCWSTR Name); DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, REFIID riid, _COM_Outptr_opt_ void **ppvDevice); DECLSPEC_XFGVIRT(ID3D12CommandList, GetType) D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( - ID3D12GraphicsCommandList6 * This); + ID3D12GraphicsCommandList8 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close) HRESULT ( STDMETHODCALLTYPE *Close )( - ID3D12GraphicsCommandList6 * This); + ID3D12GraphicsCommandList8 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset) HRESULT ( STDMETHODCALLTYPE *Reset )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12CommandAllocator *pAllocator, _In_opt_ ID3D12PipelineState *pInitialState); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState) void ( STDMETHODCALLTYPE *ClearState )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_opt_ ID3D12PipelineState *pPipelineState); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced) void ( STDMETHODCALLTYPE *DrawInstanced )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT VertexCountPerInstance, _In_ UINT InstanceCount, _In_ UINT StartVertexLocation, @@ -26167,7 +33997,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced) void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT IndexCountPerInstance, _In_ UINT InstanceCount, _In_ UINT StartIndexLocation, @@ -26176,14 +34006,14 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch) void ( STDMETHODCALLTYPE *Dispatch )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT ThreadGroupCountX, _In_ UINT ThreadGroupCountY, _In_ UINT ThreadGroupCountZ); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion) void ( STDMETHODCALLTYPE *CopyBufferRegion )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12Resource *pDstBuffer, UINT64 DstOffset, _In_ ID3D12Resource *pSrcBuffer, @@ -26192,7 +34022,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion) void ( STDMETHODCALLTYPE *CopyTextureRegion )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, UINT DstX, UINT DstY, @@ -26202,13 +34032,13 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource) void ( STDMETHODCALLTYPE *CopyResource )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12Resource *pDstResource, _In_ ID3D12Resource *pSrcResource); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles) void ( STDMETHODCALLTYPE *CopyTiles )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12Resource *pTiledResource, _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, @@ -26218,7 +34048,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource) void ( STDMETHODCALLTYPE *ResolveSubresource )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12Resource *pDstResource, _In_ UINT DstSubresource, _In_ ID3D12Resource *pSrcResource, @@ -26227,92 +34057,92 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology) void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports) void ( STDMETHODCALLTYPE *RSSetViewports )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects) void ( STDMETHODCALLTYPE *RSSetScissorRects )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, _In_reads_( NumRects) const D3D12_RECT *pRects); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor) void ( STDMETHODCALLTYPE *OMSetBlendFactor )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef) void ( STDMETHODCALLTYPE *OMSetStencilRef )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT StencilRef); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState) void ( STDMETHODCALLTYPE *SetPipelineState )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12PipelineState *pPipelineState); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier) void ( STDMETHODCALLTYPE *ResourceBarrier )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT NumBarriers, _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle) void ( STDMETHODCALLTYPE *ExecuteBundle )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12GraphicsCommandList *pCommandList); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps) void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT NumDescriptorHeaps, _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature) void ( STDMETHODCALLTYPE *SetComputeRootSignature )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_opt_ ID3D12RootSignature *pRootSignature); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature) void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_opt_ ID3D12RootSignature *pRootSignature); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable) void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable) void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant) void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT RootParameterIndex, _In_ UINT SrcData, _In_ UINT DestOffsetIn32BitValues); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant) void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT RootParameterIndex, _In_ UINT SrcData, _In_ UINT DestOffsetIn32BitValues); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants) void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT RootParameterIndex, _In_ UINT Num32BitValuesToSet, _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, @@ -26320,7 +34150,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants) void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT RootParameterIndex, _In_ UINT Num32BitValuesToSet, _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, @@ -26328,62 +34158,62 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView) void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView) void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView) void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView) void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView) void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView) void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer) void ( STDMETHODCALLTYPE *IASetIndexBuffer )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers) void ( STDMETHODCALLTYPE *IASetVertexBuffers )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT StartSlot, _In_ UINT NumViews, _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets) void ( STDMETHODCALLTYPE *SOSetTargets )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT StartSlot, _In_ UINT NumViews, _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets) void ( STDMETHODCALLTYPE *OMSetRenderTargets )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT NumRenderTargetDescriptors, _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, _In_ BOOL RTsSingleHandleToDescriptorRange, @@ -26391,7 +34221,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView) void ( STDMETHODCALLTYPE *ClearDepthStencilView )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, _In_ D3D12_CLEAR_FLAGS ClearFlags, _In_ FLOAT Depth, @@ -26401,7 +34231,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView) void ( STDMETHODCALLTYPE *ClearRenderTargetView )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, _In_ const FLOAT ColorRGBA[ 4 ], _In_ UINT NumRects, @@ -26409,7 +34239,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint) void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, _In_ ID3D12Resource *pResource, @@ -26419,7 +34249,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat) void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, _In_ ID3D12Resource *pResource, @@ -26429,27 +34259,27 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource) void ( STDMETHODCALLTYPE *DiscardResource )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12Resource *pResource, _In_opt_ const D3D12_DISCARD_REGION *pRegion); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery) void ( STDMETHODCALLTYPE *BeginQuery )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12QueryHeap *pQueryHeap, _In_ D3D12_QUERY_TYPE Type, _In_ UINT Index); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery) void ( STDMETHODCALLTYPE *EndQuery )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12QueryHeap *pQueryHeap, _In_ D3D12_QUERY_TYPE Type, _In_ UINT Index); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData) void ( STDMETHODCALLTYPE *ResolveQueryData )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12QueryHeap *pQueryHeap, _In_ D3D12_QUERY_TYPE Type, _In_ UINT StartIndex, @@ -26459,32 +34289,32 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication) void ( STDMETHODCALLTYPE *SetPredication )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_opt_ ID3D12Resource *pBuffer, _In_ UINT64 AlignedBufferOffset, _In_ D3D12_PREDICATION_OP Operation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker) void ( STDMETHODCALLTYPE *SetMarker )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, UINT Metadata, _In_reads_bytes_opt_(Size) const void *pData, UINT Size); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent) void ( STDMETHODCALLTYPE *BeginEvent )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, UINT Metadata, _In_reads_bytes_opt_(Size) const void *pData, UINT Size); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent) void ( STDMETHODCALLTYPE *EndEvent )( - ID3D12GraphicsCommandList6 * This); + ID3D12GraphicsCommandList8 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect) void ( STDMETHODCALLTYPE *ExecuteIndirect )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12CommandSignature *pCommandSignature, _In_ UINT MaxCommandCount, _In_ ID3D12Resource *pArgumentBuffer, @@ -26494,7 +34324,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT) void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12Resource *pDstBuffer, UINT64 DstOffset, _In_ ID3D12Resource *pSrcBuffer, @@ -26505,7 +34335,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64) void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12Resource *pDstBuffer, UINT64 DstOffset, _In_ ID3D12Resource *pSrcBuffer, @@ -26516,20 +34346,20 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds) void ( STDMETHODCALLTYPE *OMSetDepthBounds )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ FLOAT Min, _In_ FLOAT Max); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions) void ( STDMETHODCALLTYPE *SetSamplePositions )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT NumSamplesPerPixel, _In_ UINT NumPixels, _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion) void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12Resource *pDstResource, _In_ UINT DstSubresource, _In_ UINT DstX, @@ -26542,24 +34372,24 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask) void ( STDMETHODCALLTYPE *SetViewInstanceMask )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT Mask); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate) void ( STDMETHODCALLTYPE *WriteBufferImmediate )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, UINT Count, _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession) void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BeginRenderPass) void ( STDMETHODCALLTYPE *BeginRenderPass )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT NumRenderTargets, _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, @@ -26567,77 +34397,89 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EndRenderPass) void ( STDMETHODCALLTYPE *EndRenderPass )( - ID3D12GraphicsCommandList6 * This); + ID3D12GraphicsCommandList8 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, InitializeMetaCommand) void ( STDMETHODCALLTYPE *InitializeMetaCommand )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12MetaCommand *pMetaCommand, _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, _In_ SIZE_T InitializationParametersDataSizeInBytes); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, ExecuteMetaCommand) void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12MetaCommand *pMetaCommand, _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, _In_ SIZE_T ExecutionParametersDataSizeInBytes); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BuildRaytracingAccelerationStructure) void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, _In_ UINT NumPostbuildInfoDescs, _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EmitRaytracingAccelerationStructurePostbuildInfo) void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, _In_ UINT NumSourceAccelerationStructures, _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, CopyRaytracingAccelerationStructure) void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, SetPipelineState1) void ( STDMETHODCALLTYPE *SetPipelineState1 )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ ID3D12StateObject *pStateObject); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, DispatchRays) void ( STDMETHODCALLTYPE *DispatchRays )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRate) void ( STDMETHODCALLTYPE *RSSetShadingRate )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ D3D12_SHADING_RATE baseShadingRate, _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT) const D3D12_SHADING_RATE_COMBINER *combiners); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRateImage) void ( STDMETHODCALLTYPE *RSSetShadingRateImage )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_opt_ ID3D12Resource *shadingRateImage); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList6, DispatchMesh) void ( STDMETHODCALLTYPE *DispatchMesh )( - ID3D12GraphicsCommandList6 * This, + ID3D12GraphicsCommandList8 * This, _In_ UINT ThreadGroupCountX, _In_ UINT ThreadGroupCountY, _In_ UINT ThreadGroupCountZ); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList7, Barrier) + void ( STDMETHODCALLTYPE *Barrier )( + ID3D12GraphicsCommandList8 * This, + UINT32 NumBarrierGroups, + _In_reads_(NumBarrierGroups) const D3D12_BARRIER_GROUP *pBarrierGroups); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList8, OMSetFrontAndBackStencilRef) + void ( STDMETHODCALLTYPE *OMSetFrontAndBackStencilRef )( + ID3D12GraphicsCommandList8 * This, + _In_ UINT FrontStencilRef, + _In_ UINT BackStencilRef); + END_INTERFACE - } ID3D12GraphicsCommandList6Vtbl; + } ID3D12GraphicsCommandList8Vtbl; - interface ID3D12GraphicsCommandList6 + interface ID3D12GraphicsCommandList8 { - CONST_VTBL struct ID3D12GraphicsCommandList6Vtbl *lpVtbl; + CONST_VTBL struct ID3D12GraphicsCommandList8Vtbl *lpVtbl; }; @@ -26645,256 +34487,264 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; #ifdef COBJMACROS -#define ID3D12GraphicsCommandList6_QueryInterface(This,riid,ppvObject) \ +#define ID3D12GraphicsCommandList8_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12GraphicsCommandList6_AddRef(This) \ +#define ID3D12GraphicsCommandList8_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12GraphicsCommandList6_Release(This) \ +#define ID3D12GraphicsCommandList8_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12GraphicsCommandList6_GetPrivateData(This,guid,pDataSize,pData) \ +#define ID3D12GraphicsCommandList8_GetPrivateData(This,guid,pDataSize,pData) \ ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12GraphicsCommandList6_SetPrivateData(This,guid,DataSize,pData) \ +#define ID3D12GraphicsCommandList8_SetPrivateData(This,guid,DataSize,pData) \ ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12GraphicsCommandList6_SetPrivateDataInterface(This,guid,pData) \ +#define ID3D12GraphicsCommandList8_SetPrivateDataInterface(This,guid,pData) \ ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12GraphicsCommandList6_SetName(This,Name) \ +#define ID3D12GraphicsCommandList8_SetName(This,Name) \ ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12GraphicsCommandList6_GetDevice(This,riid,ppvDevice) \ +#define ID3D12GraphicsCommandList8_GetDevice(This,riid,ppvDevice) \ ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) -#define ID3D12GraphicsCommandList6_GetType(This) \ +#define ID3D12GraphicsCommandList8_GetType(This) \ ( (This)->lpVtbl -> GetType(This) ) -#define ID3D12GraphicsCommandList6_Close(This) \ +#define ID3D12GraphicsCommandList8_Close(This) \ ( (This)->lpVtbl -> Close(This) ) -#define ID3D12GraphicsCommandList6_Reset(This,pAllocator,pInitialState) \ +#define ID3D12GraphicsCommandList8_Reset(This,pAllocator,pInitialState) \ ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) -#define ID3D12GraphicsCommandList6_ClearState(This,pPipelineState) \ +#define ID3D12GraphicsCommandList8_ClearState(This,pPipelineState) \ ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) -#define ID3D12GraphicsCommandList6_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ +#define ID3D12GraphicsCommandList8_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) -#define ID3D12GraphicsCommandList6_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ +#define ID3D12GraphicsCommandList8_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) -#define ID3D12GraphicsCommandList6_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ +#define ID3D12GraphicsCommandList8_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) -#define ID3D12GraphicsCommandList6_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ +#define ID3D12GraphicsCommandList8_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) -#define ID3D12GraphicsCommandList6_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ +#define ID3D12GraphicsCommandList8_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) -#define ID3D12GraphicsCommandList6_CopyResource(This,pDstResource,pSrcResource) \ +#define ID3D12GraphicsCommandList8_CopyResource(This,pDstResource,pSrcResource) \ ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) -#define ID3D12GraphicsCommandList6_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ +#define ID3D12GraphicsCommandList8_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) -#define ID3D12GraphicsCommandList6_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ +#define ID3D12GraphicsCommandList8_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) -#define ID3D12GraphicsCommandList6_IASetPrimitiveTopology(This,PrimitiveTopology) \ +#define ID3D12GraphicsCommandList8_IASetPrimitiveTopology(This,PrimitiveTopology) \ ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) -#define ID3D12GraphicsCommandList6_RSSetViewports(This,NumViewports,pViewports) \ +#define ID3D12GraphicsCommandList8_RSSetViewports(This,NumViewports,pViewports) \ ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) -#define ID3D12GraphicsCommandList6_RSSetScissorRects(This,NumRects,pRects) \ +#define ID3D12GraphicsCommandList8_RSSetScissorRects(This,NumRects,pRects) \ ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) -#define ID3D12GraphicsCommandList6_OMSetBlendFactor(This,BlendFactor) \ +#define ID3D12GraphicsCommandList8_OMSetBlendFactor(This,BlendFactor) \ ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) -#define ID3D12GraphicsCommandList6_OMSetStencilRef(This,StencilRef) \ +#define ID3D12GraphicsCommandList8_OMSetStencilRef(This,StencilRef) \ ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) -#define ID3D12GraphicsCommandList6_SetPipelineState(This,pPipelineState) \ +#define ID3D12GraphicsCommandList8_SetPipelineState(This,pPipelineState) \ ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) -#define ID3D12GraphicsCommandList6_ResourceBarrier(This,NumBarriers,pBarriers) \ +#define ID3D12GraphicsCommandList8_ResourceBarrier(This,NumBarriers,pBarriers) \ ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) -#define ID3D12GraphicsCommandList6_ExecuteBundle(This,pCommandList) \ +#define ID3D12GraphicsCommandList8_ExecuteBundle(This,pCommandList) \ ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) -#define ID3D12GraphicsCommandList6_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ +#define ID3D12GraphicsCommandList8_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) -#define ID3D12GraphicsCommandList6_SetComputeRootSignature(This,pRootSignature) \ +#define ID3D12GraphicsCommandList8_SetComputeRootSignature(This,pRootSignature) \ ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) -#define ID3D12GraphicsCommandList6_SetGraphicsRootSignature(This,pRootSignature) \ +#define ID3D12GraphicsCommandList8_SetGraphicsRootSignature(This,pRootSignature) \ ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) -#define ID3D12GraphicsCommandList6_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ +#define ID3D12GraphicsCommandList8_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12GraphicsCommandList6_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ +#define ID3D12GraphicsCommandList8_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12GraphicsCommandList6_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList8_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList6_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList8_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList6_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList8_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList6_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList8_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList6_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList8_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList6_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList8_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList6_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList8_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList6_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList8_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList6_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList8_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList6_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList8_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList6_IASetIndexBuffer(This,pView) \ +#define ID3D12GraphicsCommandList8_IASetIndexBuffer(This,pView) \ ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) -#define ID3D12GraphicsCommandList6_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ +#define ID3D12GraphicsCommandList8_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) -#define ID3D12GraphicsCommandList6_SOSetTargets(This,StartSlot,NumViews,pViews) \ +#define ID3D12GraphicsCommandList8_SOSetTargets(This,StartSlot,NumViews,pViews) \ ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) -#define ID3D12GraphicsCommandList6_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ +#define ID3D12GraphicsCommandList8_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) -#define ID3D12GraphicsCommandList6_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ +#define ID3D12GraphicsCommandList8_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) -#define ID3D12GraphicsCommandList6_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ +#define ID3D12GraphicsCommandList8_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) -#define ID3D12GraphicsCommandList6_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ +#define ID3D12GraphicsCommandList8_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) -#define ID3D12GraphicsCommandList6_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ +#define ID3D12GraphicsCommandList8_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) -#define ID3D12GraphicsCommandList6_DiscardResource(This,pResource,pRegion) \ +#define ID3D12GraphicsCommandList8_DiscardResource(This,pResource,pRegion) \ ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) -#define ID3D12GraphicsCommandList6_BeginQuery(This,pQueryHeap,Type,Index) \ +#define ID3D12GraphicsCommandList8_BeginQuery(This,pQueryHeap,Type,Index) \ ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) -#define ID3D12GraphicsCommandList6_EndQuery(This,pQueryHeap,Type,Index) \ +#define ID3D12GraphicsCommandList8_EndQuery(This,pQueryHeap,Type,Index) \ ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) -#define ID3D12GraphicsCommandList6_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ +#define ID3D12GraphicsCommandList8_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) -#define ID3D12GraphicsCommandList6_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ +#define ID3D12GraphicsCommandList8_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) -#define ID3D12GraphicsCommandList6_SetMarker(This,Metadata,pData,Size) \ +#define ID3D12GraphicsCommandList8_SetMarker(This,Metadata,pData,Size) \ ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) -#define ID3D12GraphicsCommandList6_BeginEvent(This,Metadata,pData,Size) \ +#define ID3D12GraphicsCommandList8_BeginEvent(This,Metadata,pData,Size) \ ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) -#define ID3D12GraphicsCommandList6_EndEvent(This) \ +#define ID3D12GraphicsCommandList8_EndEvent(This) \ ( (This)->lpVtbl -> EndEvent(This) ) -#define ID3D12GraphicsCommandList6_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ +#define ID3D12GraphicsCommandList8_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) -#define ID3D12GraphicsCommandList6_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ +#define ID3D12GraphicsCommandList8_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -#define ID3D12GraphicsCommandList6_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ +#define ID3D12GraphicsCommandList8_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -#define ID3D12GraphicsCommandList6_OMSetDepthBounds(This,Min,Max) \ +#define ID3D12GraphicsCommandList8_OMSetDepthBounds(This,Min,Max) \ ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) -#define ID3D12GraphicsCommandList6_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ +#define ID3D12GraphicsCommandList8_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) -#define ID3D12GraphicsCommandList6_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ +#define ID3D12GraphicsCommandList8_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) -#define ID3D12GraphicsCommandList6_SetViewInstanceMask(This,Mask) \ +#define ID3D12GraphicsCommandList8_SetViewInstanceMask(This,Mask) \ ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) -#define ID3D12GraphicsCommandList6_WriteBufferImmediate(This,Count,pParams,pModes) \ +#define ID3D12GraphicsCommandList8_WriteBufferImmediate(This,Count,pParams,pModes) \ ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) -#define ID3D12GraphicsCommandList6_SetProtectedResourceSession(This,pProtectedResourceSession) \ +#define ID3D12GraphicsCommandList8_SetProtectedResourceSession(This,pProtectedResourceSession) \ ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) -#define ID3D12GraphicsCommandList6_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ +#define ID3D12GraphicsCommandList8_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) -#define ID3D12GraphicsCommandList6_EndRenderPass(This) \ +#define ID3D12GraphicsCommandList8_EndRenderPass(This) \ ( (This)->lpVtbl -> EndRenderPass(This) ) -#define ID3D12GraphicsCommandList6_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ +#define ID3D12GraphicsCommandList8_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) -#define ID3D12GraphicsCommandList6_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ +#define ID3D12GraphicsCommandList8_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) -#define ID3D12GraphicsCommandList6_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ +#define ID3D12GraphicsCommandList8_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) -#define ID3D12GraphicsCommandList6_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ +#define ID3D12GraphicsCommandList8_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) -#define ID3D12GraphicsCommandList6_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ +#define ID3D12GraphicsCommandList8_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) -#define ID3D12GraphicsCommandList6_SetPipelineState1(This,pStateObject) \ +#define ID3D12GraphicsCommandList8_SetPipelineState1(This,pStateObject) \ ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) -#define ID3D12GraphicsCommandList6_DispatchRays(This,pDesc) \ +#define ID3D12GraphicsCommandList8_DispatchRays(This,pDesc) \ ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) -#define ID3D12GraphicsCommandList6_RSSetShadingRate(This,baseShadingRate,combiners) \ +#define ID3D12GraphicsCommandList8_RSSetShadingRate(This,baseShadingRate,combiners) \ ( (This)->lpVtbl -> RSSetShadingRate(This,baseShadingRate,combiners) ) -#define ID3D12GraphicsCommandList6_RSSetShadingRateImage(This,shadingRateImage) \ +#define ID3D12GraphicsCommandList8_RSSetShadingRateImage(This,shadingRateImage) \ ( (This)->lpVtbl -> RSSetShadingRateImage(This,shadingRateImage) ) -#define ID3D12GraphicsCommandList6_DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ +#define ID3D12GraphicsCommandList8_DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ ( (This)->lpVtbl -> DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) + +#define ID3D12GraphicsCommandList8_Barrier(This,NumBarrierGroups,pBarrierGroups) \ + ( (This)->lpVtbl -> Barrier(This,NumBarrierGroups,pBarrierGroups) ) + + +#define ID3D12GraphicsCommandList8_OMSetFrontAndBackStencilRef(This,FrontStencilRef,BackStencilRef) \ + ( (This)->lpVtbl -> OMSetFrontAndBackStencilRef(This,FrontStencilRef,BackStencilRef) ) + #endif /* COBJMACROS */ @@ -26903,104 +34753,108 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList6; -#endif /* __ID3D12GraphicsCommandList6_INTERFACE_DEFINED__ */ +#endif /* __ID3D12GraphicsCommandList8_INTERFACE_DEFINED__ */ -#ifndef __ID3D12GraphicsCommandList7_INTERFACE_DEFINED__ -#define __ID3D12GraphicsCommandList7_INTERFACE_DEFINED__ +#ifndef __ID3D12GraphicsCommandList9_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList9_INTERFACE_DEFINED__ -/* interface ID3D12GraphicsCommandList7 */ +/* interface ID3D12GraphicsCommandList9 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12GraphicsCommandList7; +EXTERN_C const IID IID_ID3D12GraphicsCommandList9; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("dd171223-8b61-4769-90e3-160ccde4e2c1") - ID3D12GraphicsCommandList7 : public ID3D12GraphicsCommandList6 + MIDL_INTERFACE("34ed2808-ffe6-4c2b-b11a-cabd2b0c59e1") + ID3D12GraphicsCommandList9 : public ID3D12GraphicsCommandList8 { public: - virtual void STDMETHODCALLTYPE Barrier( - UINT32 NumBarrierGroups, - _In_reads_(NumBarrierGroups) const D3D12_BARRIER_GROUP *pBarrierGroups) = 0; + virtual void STDMETHODCALLTYPE RSSetDepthBias( + _In_ FLOAT DepthBias, + _In_ FLOAT DepthBiasClamp, + _In_ FLOAT SlopeScaledDepthBias) = 0; + + virtual void STDMETHODCALLTYPE IASetIndexBufferStripCutValue( + _In_ D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue) = 0; }; #else /* C style interface */ - typedef struct ID3D12GraphicsCommandList7Vtbl + typedef struct ID3D12GraphicsCommandList9Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12GraphicsCommandList7 * This); + ID3D12GraphicsCommandList9 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12GraphicsCommandList7 * This); + ID3D12GraphicsCommandList9 * This); DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ REFGUID guid, _Inout_ UINT *pDataSize, _Out_writes_bytes_opt_( *pDataSize ) void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_( DataSize ) const void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ REFGUID guid, _In_opt_ const IUnknown *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetName) HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_z_ LPCWSTR Name); DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, REFIID riid, _COM_Outptr_opt_ void **ppvDevice); DECLSPEC_XFGVIRT(ID3D12CommandList, GetType) D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( - ID3D12GraphicsCommandList7 * This); + ID3D12GraphicsCommandList9 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close) HRESULT ( STDMETHODCALLTYPE *Close )( - ID3D12GraphicsCommandList7 * This); + ID3D12GraphicsCommandList9 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset) HRESULT ( STDMETHODCALLTYPE *Reset )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12CommandAllocator *pAllocator, _In_opt_ ID3D12PipelineState *pInitialState); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState) void ( STDMETHODCALLTYPE *ClearState )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_opt_ ID3D12PipelineState *pPipelineState); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced) void ( STDMETHODCALLTYPE *DrawInstanced )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT VertexCountPerInstance, _In_ UINT InstanceCount, _In_ UINT StartVertexLocation, @@ -27008,7 +34862,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced) void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT IndexCountPerInstance, _In_ UINT InstanceCount, _In_ UINT StartIndexLocation, @@ -27017,14 +34871,14 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch) void ( STDMETHODCALLTYPE *Dispatch )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT ThreadGroupCountX, _In_ UINT ThreadGroupCountY, _In_ UINT ThreadGroupCountZ); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion) void ( STDMETHODCALLTYPE *CopyBufferRegion )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12Resource *pDstBuffer, UINT64 DstOffset, _In_ ID3D12Resource *pSrcBuffer, @@ -27033,7 +34887,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion) void ( STDMETHODCALLTYPE *CopyTextureRegion )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, UINT DstX, UINT DstY, @@ -27043,13 +34897,13 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource) void ( STDMETHODCALLTYPE *CopyResource )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12Resource *pDstResource, _In_ ID3D12Resource *pSrcResource); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles) void ( STDMETHODCALLTYPE *CopyTiles )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12Resource *pTiledResource, _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, @@ -27059,7 +34913,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource) void ( STDMETHODCALLTYPE *ResolveSubresource )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12Resource *pDstResource, _In_ UINT DstSubresource, _In_ ID3D12Resource *pSrcResource, @@ -27068,92 +34922,92 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology) void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports) void ( STDMETHODCALLTYPE *RSSetViewports )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects) void ( STDMETHODCALLTYPE *RSSetScissorRects )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, _In_reads_( NumRects) const D3D12_RECT *pRects); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor) void ( STDMETHODCALLTYPE *OMSetBlendFactor )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef) void ( STDMETHODCALLTYPE *OMSetStencilRef )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT StencilRef); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState) void ( STDMETHODCALLTYPE *SetPipelineState )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12PipelineState *pPipelineState); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier) void ( STDMETHODCALLTYPE *ResourceBarrier )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT NumBarriers, _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle) void ( STDMETHODCALLTYPE *ExecuteBundle )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12GraphicsCommandList *pCommandList); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps) void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT NumDescriptorHeaps, _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature) void ( STDMETHODCALLTYPE *SetComputeRootSignature )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_opt_ ID3D12RootSignature *pRootSignature); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature) void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_opt_ ID3D12RootSignature *pRootSignature); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable) void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable) void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant) void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT RootParameterIndex, _In_ UINT SrcData, _In_ UINT DestOffsetIn32BitValues); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant) void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT RootParameterIndex, _In_ UINT SrcData, _In_ UINT DestOffsetIn32BitValues); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants) void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT RootParameterIndex, _In_ UINT Num32BitValuesToSet, _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, @@ -27161,7 +35015,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants) void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT RootParameterIndex, _In_ UINT Num32BitValuesToSet, _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, @@ -27169,62 +35023,62 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView) void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView) void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView) void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView) void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView) void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView) void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer) void ( STDMETHODCALLTYPE *IASetIndexBuffer )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers) void ( STDMETHODCALLTYPE *IASetVertexBuffers )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT StartSlot, _In_ UINT NumViews, _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets) void ( STDMETHODCALLTYPE *SOSetTargets )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT StartSlot, _In_ UINT NumViews, _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets) void ( STDMETHODCALLTYPE *OMSetRenderTargets )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT NumRenderTargetDescriptors, _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, _In_ BOOL RTsSingleHandleToDescriptorRange, @@ -27232,7 +35086,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView) void ( STDMETHODCALLTYPE *ClearDepthStencilView )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, _In_ D3D12_CLEAR_FLAGS ClearFlags, _In_ FLOAT Depth, @@ -27242,7 +35096,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView) void ( STDMETHODCALLTYPE *ClearRenderTargetView )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, _In_ const FLOAT ColorRGBA[ 4 ], _In_ UINT NumRects, @@ -27250,7 +35104,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint) void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, _In_ ID3D12Resource *pResource, @@ -27260,7 +35114,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat) void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, _In_ ID3D12Resource *pResource, @@ -27270,27 +35124,27 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource) void ( STDMETHODCALLTYPE *DiscardResource )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12Resource *pResource, _In_opt_ const D3D12_DISCARD_REGION *pRegion); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery) void ( STDMETHODCALLTYPE *BeginQuery )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12QueryHeap *pQueryHeap, _In_ D3D12_QUERY_TYPE Type, _In_ UINT Index); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery) void ( STDMETHODCALLTYPE *EndQuery )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12QueryHeap *pQueryHeap, _In_ D3D12_QUERY_TYPE Type, _In_ UINT Index); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData) void ( STDMETHODCALLTYPE *ResolveQueryData )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12QueryHeap *pQueryHeap, _In_ D3D12_QUERY_TYPE Type, _In_ UINT StartIndex, @@ -27300,32 +35154,32 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication) void ( STDMETHODCALLTYPE *SetPredication )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_opt_ ID3D12Resource *pBuffer, _In_ UINT64 AlignedBufferOffset, _In_ D3D12_PREDICATION_OP Operation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker) void ( STDMETHODCALLTYPE *SetMarker )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, UINT Metadata, _In_reads_bytes_opt_(Size) const void *pData, UINT Size); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent) void ( STDMETHODCALLTYPE *BeginEvent )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, UINT Metadata, _In_reads_bytes_opt_(Size) const void *pData, UINT Size); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent) void ( STDMETHODCALLTYPE *EndEvent )( - ID3D12GraphicsCommandList7 * This); + ID3D12GraphicsCommandList9 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect) void ( STDMETHODCALLTYPE *ExecuteIndirect )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12CommandSignature *pCommandSignature, _In_ UINT MaxCommandCount, _In_ ID3D12Resource *pArgumentBuffer, @@ -27335,7 +35189,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT) void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12Resource *pDstBuffer, UINT64 DstOffset, _In_ ID3D12Resource *pSrcBuffer, @@ -27346,7 +35200,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64) void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12Resource *pDstBuffer, UINT64 DstOffset, _In_ ID3D12Resource *pSrcBuffer, @@ -27357,20 +35211,20 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds) void ( STDMETHODCALLTYPE *OMSetDepthBounds )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ FLOAT Min, _In_ FLOAT Max); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions) void ( STDMETHODCALLTYPE *SetSamplePositions )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT NumSamplesPerPixel, _In_ UINT NumPixels, _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion) void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12Resource *pDstResource, _In_ UINT DstSubresource, _In_ UINT DstX, @@ -27383,24 +35237,24 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask) void ( STDMETHODCALLTYPE *SetViewInstanceMask )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT Mask); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate) void ( STDMETHODCALLTYPE *WriteBufferImmediate )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, UINT Count, _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession) void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BeginRenderPass) void ( STDMETHODCALLTYPE *BeginRenderPass )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT NumRenderTargets, _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, @@ -27408,83 +35262,101 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EndRenderPass) void ( STDMETHODCALLTYPE *EndRenderPass )( - ID3D12GraphicsCommandList7 * This); + ID3D12GraphicsCommandList9 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, InitializeMetaCommand) void ( STDMETHODCALLTYPE *InitializeMetaCommand )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12MetaCommand *pMetaCommand, _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, _In_ SIZE_T InitializationParametersDataSizeInBytes); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, ExecuteMetaCommand) void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12MetaCommand *pMetaCommand, _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, _In_ SIZE_T ExecutionParametersDataSizeInBytes); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BuildRaytracingAccelerationStructure) void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, _In_ UINT NumPostbuildInfoDescs, _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EmitRaytracingAccelerationStructurePostbuildInfo) void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, _In_ UINT NumSourceAccelerationStructures, _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, CopyRaytracingAccelerationStructure) void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, SetPipelineState1) void ( STDMETHODCALLTYPE *SetPipelineState1 )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ ID3D12StateObject *pStateObject); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, DispatchRays) void ( STDMETHODCALLTYPE *DispatchRays )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRate) void ( STDMETHODCALLTYPE *RSSetShadingRate )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ D3D12_SHADING_RATE baseShadingRate, _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT) const D3D12_SHADING_RATE_COMBINER *combiners); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRateImage) void ( STDMETHODCALLTYPE *RSSetShadingRateImage )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_opt_ ID3D12Resource *shadingRateImage); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList6, DispatchMesh) void ( STDMETHODCALLTYPE *DispatchMesh )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, _In_ UINT ThreadGroupCountX, _In_ UINT ThreadGroupCountY, _In_ UINT ThreadGroupCountZ); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList7, Barrier) void ( STDMETHODCALLTYPE *Barrier )( - ID3D12GraphicsCommandList7 * This, + ID3D12GraphicsCommandList9 * This, UINT32 NumBarrierGroups, _In_reads_(NumBarrierGroups) const D3D12_BARRIER_GROUP *pBarrierGroups); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList8, OMSetFrontAndBackStencilRef) + void ( STDMETHODCALLTYPE *OMSetFrontAndBackStencilRef )( + ID3D12GraphicsCommandList9 * This, + _In_ UINT FrontStencilRef, + _In_ UINT BackStencilRef); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList9, RSSetDepthBias) + void ( STDMETHODCALLTYPE *RSSetDepthBias )( + ID3D12GraphicsCommandList9 * This, + _In_ FLOAT DepthBias, + _In_ FLOAT DepthBiasClamp, + _In_ FLOAT SlopeScaledDepthBias); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList9, IASetIndexBufferStripCutValue) + void ( STDMETHODCALLTYPE *IASetIndexBufferStripCutValue )( + ID3D12GraphicsCommandList9 * This, + _In_ D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue); + END_INTERFACE - } ID3D12GraphicsCommandList7Vtbl; + } ID3D12GraphicsCommandList9Vtbl; - interface ID3D12GraphicsCommandList7 + interface ID3D12GraphicsCommandList9 { - CONST_VTBL struct ID3D12GraphicsCommandList7Vtbl *lpVtbl; + CONST_VTBL struct ID3D12GraphicsCommandList9Vtbl *lpVtbl; }; @@ -27492,260 +35364,271 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; #ifdef COBJMACROS -#define ID3D12GraphicsCommandList7_QueryInterface(This,riid,ppvObject) \ +#define ID3D12GraphicsCommandList9_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12GraphicsCommandList7_AddRef(This) \ +#define ID3D12GraphicsCommandList9_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12GraphicsCommandList7_Release(This) \ +#define ID3D12GraphicsCommandList9_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12GraphicsCommandList7_GetPrivateData(This,guid,pDataSize,pData) \ +#define ID3D12GraphicsCommandList9_GetPrivateData(This,guid,pDataSize,pData) \ ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12GraphicsCommandList7_SetPrivateData(This,guid,DataSize,pData) \ +#define ID3D12GraphicsCommandList9_SetPrivateData(This,guid,DataSize,pData) \ ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12GraphicsCommandList7_SetPrivateDataInterface(This,guid,pData) \ +#define ID3D12GraphicsCommandList9_SetPrivateDataInterface(This,guid,pData) \ ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12GraphicsCommandList7_SetName(This,Name) \ +#define ID3D12GraphicsCommandList9_SetName(This,Name) \ ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12GraphicsCommandList7_GetDevice(This,riid,ppvDevice) \ +#define ID3D12GraphicsCommandList9_GetDevice(This,riid,ppvDevice) \ ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) -#define ID3D12GraphicsCommandList7_GetType(This) \ +#define ID3D12GraphicsCommandList9_GetType(This) \ ( (This)->lpVtbl -> GetType(This) ) -#define ID3D12GraphicsCommandList7_Close(This) \ +#define ID3D12GraphicsCommandList9_Close(This) \ ( (This)->lpVtbl -> Close(This) ) -#define ID3D12GraphicsCommandList7_Reset(This,pAllocator,pInitialState) \ +#define ID3D12GraphicsCommandList9_Reset(This,pAllocator,pInitialState) \ ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) -#define ID3D12GraphicsCommandList7_ClearState(This,pPipelineState) \ +#define ID3D12GraphicsCommandList9_ClearState(This,pPipelineState) \ ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) -#define ID3D12GraphicsCommandList7_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ +#define ID3D12GraphicsCommandList9_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) -#define ID3D12GraphicsCommandList7_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ +#define ID3D12GraphicsCommandList9_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) -#define ID3D12GraphicsCommandList7_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ +#define ID3D12GraphicsCommandList9_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) -#define ID3D12GraphicsCommandList7_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ +#define ID3D12GraphicsCommandList9_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) -#define ID3D12GraphicsCommandList7_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ +#define ID3D12GraphicsCommandList9_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) -#define ID3D12GraphicsCommandList7_CopyResource(This,pDstResource,pSrcResource) \ +#define ID3D12GraphicsCommandList9_CopyResource(This,pDstResource,pSrcResource) \ ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) -#define ID3D12GraphicsCommandList7_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ +#define ID3D12GraphicsCommandList9_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) -#define ID3D12GraphicsCommandList7_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ +#define ID3D12GraphicsCommandList9_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) -#define ID3D12GraphicsCommandList7_IASetPrimitiveTopology(This,PrimitiveTopology) \ +#define ID3D12GraphicsCommandList9_IASetPrimitiveTopology(This,PrimitiveTopology) \ ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) -#define ID3D12GraphicsCommandList7_RSSetViewports(This,NumViewports,pViewports) \ +#define ID3D12GraphicsCommandList9_RSSetViewports(This,NumViewports,pViewports) \ ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) -#define ID3D12GraphicsCommandList7_RSSetScissorRects(This,NumRects,pRects) \ +#define ID3D12GraphicsCommandList9_RSSetScissorRects(This,NumRects,pRects) \ ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) -#define ID3D12GraphicsCommandList7_OMSetBlendFactor(This,BlendFactor) \ +#define ID3D12GraphicsCommandList9_OMSetBlendFactor(This,BlendFactor) \ ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) -#define ID3D12GraphicsCommandList7_OMSetStencilRef(This,StencilRef) \ +#define ID3D12GraphicsCommandList9_OMSetStencilRef(This,StencilRef) \ ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) -#define ID3D12GraphicsCommandList7_SetPipelineState(This,pPipelineState) \ +#define ID3D12GraphicsCommandList9_SetPipelineState(This,pPipelineState) \ ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) -#define ID3D12GraphicsCommandList7_ResourceBarrier(This,NumBarriers,pBarriers) \ +#define ID3D12GraphicsCommandList9_ResourceBarrier(This,NumBarriers,pBarriers) \ ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) -#define ID3D12GraphicsCommandList7_ExecuteBundle(This,pCommandList) \ +#define ID3D12GraphicsCommandList9_ExecuteBundle(This,pCommandList) \ ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) -#define ID3D12GraphicsCommandList7_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ +#define ID3D12GraphicsCommandList9_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) -#define ID3D12GraphicsCommandList7_SetComputeRootSignature(This,pRootSignature) \ +#define ID3D12GraphicsCommandList9_SetComputeRootSignature(This,pRootSignature) \ ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) -#define ID3D12GraphicsCommandList7_SetGraphicsRootSignature(This,pRootSignature) \ +#define ID3D12GraphicsCommandList9_SetGraphicsRootSignature(This,pRootSignature) \ ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) -#define ID3D12GraphicsCommandList7_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ +#define ID3D12GraphicsCommandList9_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12GraphicsCommandList7_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ +#define ID3D12GraphicsCommandList9_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12GraphicsCommandList7_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList9_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList7_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList9_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList7_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList9_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList7_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList9_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList7_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList9_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList7_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList9_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList7_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList9_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList7_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList9_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList7_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList9_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList7_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList9_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList7_IASetIndexBuffer(This,pView) \ +#define ID3D12GraphicsCommandList9_IASetIndexBuffer(This,pView) \ ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) -#define ID3D12GraphicsCommandList7_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ +#define ID3D12GraphicsCommandList9_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) -#define ID3D12GraphicsCommandList7_SOSetTargets(This,StartSlot,NumViews,pViews) \ +#define ID3D12GraphicsCommandList9_SOSetTargets(This,StartSlot,NumViews,pViews) \ ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) -#define ID3D12GraphicsCommandList7_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ +#define ID3D12GraphicsCommandList9_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) -#define ID3D12GraphicsCommandList7_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ +#define ID3D12GraphicsCommandList9_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) -#define ID3D12GraphicsCommandList7_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ +#define ID3D12GraphicsCommandList9_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) -#define ID3D12GraphicsCommandList7_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ +#define ID3D12GraphicsCommandList9_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) -#define ID3D12GraphicsCommandList7_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ +#define ID3D12GraphicsCommandList9_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) -#define ID3D12GraphicsCommandList7_DiscardResource(This,pResource,pRegion) \ +#define ID3D12GraphicsCommandList9_DiscardResource(This,pResource,pRegion) \ ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) -#define ID3D12GraphicsCommandList7_BeginQuery(This,pQueryHeap,Type,Index) \ +#define ID3D12GraphicsCommandList9_BeginQuery(This,pQueryHeap,Type,Index) \ ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) -#define ID3D12GraphicsCommandList7_EndQuery(This,pQueryHeap,Type,Index) \ +#define ID3D12GraphicsCommandList9_EndQuery(This,pQueryHeap,Type,Index) \ ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) -#define ID3D12GraphicsCommandList7_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ +#define ID3D12GraphicsCommandList9_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) -#define ID3D12GraphicsCommandList7_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ +#define ID3D12GraphicsCommandList9_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) -#define ID3D12GraphicsCommandList7_SetMarker(This,Metadata,pData,Size) \ +#define ID3D12GraphicsCommandList9_SetMarker(This,Metadata,pData,Size) \ ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) -#define ID3D12GraphicsCommandList7_BeginEvent(This,Metadata,pData,Size) \ +#define ID3D12GraphicsCommandList9_BeginEvent(This,Metadata,pData,Size) \ ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) -#define ID3D12GraphicsCommandList7_EndEvent(This) \ +#define ID3D12GraphicsCommandList9_EndEvent(This) \ ( (This)->lpVtbl -> EndEvent(This) ) -#define ID3D12GraphicsCommandList7_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ +#define ID3D12GraphicsCommandList9_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) -#define ID3D12GraphicsCommandList7_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ +#define ID3D12GraphicsCommandList9_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -#define ID3D12GraphicsCommandList7_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ +#define ID3D12GraphicsCommandList9_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -#define ID3D12GraphicsCommandList7_OMSetDepthBounds(This,Min,Max) \ +#define ID3D12GraphicsCommandList9_OMSetDepthBounds(This,Min,Max) \ ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) -#define ID3D12GraphicsCommandList7_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ +#define ID3D12GraphicsCommandList9_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) -#define ID3D12GraphicsCommandList7_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ +#define ID3D12GraphicsCommandList9_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) -#define ID3D12GraphicsCommandList7_SetViewInstanceMask(This,Mask) \ +#define ID3D12GraphicsCommandList9_SetViewInstanceMask(This,Mask) \ ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) -#define ID3D12GraphicsCommandList7_WriteBufferImmediate(This,Count,pParams,pModes) \ +#define ID3D12GraphicsCommandList9_WriteBufferImmediate(This,Count,pParams,pModes) \ ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) -#define ID3D12GraphicsCommandList7_SetProtectedResourceSession(This,pProtectedResourceSession) \ +#define ID3D12GraphicsCommandList9_SetProtectedResourceSession(This,pProtectedResourceSession) \ ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) -#define ID3D12GraphicsCommandList7_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ +#define ID3D12GraphicsCommandList9_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) -#define ID3D12GraphicsCommandList7_EndRenderPass(This) \ +#define ID3D12GraphicsCommandList9_EndRenderPass(This) \ ( (This)->lpVtbl -> EndRenderPass(This) ) -#define ID3D12GraphicsCommandList7_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ +#define ID3D12GraphicsCommandList9_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) -#define ID3D12GraphicsCommandList7_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ +#define ID3D12GraphicsCommandList9_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) -#define ID3D12GraphicsCommandList7_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ +#define ID3D12GraphicsCommandList9_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) -#define ID3D12GraphicsCommandList7_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ +#define ID3D12GraphicsCommandList9_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) -#define ID3D12GraphicsCommandList7_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ +#define ID3D12GraphicsCommandList9_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) -#define ID3D12GraphicsCommandList7_SetPipelineState1(This,pStateObject) \ +#define ID3D12GraphicsCommandList9_SetPipelineState1(This,pStateObject) \ ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) -#define ID3D12GraphicsCommandList7_DispatchRays(This,pDesc) \ +#define ID3D12GraphicsCommandList9_DispatchRays(This,pDesc) \ ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) -#define ID3D12GraphicsCommandList7_RSSetShadingRate(This,baseShadingRate,combiners) \ +#define ID3D12GraphicsCommandList9_RSSetShadingRate(This,baseShadingRate,combiners) \ ( (This)->lpVtbl -> RSSetShadingRate(This,baseShadingRate,combiners) ) -#define ID3D12GraphicsCommandList7_RSSetShadingRateImage(This,shadingRateImage) \ +#define ID3D12GraphicsCommandList9_RSSetShadingRateImage(This,shadingRateImage) \ ( (This)->lpVtbl -> RSSetShadingRateImage(This,shadingRateImage) ) -#define ID3D12GraphicsCommandList7_DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ +#define ID3D12GraphicsCommandList9_DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ ( (This)->lpVtbl -> DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) -#define ID3D12GraphicsCommandList7_Barrier(This,NumBarrierGroups,pBarrierGroups) \ +#define ID3D12GraphicsCommandList9_Barrier(This,NumBarrierGroups,pBarrierGroups) \ ( (This)->lpVtbl -> Barrier(This,NumBarrierGroups,pBarrierGroups) ) + +#define ID3D12GraphicsCommandList9_OMSetFrontAndBackStencilRef(This,FrontStencilRef,BackStencilRef) \ + ( (This)->lpVtbl -> OMSetFrontAndBackStencilRef(This,FrontStencilRef,BackStencilRef) ) + + +#define ID3D12GraphicsCommandList9_RSSetDepthBias(This,DepthBias,DepthBiasClamp,SlopeScaledDepthBias) \ + ( (This)->lpVtbl -> RSSetDepthBias(This,DepthBias,DepthBiasClamp,SlopeScaledDepthBias) ) + +#define ID3D12GraphicsCommandList9_IASetIndexBufferStripCutValue(This,IBStripCutValue) \ + ( (This)->lpVtbl -> IASetIndexBufferStripCutValue(This,IBStripCutValue) ) + #endif /* COBJMACROS */ @@ -27754,104 +35637,106 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList7; -#endif /* __ID3D12GraphicsCommandList7_INTERFACE_DEFINED__ */ +#endif /* __ID3D12GraphicsCommandList9_INTERFACE_DEFINED__ */ -#ifndef __ID3D12GraphicsCommandList8_INTERFACE_DEFINED__ -#define __ID3D12GraphicsCommandList8_INTERFACE_DEFINED__ +#ifndef __ID3D12GraphicsCommandList10_INTERFACE_DEFINED__ +#define __ID3D12GraphicsCommandList10_INTERFACE_DEFINED__ -/* interface ID3D12GraphicsCommandList8 */ +/* interface ID3D12GraphicsCommandList10 */ /* [unique][local][object][uuid] */ -EXTERN_C const IID IID_ID3D12GraphicsCommandList8; +EXTERN_C const IID IID_ID3D12GraphicsCommandList10; #if defined(__cplusplus) && !defined(CINTERFACE) - MIDL_INTERFACE("ee936ef9-599d-4d28-938e-23c4ad05ce51") - ID3D12GraphicsCommandList8 : public ID3D12GraphicsCommandList7 + MIDL_INTERFACE("7013c015-d161-4b63-a08c-238552dd8acc") + ID3D12GraphicsCommandList10 : public ID3D12GraphicsCommandList9 { public: - virtual void STDMETHODCALLTYPE OMSetFrontAndBackStencilRef( - _In_ UINT FrontStencilRef, - _In_ UINT BackStencilRef) = 0; + virtual void STDMETHODCALLTYPE SetProgram( + _In_ const D3D12_SET_PROGRAM_DESC *pDesc) = 0; + + virtual void STDMETHODCALLTYPE DispatchGraph( + _In_ const D3D12_DISPATCH_GRAPH_DESC *pDesc) = 0; }; #else /* C style interface */ - typedef struct ID3D12GraphicsCommandList8Vtbl + typedef struct ID3D12GraphicsCommandList10Vtbl { BEGIN_INTERFACE DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, REFIID riid, _COM_Outptr_ void **ppvObject); DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( - ID3D12GraphicsCommandList8 * This); + ID3D12GraphicsCommandList10 * This); DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( - ID3D12GraphicsCommandList8 * This); + ID3D12GraphicsCommandList10 * This); DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ REFGUID guid, _Inout_ UINT *pDataSize, _Out_writes_bytes_opt_( *pDataSize ) void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_( DataSize ) const void *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ REFGUID guid, _In_opt_ const IUnknown *pData); DECLSPEC_XFGVIRT(ID3D12Object, SetName) HRESULT ( STDMETHODCALLTYPE *SetName )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_z_ LPCWSTR Name); DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, REFIID riid, _COM_Outptr_opt_ void **ppvDevice); DECLSPEC_XFGVIRT(ID3D12CommandList, GetType) D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( - ID3D12GraphicsCommandList8 * This); + ID3D12GraphicsCommandList10 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Close) HRESULT ( STDMETHODCALLTYPE *Close )( - ID3D12GraphicsCommandList8 * This); + ID3D12GraphicsCommandList10 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Reset) HRESULT ( STDMETHODCALLTYPE *Reset )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12CommandAllocator *pAllocator, _In_opt_ ID3D12PipelineState *pInitialState); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearState) void ( STDMETHODCALLTYPE *ClearState )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_opt_ ID3D12PipelineState *pPipelineState); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawInstanced) void ( STDMETHODCALLTYPE *DrawInstanced )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT VertexCountPerInstance, _In_ UINT InstanceCount, _In_ UINT StartVertexLocation, @@ -27859,7 +35744,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DrawIndexedInstanced) void ( STDMETHODCALLTYPE *DrawIndexedInstanced )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT IndexCountPerInstance, _In_ UINT InstanceCount, _In_ UINT StartIndexLocation, @@ -27868,14 +35753,14 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, Dispatch) void ( STDMETHODCALLTYPE *Dispatch )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT ThreadGroupCountX, _In_ UINT ThreadGroupCountY, _In_ UINT ThreadGroupCountZ); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyBufferRegion) void ( STDMETHODCALLTYPE *CopyBufferRegion )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12Resource *pDstBuffer, UINT64 DstOffset, _In_ ID3D12Resource *pSrcBuffer, @@ -27884,7 +35769,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTextureRegion) void ( STDMETHODCALLTYPE *CopyTextureRegion )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ const D3D12_TEXTURE_COPY_LOCATION *pDst, UINT DstX, UINT DstY, @@ -27894,13 +35779,13 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyResource) void ( STDMETHODCALLTYPE *CopyResource )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12Resource *pDstResource, _In_ ID3D12Resource *pSrcResource); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, CopyTiles) void ( STDMETHODCALLTYPE *CopyTiles )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12Resource *pTiledResource, _In_ const D3D12_TILED_RESOURCE_COORDINATE *pTileRegionStartCoordinate, _In_ const D3D12_TILE_REGION_SIZE *pTileRegionSize, @@ -27910,7 +35795,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveSubresource) void ( STDMETHODCALLTYPE *ResolveSubresource )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12Resource *pDstResource, _In_ UINT DstSubresource, _In_ ID3D12Resource *pSrcResource, @@ -27919,92 +35804,92 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetPrimitiveTopology) void ( STDMETHODCALLTYPE *IASetPrimitiveTopology )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetViewports) void ( STDMETHODCALLTYPE *RSSetViewports )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumViewports, _In_reads_( NumViewports) const D3D12_VIEWPORT *pViewports); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, RSSetScissorRects) void ( STDMETHODCALLTYPE *RSSetScissorRects )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_range_(0, D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) UINT NumRects, _In_reads_( NumRects) const D3D12_RECT *pRects); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetBlendFactor) void ( STDMETHODCALLTYPE *OMSetBlendFactor )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_reads_opt_(4) const FLOAT BlendFactor[ 4 ]); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetStencilRef) void ( STDMETHODCALLTYPE *OMSetStencilRef )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT StencilRef); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPipelineState) void ( STDMETHODCALLTYPE *SetPipelineState )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12PipelineState *pPipelineState); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResourceBarrier) void ( STDMETHODCALLTYPE *ResourceBarrier )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT NumBarriers, _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteBundle) void ( STDMETHODCALLTYPE *ExecuteBundle )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12GraphicsCommandList *pCommandList); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetDescriptorHeaps) void ( STDMETHODCALLTYPE *SetDescriptorHeaps )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT NumDescriptorHeaps, _In_reads_(NumDescriptorHeaps) ID3D12DescriptorHeap *const *ppDescriptorHeaps); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootSignature) void ( STDMETHODCALLTYPE *SetComputeRootSignature )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_opt_ ID3D12RootSignature *pRootSignature); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootSignature) void ( STDMETHODCALLTYPE *SetGraphicsRootSignature )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_opt_ ID3D12RootSignature *pRootSignature); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootDescriptorTable) void ( STDMETHODCALLTYPE *SetComputeRootDescriptorTable )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootDescriptorTable) void ( STDMETHODCALLTYPE *SetGraphicsRootDescriptorTable )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstant) void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstant )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT RootParameterIndex, _In_ UINT SrcData, _In_ UINT DestOffsetIn32BitValues); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstant) void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstant )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT RootParameterIndex, _In_ UINT SrcData, _In_ UINT DestOffsetIn32BitValues); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRoot32BitConstants) void ( STDMETHODCALLTYPE *SetComputeRoot32BitConstants )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT RootParameterIndex, _In_ UINT Num32BitValuesToSet, _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, @@ -28012,7 +35897,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRoot32BitConstants) void ( STDMETHODCALLTYPE *SetGraphicsRoot32BitConstants )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT RootParameterIndex, _In_ UINT Num32BitValuesToSet, _In_reads_(Num32BitValuesToSet*sizeof(UINT)) const void *pSrcData, @@ -28020,62 +35905,62 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootConstantBufferView) void ( STDMETHODCALLTYPE *SetComputeRootConstantBufferView )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootConstantBufferView) void ( STDMETHODCALLTYPE *SetGraphicsRootConstantBufferView )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootShaderResourceView) void ( STDMETHODCALLTYPE *SetComputeRootShaderResourceView )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootShaderResourceView) void ( STDMETHODCALLTYPE *SetGraphicsRootShaderResourceView )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetComputeRootUnorderedAccessView) void ( STDMETHODCALLTYPE *SetComputeRootUnorderedAccessView )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetGraphicsRootUnorderedAccessView) void ( STDMETHODCALLTYPE *SetGraphicsRootUnorderedAccessView )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT RootParameterIndex, _In_ D3D12_GPU_VIRTUAL_ADDRESS BufferLocation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetIndexBuffer) void ( STDMETHODCALLTYPE *IASetIndexBuffer )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_opt_ const D3D12_INDEX_BUFFER_VIEW *pView); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, IASetVertexBuffers) void ( STDMETHODCALLTYPE *IASetVertexBuffers )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT StartSlot, _In_ UINT NumViews, _In_reads_opt_(NumViews) const D3D12_VERTEX_BUFFER_VIEW *pViews); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SOSetTargets) void ( STDMETHODCALLTYPE *SOSetTargets )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT StartSlot, _In_ UINT NumViews, _In_reads_opt_(NumViews) const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, OMSetRenderTargets) void ( STDMETHODCALLTYPE *OMSetRenderTargets )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT NumRenderTargetDescriptors, _In_opt_ const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors, _In_ BOOL RTsSingleHandleToDescriptorRange, @@ -28083,7 +35968,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearDepthStencilView) void ( STDMETHODCALLTYPE *ClearDepthStencilView )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, _In_ D3D12_CLEAR_FLAGS ClearFlags, _In_ FLOAT Depth, @@ -28093,7 +35978,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearRenderTargetView) void ( STDMETHODCALLTYPE *ClearRenderTargetView )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, _In_ const FLOAT ColorRGBA[ 4 ], _In_ UINT NumRects, @@ -28101,7 +35986,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewUint) void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewUint )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, _In_ ID3D12Resource *pResource, @@ -28111,7 +35996,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ClearUnorderedAccessViewFloat) void ( STDMETHODCALLTYPE *ClearUnorderedAccessViewFloat )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, _In_ D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle, _In_ ID3D12Resource *pResource, @@ -28121,27 +36006,27 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, DiscardResource) void ( STDMETHODCALLTYPE *DiscardResource )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12Resource *pResource, _In_opt_ const D3D12_DISCARD_REGION *pRegion); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginQuery) void ( STDMETHODCALLTYPE *BeginQuery )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12QueryHeap *pQueryHeap, _In_ D3D12_QUERY_TYPE Type, _In_ UINT Index); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndQuery) void ( STDMETHODCALLTYPE *EndQuery )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12QueryHeap *pQueryHeap, _In_ D3D12_QUERY_TYPE Type, _In_ UINT Index); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ResolveQueryData) void ( STDMETHODCALLTYPE *ResolveQueryData )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12QueryHeap *pQueryHeap, _In_ D3D12_QUERY_TYPE Type, _In_ UINT StartIndex, @@ -28151,32 +36036,32 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetPredication) void ( STDMETHODCALLTYPE *SetPredication )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_opt_ ID3D12Resource *pBuffer, _In_ UINT64 AlignedBufferOffset, _In_ D3D12_PREDICATION_OP Operation); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, SetMarker) void ( STDMETHODCALLTYPE *SetMarker )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, UINT Metadata, _In_reads_bytes_opt_(Size) const void *pData, UINT Size); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, BeginEvent) void ( STDMETHODCALLTYPE *BeginEvent )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, UINT Metadata, _In_reads_bytes_opt_(Size) const void *pData, UINT Size); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, EndEvent) void ( STDMETHODCALLTYPE *EndEvent )( - ID3D12GraphicsCommandList8 * This); + ID3D12GraphicsCommandList10 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList, ExecuteIndirect) void ( STDMETHODCALLTYPE *ExecuteIndirect )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12CommandSignature *pCommandSignature, _In_ UINT MaxCommandCount, _In_ ID3D12Resource *pArgumentBuffer, @@ -28186,7 +36071,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT) void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12Resource *pDstBuffer, UINT64 DstOffset, _In_ ID3D12Resource *pSrcBuffer, @@ -28197,7 +36082,7 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, AtomicCopyBufferUINT64) void ( STDMETHODCALLTYPE *AtomicCopyBufferUINT64 )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12Resource *pDstBuffer, UINT64 DstOffset, _In_ ID3D12Resource *pSrcBuffer, @@ -28208,20 +36093,20 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, OMSetDepthBounds) void ( STDMETHODCALLTYPE *OMSetDepthBounds )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ FLOAT Min, _In_ FLOAT Max); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetSamplePositions) void ( STDMETHODCALLTYPE *SetSamplePositions )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT NumSamplesPerPixel, _In_ UINT NumPixels, _In_reads_(NumSamplesPerPixel*NumPixels) D3D12_SAMPLE_POSITION *pSamplePositions); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, ResolveSubresourceRegion) void ( STDMETHODCALLTYPE *ResolveSubresourceRegion )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12Resource *pDstResource, _In_ UINT DstSubresource, _In_ UINT DstX, @@ -28234,24 +36119,24 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList1, SetViewInstanceMask) void ( STDMETHODCALLTYPE *SetViewInstanceMask )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT Mask); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList2, WriteBufferImmediate) void ( STDMETHODCALLTYPE *WriteBufferImmediate )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, UINT Count, _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList3, SetProtectedResourceSession) void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BeginRenderPass) void ( STDMETHODCALLTYPE *BeginRenderPass )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT NumRenderTargets, _In_reads_opt_(NumRenderTargets) const D3D12_RENDER_PASS_RENDER_TARGET_DESC *pRenderTargets, _In_opt_ const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *pDepthStencil, @@ -28259,89 +36144,111 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EndRenderPass) void ( STDMETHODCALLTYPE *EndRenderPass )( - ID3D12GraphicsCommandList8 * This); + ID3D12GraphicsCommandList10 * This); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, InitializeMetaCommand) void ( STDMETHODCALLTYPE *InitializeMetaCommand )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12MetaCommand *pMetaCommand, _In_reads_bytes_opt_(InitializationParametersDataSizeInBytes) const void *pInitializationParametersData, _In_ SIZE_T InitializationParametersDataSizeInBytes); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, ExecuteMetaCommand) void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12MetaCommand *pMetaCommand, _In_reads_bytes_opt_(ExecutionParametersDataSizeInBytes) const void *pExecutionParametersData, _In_ SIZE_T ExecutionParametersDataSizeInBytes); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, BuildRaytracingAccelerationStructure) void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc, _In_ UINT NumPostbuildInfoDescs, _In_reads_opt_(NumPostbuildInfoDescs) const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pPostbuildInfoDescs); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, EmitRaytracingAccelerationStructurePostbuildInfo) void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostbuildInfo )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *pDesc, _In_ UINT NumSourceAccelerationStructures, _In_reads_( NumSourceAccelerationStructures ) const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, CopyRaytracingAccelerationStructure) void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData, _In_ D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData, _In_ D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, SetPipelineState1) void ( STDMETHODCALLTYPE *SetPipelineState1 )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ ID3D12StateObject *pStateObject); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList4, DispatchRays) void ( STDMETHODCALLTYPE *DispatchRays )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ const D3D12_DISPATCH_RAYS_DESC *pDesc); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRate) void ( STDMETHODCALLTYPE *RSSetShadingRate )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ D3D12_SHADING_RATE baseShadingRate, _In_reads_opt_(D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT) const D3D12_SHADING_RATE_COMBINER *combiners); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList5, RSSetShadingRateImage) void ( STDMETHODCALLTYPE *RSSetShadingRateImage )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_opt_ ID3D12Resource *shadingRateImage); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList6, DispatchMesh) void ( STDMETHODCALLTYPE *DispatchMesh )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT ThreadGroupCountX, _In_ UINT ThreadGroupCountY, _In_ UINT ThreadGroupCountZ); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList7, Barrier) void ( STDMETHODCALLTYPE *Barrier )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, UINT32 NumBarrierGroups, _In_reads_(NumBarrierGroups) const D3D12_BARRIER_GROUP *pBarrierGroups); DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList8, OMSetFrontAndBackStencilRef) void ( STDMETHODCALLTYPE *OMSetFrontAndBackStencilRef )( - ID3D12GraphicsCommandList8 * This, + ID3D12GraphicsCommandList10 * This, _In_ UINT FrontStencilRef, _In_ UINT BackStencilRef); + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList9, RSSetDepthBias) + void ( STDMETHODCALLTYPE *RSSetDepthBias )( + ID3D12GraphicsCommandList10 * This, + _In_ FLOAT DepthBias, + _In_ FLOAT DepthBiasClamp, + _In_ FLOAT SlopeScaledDepthBias); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList9, IASetIndexBufferStripCutValue) + void ( STDMETHODCALLTYPE *IASetIndexBufferStripCutValue )( + ID3D12GraphicsCommandList10 * This, + _In_ D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList10, SetProgram) + void ( STDMETHODCALLTYPE *SetProgram )( + ID3D12GraphicsCommandList10 * This, + _In_ const D3D12_SET_PROGRAM_DESC *pDesc); + + DECLSPEC_XFGVIRT(ID3D12GraphicsCommandList10, DispatchGraph) + void ( STDMETHODCALLTYPE *DispatchGraph )( + ID3D12GraphicsCommandList10 * This, + _In_ const D3D12_DISPATCH_GRAPH_DESC *pDesc); + END_INTERFACE - } ID3D12GraphicsCommandList8Vtbl; + } ID3D12GraphicsCommandList10Vtbl; - interface ID3D12GraphicsCommandList8 + interface ID3D12GraphicsCommandList10 { - CONST_VTBL struct ID3D12GraphicsCommandList8Vtbl *lpVtbl; + CONST_VTBL struct ID3D12GraphicsCommandList10Vtbl *lpVtbl; }; @@ -28349,264 +36256,278 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; #ifdef COBJMACROS -#define ID3D12GraphicsCommandList8_QueryInterface(This,riid,ppvObject) \ +#define ID3D12GraphicsCommandList10_QueryInterface(This,riid,ppvObject) \ ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) -#define ID3D12GraphicsCommandList8_AddRef(This) \ +#define ID3D12GraphicsCommandList10_AddRef(This) \ ( (This)->lpVtbl -> AddRef(This) ) -#define ID3D12GraphicsCommandList8_Release(This) \ +#define ID3D12GraphicsCommandList10_Release(This) \ ( (This)->lpVtbl -> Release(This) ) -#define ID3D12GraphicsCommandList8_GetPrivateData(This,guid,pDataSize,pData) \ +#define ID3D12GraphicsCommandList10_GetPrivateData(This,guid,pDataSize,pData) \ ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) -#define ID3D12GraphicsCommandList8_SetPrivateData(This,guid,DataSize,pData) \ +#define ID3D12GraphicsCommandList10_SetPrivateData(This,guid,DataSize,pData) \ ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) -#define ID3D12GraphicsCommandList8_SetPrivateDataInterface(This,guid,pData) \ +#define ID3D12GraphicsCommandList10_SetPrivateDataInterface(This,guid,pData) \ ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) -#define ID3D12GraphicsCommandList8_SetName(This,Name) \ +#define ID3D12GraphicsCommandList10_SetName(This,Name) \ ( (This)->lpVtbl -> SetName(This,Name) ) -#define ID3D12GraphicsCommandList8_GetDevice(This,riid,ppvDevice) \ +#define ID3D12GraphicsCommandList10_GetDevice(This,riid,ppvDevice) \ ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) -#define ID3D12GraphicsCommandList8_GetType(This) \ +#define ID3D12GraphicsCommandList10_GetType(This) \ ( (This)->lpVtbl -> GetType(This) ) -#define ID3D12GraphicsCommandList8_Close(This) \ +#define ID3D12GraphicsCommandList10_Close(This) \ ( (This)->lpVtbl -> Close(This) ) -#define ID3D12GraphicsCommandList8_Reset(This,pAllocator,pInitialState) \ +#define ID3D12GraphicsCommandList10_Reset(This,pAllocator,pInitialState) \ ( (This)->lpVtbl -> Reset(This,pAllocator,pInitialState) ) -#define ID3D12GraphicsCommandList8_ClearState(This,pPipelineState) \ +#define ID3D12GraphicsCommandList10_ClearState(This,pPipelineState) \ ( (This)->lpVtbl -> ClearState(This,pPipelineState) ) -#define ID3D12GraphicsCommandList8_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ +#define ID3D12GraphicsCommandList10_DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) \ ( (This)->lpVtbl -> DrawInstanced(This,VertexCountPerInstance,InstanceCount,StartVertexLocation,StartInstanceLocation) ) -#define ID3D12GraphicsCommandList8_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ +#define ID3D12GraphicsCommandList10_DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) \ ( (This)->lpVtbl -> DrawIndexedInstanced(This,IndexCountPerInstance,InstanceCount,StartIndexLocation,BaseVertexLocation,StartInstanceLocation) ) -#define ID3D12GraphicsCommandList8_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ +#define ID3D12GraphicsCommandList10_Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ ( (This)->lpVtbl -> Dispatch(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) -#define ID3D12GraphicsCommandList8_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ +#define ID3D12GraphicsCommandList10_CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) \ ( (This)->lpVtbl -> CopyBufferRegion(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,NumBytes) ) -#define ID3D12GraphicsCommandList8_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ +#define ID3D12GraphicsCommandList10_CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) \ ( (This)->lpVtbl -> CopyTextureRegion(This,pDst,DstX,DstY,DstZ,pSrc,pSrcBox) ) -#define ID3D12GraphicsCommandList8_CopyResource(This,pDstResource,pSrcResource) \ +#define ID3D12GraphicsCommandList10_CopyResource(This,pDstResource,pSrcResource) \ ( (This)->lpVtbl -> CopyResource(This,pDstResource,pSrcResource) ) -#define ID3D12GraphicsCommandList8_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ +#define ID3D12GraphicsCommandList10_CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) \ ( (This)->lpVtbl -> CopyTiles(This,pTiledResource,pTileRegionStartCoordinate,pTileRegionSize,pBuffer,BufferStartOffsetInBytes,Flags) ) -#define ID3D12GraphicsCommandList8_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ +#define ID3D12GraphicsCommandList10_ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) \ ( (This)->lpVtbl -> ResolveSubresource(This,pDstResource,DstSubresource,pSrcResource,SrcSubresource,Format) ) -#define ID3D12GraphicsCommandList8_IASetPrimitiveTopology(This,PrimitiveTopology) \ +#define ID3D12GraphicsCommandList10_IASetPrimitiveTopology(This,PrimitiveTopology) \ ( (This)->lpVtbl -> IASetPrimitiveTopology(This,PrimitiveTopology) ) -#define ID3D12GraphicsCommandList8_RSSetViewports(This,NumViewports,pViewports) \ +#define ID3D12GraphicsCommandList10_RSSetViewports(This,NumViewports,pViewports) \ ( (This)->lpVtbl -> RSSetViewports(This,NumViewports,pViewports) ) -#define ID3D12GraphicsCommandList8_RSSetScissorRects(This,NumRects,pRects) \ +#define ID3D12GraphicsCommandList10_RSSetScissorRects(This,NumRects,pRects) \ ( (This)->lpVtbl -> RSSetScissorRects(This,NumRects,pRects) ) -#define ID3D12GraphicsCommandList8_OMSetBlendFactor(This,BlendFactor) \ +#define ID3D12GraphicsCommandList10_OMSetBlendFactor(This,BlendFactor) \ ( (This)->lpVtbl -> OMSetBlendFactor(This,BlendFactor) ) -#define ID3D12GraphicsCommandList8_OMSetStencilRef(This,StencilRef) \ +#define ID3D12GraphicsCommandList10_OMSetStencilRef(This,StencilRef) \ ( (This)->lpVtbl -> OMSetStencilRef(This,StencilRef) ) -#define ID3D12GraphicsCommandList8_SetPipelineState(This,pPipelineState) \ +#define ID3D12GraphicsCommandList10_SetPipelineState(This,pPipelineState) \ ( (This)->lpVtbl -> SetPipelineState(This,pPipelineState) ) -#define ID3D12GraphicsCommandList8_ResourceBarrier(This,NumBarriers,pBarriers) \ +#define ID3D12GraphicsCommandList10_ResourceBarrier(This,NumBarriers,pBarriers) \ ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) -#define ID3D12GraphicsCommandList8_ExecuteBundle(This,pCommandList) \ +#define ID3D12GraphicsCommandList10_ExecuteBundle(This,pCommandList) \ ( (This)->lpVtbl -> ExecuteBundle(This,pCommandList) ) -#define ID3D12GraphicsCommandList8_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ +#define ID3D12GraphicsCommandList10_SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) \ ( (This)->lpVtbl -> SetDescriptorHeaps(This,NumDescriptorHeaps,ppDescriptorHeaps) ) -#define ID3D12GraphicsCommandList8_SetComputeRootSignature(This,pRootSignature) \ +#define ID3D12GraphicsCommandList10_SetComputeRootSignature(This,pRootSignature) \ ( (This)->lpVtbl -> SetComputeRootSignature(This,pRootSignature) ) -#define ID3D12GraphicsCommandList8_SetGraphicsRootSignature(This,pRootSignature) \ +#define ID3D12GraphicsCommandList10_SetGraphicsRootSignature(This,pRootSignature) \ ( (This)->lpVtbl -> SetGraphicsRootSignature(This,pRootSignature) ) -#define ID3D12GraphicsCommandList8_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ +#define ID3D12GraphicsCommandList10_SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ ( (This)->lpVtbl -> SetComputeRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12GraphicsCommandList8_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ +#define ID3D12GraphicsCommandList10_SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) \ ( (This)->lpVtbl -> SetGraphicsRootDescriptorTable(This,RootParameterIndex,BaseDescriptor) ) -#define ID3D12GraphicsCommandList8_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList10_SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetComputeRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList8_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList10_SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetGraphicsRoot32BitConstant(This,RootParameterIndex,SrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList8_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList10_SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetComputeRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList8_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ +#define ID3D12GraphicsCommandList10_SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) \ ( (This)->lpVtbl -> SetGraphicsRoot32BitConstants(This,RootParameterIndex,Num32BitValuesToSet,pSrcData,DestOffsetIn32BitValues) ) -#define ID3D12GraphicsCommandList8_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList10_SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetComputeRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList8_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList10_SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetGraphicsRootConstantBufferView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList8_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList10_SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetComputeRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList8_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList10_SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetGraphicsRootShaderResourceView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList8_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList10_SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetComputeRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList8_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ +#define ID3D12GraphicsCommandList10_SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) \ ( (This)->lpVtbl -> SetGraphicsRootUnorderedAccessView(This,RootParameterIndex,BufferLocation) ) -#define ID3D12GraphicsCommandList8_IASetIndexBuffer(This,pView) \ +#define ID3D12GraphicsCommandList10_IASetIndexBuffer(This,pView) \ ( (This)->lpVtbl -> IASetIndexBuffer(This,pView) ) -#define ID3D12GraphicsCommandList8_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ +#define ID3D12GraphicsCommandList10_IASetVertexBuffers(This,StartSlot,NumViews,pViews) \ ( (This)->lpVtbl -> IASetVertexBuffers(This,StartSlot,NumViews,pViews) ) -#define ID3D12GraphicsCommandList8_SOSetTargets(This,StartSlot,NumViews,pViews) \ +#define ID3D12GraphicsCommandList10_SOSetTargets(This,StartSlot,NumViews,pViews) \ ( (This)->lpVtbl -> SOSetTargets(This,StartSlot,NumViews,pViews) ) -#define ID3D12GraphicsCommandList8_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ +#define ID3D12GraphicsCommandList10_OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) \ ( (This)->lpVtbl -> OMSetRenderTargets(This,NumRenderTargetDescriptors,pRenderTargetDescriptors,RTsSingleHandleToDescriptorRange,pDepthStencilDescriptor) ) -#define ID3D12GraphicsCommandList8_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ +#define ID3D12GraphicsCommandList10_ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) \ ( (This)->lpVtbl -> ClearDepthStencilView(This,DepthStencilView,ClearFlags,Depth,Stencil,NumRects,pRects) ) -#define ID3D12GraphicsCommandList8_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ +#define ID3D12GraphicsCommandList10_ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) \ ( (This)->lpVtbl -> ClearRenderTargetView(This,RenderTargetView,ColorRGBA,NumRects,pRects) ) -#define ID3D12GraphicsCommandList8_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ +#define ID3D12GraphicsCommandList10_ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ ( (This)->lpVtbl -> ClearUnorderedAccessViewUint(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) -#define ID3D12GraphicsCommandList8_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ +#define ID3D12GraphicsCommandList10_ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) \ ( (This)->lpVtbl -> ClearUnorderedAccessViewFloat(This,ViewGPUHandleInCurrentHeap,ViewCPUHandle,pResource,Values,NumRects,pRects) ) -#define ID3D12GraphicsCommandList8_DiscardResource(This,pResource,pRegion) \ +#define ID3D12GraphicsCommandList10_DiscardResource(This,pResource,pRegion) \ ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) -#define ID3D12GraphicsCommandList8_BeginQuery(This,pQueryHeap,Type,Index) \ +#define ID3D12GraphicsCommandList10_BeginQuery(This,pQueryHeap,Type,Index) \ ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) -#define ID3D12GraphicsCommandList8_EndQuery(This,pQueryHeap,Type,Index) \ +#define ID3D12GraphicsCommandList10_EndQuery(This,pQueryHeap,Type,Index) \ ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) -#define ID3D12GraphicsCommandList8_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ +#define ID3D12GraphicsCommandList10_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) -#define ID3D12GraphicsCommandList8_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ +#define ID3D12GraphicsCommandList10_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) -#define ID3D12GraphicsCommandList8_SetMarker(This,Metadata,pData,Size) \ +#define ID3D12GraphicsCommandList10_SetMarker(This,Metadata,pData,Size) \ ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) -#define ID3D12GraphicsCommandList8_BeginEvent(This,Metadata,pData,Size) \ +#define ID3D12GraphicsCommandList10_BeginEvent(This,Metadata,pData,Size) \ ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) -#define ID3D12GraphicsCommandList8_EndEvent(This) \ +#define ID3D12GraphicsCommandList10_EndEvent(This) \ ( (This)->lpVtbl -> EndEvent(This) ) -#define ID3D12GraphicsCommandList8_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ +#define ID3D12GraphicsCommandList10_ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) \ ( (This)->lpVtbl -> ExecuteIndirect(This,pCommandSignature,MaxCommandCount,pArgumentBuffer,ArgumentBufferOffset,pCountBuffer,CountBufferOffset) ) -#define ID3D12GraphicsCommandList8_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ +#define ID3D12GraphicsCommandList10_AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ ( (This)->lpVtbl -> AtomicCopyBufferUINT(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -#define ID3D12GraphicsCommandList8_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ +#define ID3D12GraphicsCommandList10_AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) \ ( (This)->lpVtbl -> AtomicCopyBufferUINT64(This,pDstBuffer,DstOffset,pSrcBuffer,SrcOffset,Dependencies,ppDependentResources,pDependentSubresourceRanges) ) -#define ID3D12GraphicsCommandList8_OMSetDepthBounds(This,Min,Max) \ +#define ID3D12GraphicsCommandList10_OMSetDepthBounds(This,Min,Max) \ ( (This)->lpVtbl -> OMSetDepthBounds(This,Min,Max) ) -#define ID3D12GraphicsCommandList8_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ +#define ID3D12GraphicsCommandList10_SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) \ ( (This)->lpVtbl -> SetSamplePositions(This,NumSamplesPerPixel,NumPixels,pSamplePositions) ) -#define ID3D12GraphicsCommandList8_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ +#define ID3D12GraphicsCommandList10_ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) \ ( (This)->lpVtbl -> ResolveSubresourceRegion(This,pDstResource,DstSubresource,DstX,DstY,pSrcResource,SrcSubresource,pSrcRect,Format,ResolveMode) ) -#define ID3D12GraphicsCommandList8_SetViewInstanceMask(This,Mask) \ +#define ID3D12GraphicsCommandList10_SetViewInstanceMask(This,Mask) \ ( (This)->lpVtbl -> SetViewInstanceMask(This,Mask) ) -#define ID3D12GraphicsCommandList8_WriteBufferImmediate(This,Count,pParams,pModes) \ +#define ID3D12GraphicsCommandList10_WriteBufferImmediate(This,Count,pParams,pModes) \ ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) -#define ID3D12GraphicsCommandList8_SetProtectedResourceSession(This,pProtectedResourceSession) \ +#define ID3D12GraphicsCommandList10_SetProtectedResourceSession(This,pProtectedResourceSession) \ ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) -#define ID3D12GraphicsCommandList8_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ +#define ID3D12GraphicsCommandList10_BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) \ ( (This)->lpVtbl -> BeginRenderPass(This,NumRenderTargets,pRenderTargets,pDepthStencil,Flags) ) -#define ID3D12GraphicsCommandList8_EndRenderPass(This) \ +#define ID3D12GraphicsCommandList10_EndRenderPass(This) \ ( (This)->lpVtbl -> EndRenderPass(This) ) -#define ID3D12GraphicsCommandList8_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ +#define ID3D12GraphicsCommandList10_InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) \ ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,pInitializationParametersData,InitializationParametersDataSizeInBytes) ) -#define ID3D12GraphicsCommandList8_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ +#define ID3D12GraphicsCommandList10_ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) \ ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,pExecutionParametersData,ExecutionParametersDataSizeInBytes) ) -#define ID3D12GraphicsCommandList8_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ +#define ID3D12GraphicsCommandList10_BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) \ ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc,NumPostbuildInfoDescs,pPostbuildInfoDescs) ) -#define ID3D12GraphicsCommandList8_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ +#define ID3D12GraphicsCommandList10_EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) \ ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostbuildInfo(This,pDesc,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) -#define ID3D12GraphicsCommandList8_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ +#define ID3D12GraphicsCommandList10_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) \ ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) -#define ID3D12GraphicsCommandList8_SetPipelineState1(This,pStateObject) \ +#define ID3D12GraphicsCommandList10_SetPipelineState1(This,pStateObject) \ ( (This)->lpVtbl -> SetPipelineState1(This,pStateObject) ) -#define ID3D12GraphicsCommandList8_DispatchRays(This,pDesc) \ +#define ID3D12GraphicsCommandList10_DispatchRays(This,pDesc) \ ( (This)->lpVtbl -> DispatchRays(This,pDesc) ) -#define ID3D12GraphicsCommandList8_RSSetShadingRate(This,baseShadingRate,combiners) \ +#define ID3D12GraphicsCommandList10_RSSetShadingRate(This,baseShadingRate,combiners) \ ( (This)->lpVtbl -> RSSetShadingRate(This,baseShadingRate,combiners) ) -#define ID3D12GraphicsCommandList8_RSSetShadingRateImage(This,shadingRateImage) \ +#define ID3D12GraphicsCommandList10_RSSetShadingRateImage(This,shadingRateImage) \ ( (This)->lpVtbl -> RSSetShadingRateImage(This,shadingRateImage) ) -#define ID3D12GraphicsCommandList8_DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ +#define ID3D12GraphicsCommandList10_DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) \ ( (This)->lpVtbl -> DispatchMesh(This,ThreadGroupCountX,ThreadGroupCountY,ThreadGroupCountZ) ) -#define ID3D12GraphicsCommandList8_Barrier(This,NumBarrierGroups,pBarrierGroups) \ +#define ID3D12GraphicsCommandList10_Barrier(This,NumBarrierGroups,pBarrierGroups) \ ( (This)->lpVtbl -> Barrier(This,NumBarrierGroups,pBarrierGroups) ) -#define ID3D12GraphicsCommandList8_OMSetFrontAndBackStencilRef(This,FrontStencilRef,BackStencilRef) \ +#define ID3D12GraphicsCommandList10_OMSetFrontAndBackStencilRef(This,FrontStencilRef,BackStencilRef) \ ( (This)->lpVtbl -> OMSetFrontAndBackStencilRef(This,FrontStencilRef,BackStencilRef) ) + +#define ID3D12GraphicsCommandList10_RSSetDepthBias(This,DepthBias,DepthBiasClamp,SlopeScaledDepthBias) \ + ( (This)->lpVtbl -> RSSetDepthBias(This,DepthBias,DepthBiasClamp,SlopeScaledDepthBias) ) + +#define ID3D12GraphicsCommandList10_IASetIndexBufferStripCutValue(This,IBStripCutValue) \ + ( (This)->lpVtbl -> IASetIndexBufferStripCutValue(This,IBStripCutValue) ) + + +#define ID3D12GraphicsCommandList10_SetProgram(This,pDesc) \ + ( (This)->lpVtbl -> SetProgram(This,pDesc) ) + +#define ID3D12GraphicsCommandList10_DispatchGraph(This,pDesc) \ + ( (This)->lpVtbl -> DispatchGraph(This,pDesc) ) + #endif /* COBJMACROS */ @@ -28615,14 +36536,253 @@ EXTERN_C const IID IID_ID3D12GraphicsCommandList8; -#endif /* __ID3D12GraphicsCommandList8_INTERFACE_DEFINED__ */ +#endif /* __ID3D12GraphicsCommandList10_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12DSRDeviceFactory_INTERFACE_DEFINED__ +#define __ID3D12DSRDeviceFactory_INTERFACE_DEFINED__ + +/* interface ID3D12DSRDeviceFactory */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12DSRDeviceFactory; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("f343d1a0-afe3-439f-b13d-cd87a43b70ca") + ID3D12DSRDeviceFactory : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateDSRDevice( + ID3D12Device *pD3D12Device, + UINT NodeMask, + REFIID riid, + _COM_Outptr_ void **ppvDSRDevice) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12DSRDeviceFactoryVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12DSRDeviceFactory * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12DSRDeviceFactory * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12DSRDeviceFactory * This); + + DECLSPEC_XFGVIRT(ID3D12DSRDeviceFactory, CreateDSRDevice) + HRESULT ( STDMETHODCALLTYPE *CreateDSRDevice )( + ID3D12DSRDeviceFactory * This, + ID3D12Device *pD3D12Device, + UINT NodeMask, + REFIID riid, + _COM_Outptr_ void **ppvDSRDevice); + + END_INTERFACE + } ID3D12DSRDeviceFactoryVtbl; + + interface ID3D12DSRDeviceFactory + { + CONST_VTBL struct ID3D12DSRDeviceFactoryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12DSRDeviceFactory_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12DSRDeviceFactory_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12DSRDeviceFactory_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12DSRDeviceFactory_CreateDSRDevice(This,pD3D12Device,NodeMask,riid,ppvDSRDevice) \ + ( (This)->lpVtbl -> CreateDSRDevice(This,pD3D12Device,NodeMask,riid,ppvDSRDevice) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12DSRDeviceFactory_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12GBVDiagnostics_INTERFACE_DEFINED__ +#define __ID3D12GBVDiagnostics_INTERFACE_DEFINED__ + +/* interface ID3D12GBVDiagnostics */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12GBVDiagnostics; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("597985ab-9b75-4dbb-be23-0761195bebee") + ID3D12GBVDiagnostics : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetGBVEntireSubresourceStatesData( + _In_ ID3D12Resource *pResource, + _Out_writes_bytes_(DataSize) int *pData, + UINT DataSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGBVSubresourceState( + _In_ ID3D12Resource *pResource, + UINT Subresource, + _Out_ int *pData) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGBVResourceUniformState( + _In_ ID3D12Resource *pResource, + _Out_ int *pData) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGBVResourceInfo( + _In_ ID3D12Resource *pResource, + _In_opt_ D3D12_RESOURCE_DESC *pResourceDesc, + _In_opt_ UINT32 *pResourceHash, + _In_opt_ UINT32 *pSubresourceStatesByteOffset) = 0; + + virtual void STDMETHODCALLTYPE GBVReserved0( void) = 0; + + virtual void STDMETHODCALLTYPE GBVReserved1( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12GBVDiagnosticsVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12GBVDiagnostics * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12GBVDiagnostics * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12GBVDiagnostics * This); + + DECLSPEC_XFGVIRT(ID3D12GBVDiagnostics, GetGBVEntireSubresourceStatesData) + HRESULT ( STDMETHODCALLTYPE *GetGBVEntireSubresourceStatesData )( + ID3D12GBVDiagnostics * This, + _In_ ID3D12Resource *pResource, + _Out_writes_bytes_(DataSize) int *pData, + UINT DataSize); + + DECLSPEC_XFGVIRT(ID3D12GBVDiagnostics, GetGBVSubresourceState) + HRESULT ( STDMETHODCALLTYPE *GetGBVSubresourceState )( + ID3D12GBVDiagnostics * This, + _In_ ID3D12Resource *pResource, + UINT Subresource, + _Out_ int *pData); + + DECLSPEC_XFGVIRT(ID3D12GBVDiagnostics, GetGBVResourceUniformState) + HRESULT ( STDMETHODCALLTYPE *GetGBVResourceUniformState )( + ID3D12GBVDiagnostics * This, + _In_ ID3D12Resource *pResource, + _Out_ int *pData); + + DECLSPEC_XFGVIRT(ID3D12GBVDiagnostics, GetGBVResourceInfo) + HRESULT ( STDMETHODCALLTYPE *GetGBVResourceInfo )( + ID3D12GBVDiagnostics * This, + _In_ ID3D12Resource *pResource, + _In_opt_ D3D12_RESOURCE_DESC *pResourceDesc, + _In_opt_ UINT32 *pResourceHash, + _In_opt_ UINT32 *pSubresourceStatesByteOffset); + + DECLSPEC_XFGVIRT(ID3D12GBVDiagnostics, GBVReserved0) + void ( STDMETHODCALLTYPE *GBVReserved0 )( + ID3D12GBVDiagnostics * This); + + DECLSPEC_XFGVIRT(ID3D12GBVDiagnostics, GBVReserved1) + void ( STDMETHODCALLTYPE *GBVReserved1 )( + ID3D12GBVDiagnostics * This); + + END_INTERFACE + } ID3D12GBVDiagnosticsVtbl; + + interface ID3D12GBVDiagnostics + { + CONST_VTBL struct ID3D12GBVDiagnosticsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12GBVDiagnostics_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12GBVDiagnostics_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12GBVDiagnostics_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12GBVDiagnostics_GetGBVEntireSubresourceStatesData(This,pResource,pData,DataSize) \ + ( (This)->lpVtbl -> GetGBVEntireSubresourceStatesData(This,pResource,pData,DataSize) ) + +#define ID3D12GBVDiagnostics_GetGBVSubresourceState(This,pResource,Subresource,pData) \ + ( (This)->lpVtbl -> GetGBVSubresourceState(This,pResource,Subresource,pData) ) + +#define ID3D12GBVDiagnostics_GetGBVResourceUniformState(This,pResource,pData) \ + ( (This)->lpVtbl -> GetGBVResourceUniformState(This,pResource,pData) ) + +#define ID3D12GBVDiagnostics_GetGBVResourceInfo(This,pResource,pResourceDesc,pResourceHash,pSubresourceStatesByteOffset) \ + ( (This)->lpVtbl -> GetGBVResourceInfo(This,pResource,pResourceDesc,pResourceHash,pSubresourceStatesByteOffset) ) + +#define ID3D12GBVDiagnostics_GBVReserved0(This) \ + ( (This)->lpVtbl -> GBVReserved0(This) ) + +#define ID3D12GBVDiagnostics_GBVReserved1(This) \ + ( (This)->lpVtbl -> GBVReserved1(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12GBVDiagnostics_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12_0000_0065 */ +/* interface __MIDL_itf_d3d12_0000_0085 */ /* [local] */ #endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ -//#pragma endregion +#pragma endregion DEFINE_GUID(IID_ID3D12Object,0xc4fec28f,0x7966,0x4e95,0x9f,0x94,0xf4,0x31,0xcb,0x56,0xc3,0xb8); DEFINE_GUID(IID_ID3D12DeviceChild,0x905db94b,0xa00c,0x4140,0x9d,0xf5,0x2b,0x64,0xca,0x9e,0xa3,0x57); DEFINE_GUID(IID_ID3D12RootSignature,0xc54a6b66,0x72df,0x4ee8,0x8b,0xe5,0xa9,0x46,0xa1,0x42,0x92,0x14); @@ -28635,6 +36795,7 @@ DEFINE_GUID(IID_ID3D12CommandAllocator,0x6102dee4,0xaf59,0x4b09,0xb9,0x99,0xb4,0 DEFINE_GUID(IID_ID3D12Fence,0x0a753dcf,0xc4d8,0x4b91,0xad,0xf6,0xbe,0x5a,0x60,0xd9,0x5a,0x76); DEFINE_GUID(IID_ID3D12Fence1,0x433685fe,0xe22b,0x4ca0,0xa8,0xdb,0xb5,0xb4,0xf4,0xdd,0x0e,0x4a); DEFINE_GUID(IID_ID3D12PipelineState,0x765a30f3,0xf624,0x4c6f,0xa8,0x28,0xac,0xe9,0x48,0x62,0x24,0x45); +DEFINE_GUID(IID_ID3D12PipelineState1,0x5646804c,0x9638,0x48f7,0x91,0x82,0xb3,0xee,0x5a,0x6b,0x60,0xfb); DEFINE_GUID(IID_ID3D12DescriptorHeap,0x8efb471d,0x616c,0x4f49,0x90,0xf7,0x12,0x7b,0xb7,0x63,0xfa,0x51); DEFINE_GUID(IID_ID3D12QueryHeap,0x0d9658ae,0xed45,0x469e,0xa6,0x1d,0x97,0x0e,0xc5,0x83,0xca,0xb4); DEFINE_GUID(IID_ID3D12CommandSignature,0xc36a797c,0xec80,0x4f0a,0x89,0x85,0xa7,0xb2,0x47,0x50,0x82,0xd1); @@ -28643,6 +36804,7 @@ DEFINE_GUID(IID_ID3D12GraphicsCommandList,0x5b160d0f,0xac1b,0x4185,0x8b,0xa8,0xb DEFINE_GUID(IID_ID3D12GraphicsCommandList1,0x553103fb,0x1fe7,0x4557,0xbb,0x38,0x94,0x6d,0x7d,0x0e,0x7c,0xa7); DEFINE_GUID(IID_ID3D12GraphicsCommandList2,0x38C3E585,0xFF17,0x412C,0x91,0x50,0x4F,0xC6,0xF9,0xD7,0x2A,0x28); DEFINE_GUID(IID_ID3D12CommandQueue,0x0ec870a6,0x5d7e,0x4c22,0x8c,0xfc,0x5b,0xaa,0xe0,0x76,0x16,0xed); +DEFINE_GUID(IID_ID3D12CommandQueue1,0x3a3c3165,0x0ee7,0x4b8e,0xa0,0xaf,0x63,0x56,0xb4,0xc3,0xbb,0xb9); DEFINE_GUID(IID_ID3D12Device,0x189819f1,0x1db6,0x4b57,0xbe,0x54,0x18,0x21,0x33,0x9b,0x85,0xf7); DEFINE_GUID(IID_ID3D12PipelineLibrary,0xc64226a8,0x9201,0x46af,0xb4,0xcc,0x53,0xfb,0x9f,0xf7,0x41,0x4f); DEFINE_GUID(IID_ID3D12PipelineLibrary1,0x80eabf42,0x2568,0x4e5e,0xbd,0x82,0xc3,0x7f,0x86,0x96,0x1d,0xc3); @@ -28657,6 +36819,9 @@ DEFINE_GUID(IID_ID3D12SwapChainAssistant,0xf1df64b6,0x57fd,0x49cd,0x88,0x07,0xc0 DEFINE_GUID(IID_ID3D12LifetimeTracker,0x3fd03d36,0x4eb1,0x424a,0xa5,0x82,0x49,0x4e,0xcb,0x8b,0xa8,0x13); DEFINE_GUID(IID_ID3D12StateObject,0x47016943,0xfca8,0x4594,0x93,0xea,0xaf,0x25,0x8b,0x55,0x34,0x6d); DEFINE_GUID(IID_ID3D12StateObjectProperties,0xde5fa827,0x9bf9,0x4f26,0x89,0xff,0xd7,0xf5,0x6f,0xde,0x38,0x60); +DEFINE_GUID(IID_ID3D12StateObjectProperties1,0x460caac7,0x1d24,0x446a,0xa1,0x84,0xca,0x67,0xdb,0x49,0x41,0x38); +DEFINE_GUID(IID_ID3D12StateObjectProperties2,0xd5e82917,0xf0f1,0x44cf,0xae,0x5e,0xce,0x22,0x2d,0xd0,0xb8,0x84); +DEFINE_GUID(IID_ID3D12WorkGraphProperties,0x065acf71,0xf863,0x4b89,0x82,0xf4,0x02,0xe4,0xd5,0x88,0x67,0x57); DEFINE_GUID(IID_ID3D12Device5,0x8b4f173b,0x2fea,0x4b80,0x8f,0x58,0x43,0x07,0x19,0x1a,0xb9,0x5d); DEFINE_GUID(IID_ID3D12DeviceRemovedExtendedDataSettings,0x82BC481C,0x6B9B,0x4030,0xAE,0xDB,0x7E,0xE3,0xD1,0xDF,0x1E,0x63); DEFINE_GUID(IID_ID3D12DeviceRemovedExtendedDataSettings1,0xDBD5AE51,0x3317,0x4F0A,0xAD,0xF9,0x1D,0x7C,0xED,0xCA,0xAE,0x0B); @@ -28678,20 +36843,35 @@ DEFINE_GUID(IID_ID3D12ShaderCacheSession,0x28e2495d,0x0f64,0x4ae4,0xa6,0xec,0x12 DEFINE_GUID(IID_ID3D12Device9,0x4c80e962,0xf032,0x4f60,0xbc,0x9e,0xeb,0xc2,0xcf,0xa1,0xd8,0x3c); DEFINE_GUID(IID_ID3D12Device10,0x517f8718,0xaa66,0x49f9,0xb0,0x2b,0xa7,0xab,0x89,0xc0,0x60,0x31); DEFINE_GUID(IID_ID3D12Device11,0x5405c344,0xd457,0x444e,0xb4,0xdd,0x23,0x66,0xe4,0x5a,0xee,0x39); +DEFINE_GUID(IID_ID3D12Device12,0x5af5c532,0x4c91,0x4cd0,0xb5,0x41,0x15,0xa4,0x05,0x39,0x5f,0xc5); +DEFINE_GUID(IID_ID3D12Device13,0x14eecffc,0x4df8,0x40f7,0xa1,0x18,0x5c,0x81,0x6f,0x45,0x69,0x5e); +DEFINE_GUID(IID_ID3D12Device14,0x5f6e592d,0xd895,0x44c2,0x8e,0x4a,0x88,0xad,0x49,0x26,0xd3,0x23); +DEFINE_GUID(IID_ID3D12StateObjectDatabase,0xc56060b7,0xb5fc,0x4135,0x98,0xe0,0xa1,0xe9,0x99,0x7e,0xac,0xe0); DEFINE_GUID(IID_ID3D12VirtualizationGuestDevice,0xbc66d368,0x7373,0x4943,0x87,0x57,0xfc,0x87,0xdc,0x79,0xe4,0x76); DEFINE_GUID(IID_ID3D12Tools,0x7071e1f0,0xe84b,0x4b33,0x97,0x4f,0x12,0xfa,0x49,0xde,0x65,0xc5); +DEFINE_GUID(IID_ID3D12Tools1,0xe4fbc019,0xdd3c,0x43e1,0x8f,0x32,0x7f,0x64,0x95,0x75,0xf0,0xa0); +DEFINE_GUID(IID_ID3D12Tools2,0x01d393c5,0xc9b0,0x42a1,0x95,0x8c,0xc2,0x6b,0x02,0xd4,0xd0,0x97); +DEFINE_GUID(IID_ID3D12PageableTools,0x8f1359db,0xd8d1,0x42f9,0xb5,0xcf,0x79,0xf4,0xcb,0xad,0x0d,0x3d); +DEFINE_GUID(IID_ID3D12DeviceTools,0x2ea68e9c,0x19c3,0x4e47,0xa1,0x09,0x6c,0xda,0xdf,0xf0,0xac,0xa9); +DEFINE_GUID(IID_ID3D12DeviceTools1,0xe30e9fc7,0xe641,0x4d6e,0x8a,0x81,0x9d,0xd9,0x20,0x6e,0xc4,0x7a); DEFINE_GUID(IID_ID3D12SDKConfiguration,0xe9eb5314,0x33aa,0x42b2,0xa7,0x18,0xd7,0x7f,0x58,0xb1,0xf1,0xc7); DEFINE_GUID(IID_ID3D12SDKConfiguration1,0x8aaf9303,0xad25,0x48b9,0x9a,0x57,0xd9,0xc3,0x7e,0x00,0x9d,0x9f); DEFINE_GUID(IID_ID3D12DeviceFactory,0x61f307d3,0xd34e,0x4e7c,0x83,0x74,0x3b,0xa4,0xde,0x23,0xcc,0xcb); DEFINE_GUID(IID_ID3D12DeviceConfiguration,0x78dbf87b,0xf766,0x422b,0xa6,0x1c,0xc8,0xc4,0x46,0xbd,0xb9,0xad); +DEFINE_GUID(IID_ID3D12DeviceConfiguration1,0xed342442,0x6343,0x4e16,0xbb,0x82,0xa3,0xa5,0x77,0x87,0x4e,0x56); +DEFINE_GUID(IID_ID3D12StateObjectDatabaseFactory,0xf5b066f0,0x648a,0x4611,0xbd,0x41,0x27,0xfd,0x09,0x48,0xb9,0xeb); DEFINE_GUID(IID_ID3D12GraphicsCommandList5,0x55050859,0x4024,0x474c,0x87,0xf5,0x64,0x72,0xea,0xee,0x44,0xea); DEFINE_GUID(IID_ID3D12GraphicsCommandList6,0xc3827890,0xe548,0x4cfa,0x96,0xcf,0x56,0x89,0xa9,0x37,0x0f,0x80); DEFINE_GUID(IID_ID3D12GraphicsCommandList7,0xdd171223,0x8b61,0x4769,0x90,0xe3,0x16,0x0c,0xcd,0xe4,0xe2,0xc1); DEFINE_GUID(IID_ID3D12GraphicsCommandList8,0xee936ef9,0x599d,0x4d28,0x93,0x8e,0x23,0xc4,0xad,0x05,0xce,0x51); +DEFINE_GUID(IID_ID3D12GraphicsCommandList9,0x34ed2808,0xffe6,0x4c2b,0xb1,0x1a,0xca,0xbd,0x2b,0x0c,0x59,0xe1); +DEFINE_GUID(IID_ID3D12GraphicsCommandList10,0x7013c015,0xd161,0x4b63,0xa0,0x8c,0x23,0x85,0x52,0xdd,0x8a,0xcc); +DEFINE_GUID(IID_ID3D12DSRDeviceFactory,0xf343d1a0,0xafe3,0x439f,0xb1,0x3d,0xcd,0x87,0xa4,0x3b,0x70,0xca); +DEFINE_GUID(IID_ID3D12GBVDiagnostics,0x597985ab,0x9b75,0x4dbb,0xbe,0x23,0x07,0x61,0x19,0x5b,0xeb,0xee); -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0065_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0065_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0085_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12_0000_0085_v0_0_s_ifspec; /* Additional Prototypes for ALL interfaces */ diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12compatibility.h b/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12compatibility.h index 1a9430e..ec9ff5f 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12compatibility.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12compatibility.h @@ -87,6 +87,13 @@ typedef interface OpenCLOn12CreatorID OpenCLOn12CreatorID; #endif /* __OpenCLOn12CreatorID_FWD_DEFINED__ */ +#ifndef __VulkanOn12CreatorID_FWD_DEFINED__ +#define __VulkanOn12CreatorID_FWD_DEFINED__ +typedef interface VulkanOn12CreatorID VulkanOn12CreatorID; + +#endif /* __VulkanOn12CreatorID_FWD_DEFINED__ */ + + #ifndef __DirectMLTensorFlowCreatorID_FWD_DEFINED__ #define __DirectMLTensorFlowCreatorID_FWD_DEFINED__ typedef interface DirectMLTensorFlowCreatorID DirectMLTensorFlowCreatorID; @@ -101,6 +108,13 @@ typedef interface DirectMLPyTorchCreatorID DirectMLPyTorchCreatorID; #endif /* __DirectMLPyTorchCreatorID_FWD_DEFINED__ */ +#ifndef __DirectMLWebNNCreatorID_FWD_DEFINED__ +#define __DirectMLWebNNCreatorID_FWD_DEFINED__ +typedef interface DirectMLWebNNCreatorID DirectMLWebNNCreatorID; + +#endif /* __DirectMLWebNNCreatorID_FWD_DEFINED__ */ + + /* header files for imported files */ #include "oaidl.h" #include "ocidl.h" @@ -126,7 +140,7 @@ enum D3D12_COMPATIBILITY_SHARED_FLAGS D3D12_COMPATIBILITY_SHARED_FLAG_9_ON_12 = 0x4 } D3D12_COMPATIBILITY_SHARED_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMPATIBILITY_SHARED_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMPATIBILITY_SHARED_FLAGS ) typedef enum D3D12_REFLECT_SHARED_PROPERTY { @@ -565,6 +579,78 @@ EXTERN_C const IID IID_OpenCLOn12CreatorID; #endif /* __OpenCLOn12CreatorID_INTERFACE_DEFINED__ */ +#ifndef __VulkanOn12CreatorID_INTERFACE_DEFINED__ +#define __VulkanOn12CreatorID_INTERFACE_DEFINED__ + +/* interface VulkanOn12CreatorID */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_VulkanOn12CreatorID; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("bc806e01-3052-406c-a3e8-9fc07f048f98") + VulkanOn12CreatorID : public IUnknown + { + public: + }; + + +#else /* C style interface */ + + typedef struct VulkanOn12CreatorIDVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + VulkanOn12CreatorID * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + VulkanOn12CreatorID * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + VulkanOn12CreatorID * This); + + END_INTERFACE + } VulkanOn12CreatorIDVtbl; + + interface VulkanOn12CreatorID + { + CONST_VTBL struct VulkanOn12CreatorIDVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define VulkanOn12CreatorID_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define VulkanOn12CreatorID_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define VulkanOn12CreatorID_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __VulkanOn12CreatorID_INTERFACE_DEFINED__ */ + + #ifndef __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__ #define __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__ @@ -709,7 +795,79 @@ EXTERN_C const IID IID_DirectMLPyTorchCreatorID; #endif /* __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12compatibility_0000_0007 */ +#ifndef __DirectMLWebNNCreatorID_INTERFACE_DEFINED__ +#define __DirectMLWebNNCreatorID_INTERFACE_DEFINED__ + +/* interface DirectMLWebNNCreatorID */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_DirectMLWebNNCreatorID; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("fdf01a76-1e11-450f-902b-74f04ea08094") + DirectMLWebNNCreatorID : public IUnknown + { + public: + }; + + +#else /* C style interface */ + + typedef struct DirectMLWebNNCreatorIDVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + DirectMLWebNNCreatorID * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + DirectMLWebNNCreatorID * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + DirectMLWebNNCreatorID * This); + + END_INTERFACE + } DirectMLWebNNCreatorIDVtbl; + + interface DirectMLWebNNCreatorID + { + CONST_VTBL struct DirectMLWebNNCreatorIDVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define DirectMLWebNNCreatorID_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define DirectMLWebNNCreatorID_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define DirectMLWebNNCreatorID_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __DirectMLWebNNCreatorID_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12compatibility_0000_0009 */ /* [local] */ #endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ @@ -719,12 +877,14 @@ DEFINE_GUID(IID_D3D11On12CreatorID,0xedbf5678,0x2960,0x4e81,0x84,0x29,0x99,0xd4, DEFINE_GUID(IID_D3D9On12CreatorID,0xfffcbb7f,0x15d3,0x42a2,0x84,0x1e,0x9d,0x8d,0x32,0xf3,0x7d,0xdd); DEFINE_GUID(IID_OpenGLOn12CreatorID,0x6bb3cd34,0x0d19,0x45ab,0x97,0xed,0xd7,0x20,0xba,0x3d,0xfc,0x80); DEFINE_GUID(IID_OpenCLOn12CreatorID,0x3f76bb74,0x91b5,0x4a88,0xb1,0x26,0x20,0xca,0x03,0x31,0xcd,0x60); +DEFINE_GUID(IID_VulkanOn12CreatorID,0xbc806e01,0x3052,0x406c,0xa3,0xe8,0x9f,0xc0,0x7f,0x04,0x8f,0x98); DEFINE_GUID(IID_DirectMLTensorFlowCreatorID,0xcb7490ac,0x8a0f,0x44ec,0x9b,0x7b,0x6f,0x4c,0xaf,0xe8,0xe9,0xab); DEFINE_GUID(IID_DirectMLPyTorchCreatorID,0xaf029192,0xfba1,0x4b05,0x91,0x16,0x23,0x5e,0x06,0x56,0x03,0x54); +DEFINE_GUID(IID_DirectMLWebNNCreatorID,0xfdf01a76,0x1e11,0x450f,0x90,0x2b,0x74,0xf0,0x4e,0xa0,0x80,0x94); -extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0007_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0007_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0009_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0009_v0_0_s_ifspec; /* Additional Prototypes for ALL interfaces */ diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12compiler.h b/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12compiler.h new file mode 100644 index 0000000..e505d4a --- /dev/null +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12compiler.h @@ -0,0 +1,977 @@ +/*------------------------------------------------------------------------------------- + * + * Copyright (c) Microsoft Corporation + * Licensed under the MIT license + * + *-------------------------------------------------------------------------------------*/ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.01.0628 */ + + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCSAL_H_VERSION__ +#define __REQUIRED_RPCSAL_H_VERSION__ 100 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif /* __RPCNDR_H_VERSION__ */ + +#ifndef COM_NO_WINDOWS_H +#include "windows.h" +#include "ole2.h" +#endif /*COM_NO_WINDOWS_H*/ + +#ifndef __d3d12compiler_h__ +#define __d3d12compiler_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +#ifndef DECLSPEC_XFGVIRT +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func)) +#else +#define DECLSPEC_XFGVIRT(base, func) +#endif +#endif + +/* Forward Declarations */ + +#ifndef __ID3D12CompilerFactoryChild_FWD_DEFINED__ +#define __ID3D12CompilerFactoryChild_FWD_DEFINED__ +typedef interface ID3D12CompilerFactoryChild ID3D12CompilerFactoryChild; + +#endif /* __ID3D12CompilerFactoryChild_FWD_DEFINED__ */ + + +#ifndef __ID3D12CompilerCacheSession_FWD_DEFINED__ +#define __ID3D12CompilerCacheSession_FWD_DEFINED__ +typedef interface ID3D12CompilerCacheSession ID3D12CompilerCacheSession; + +#endif /* __ID3D12CompilerCacheSession_FWD_DEFINED__ */ + + +#ifndef __ID3D12CompilerStateObject_FWD_DEFINED__ +#define __ID3D12CompilerStateObject_FWD_DEFINED__ +typedef interface ID3D12CompilerStateObject ID3D12CompilerStateObject; + +#endif /* __ID3D12CompilerStateObject_FWD_DEFINED__ */ + + +#ifndef __ID3D12Compiler_FWD_DEFINED__ +#define __ID3D12Compiler_FWD_DEFINED__ +typedef interface ID3D12Compiler ID3D12Compiler; + +#endif /* __ID3D12Compiler_FWD_DEFINED__ */ + + +#ifndef __ID3D12CompilerFactory_FWD_DEFINED__ +#define __ID3D12CompilerFactory_FWD_DEFINED__ +typedef interface ID3D12CompilerFactory ID3D12CompilerFactory; + +#endif /* __ID3D12CompilerFactory_FWD_DEFINED__ */ + + +/* header files for imported files */ +#include "oaidl.h" +#include "ocidl.h" +#include "dxgicommon.h" +#include "d3d12.h" + +#ifdef __cplusplus +extern "C"{ +#endif + + +/* interface __MIDL_itf_d3d12compiler_0000_0000 */ +/* [local] */ + +#include +#pragma region App Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) +typedef struct D3D12_ADAPTER_FAMILY + { + WCHAR szAdapterFamily[ 128 ]; + } D3D12_ADAPTER_FAMILY; + +typedef HRESULT (WINAPI* PFN_D3D12_COMPILER_CREATE_FACTORY)( + _In_ LPCWSTR pPluginCompilerDllPath, + _In_ REFIID riid, + _COM_Outptr_opt_ void** ppFactory ); + +HRESULT WINAPI D3D12CompilerCreateFactory( + _In_ LPCWSTR pPluginCompilerDllPath, + _In_ REFIID riid, // Expected: ID3D12CompilerFactory + _COM_Outptr_opt_ void** ppFactory ); + +typedef HRESULT (WINAPI* PFN_D3D12_COMPILER_SERIALIZE_VERSIONED_ROOT_SIGNATURE)( + _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignature, + _Out_ ID3DBlob** ppBlob, + _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob); + +HRESULT WINAPI D3D12CompilerSerializeVersionedRootSignature( + _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignature, + _Out_ ID3DBlob** ppBlob, + _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob); + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0000_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0000_v0_0_s_ifspec; + +#ifndef __ID3D12CompilerFactoryChild_INTERFACE_DEFINED__ +#define __ID3D12CompilerFactoryChild_INTERFACE_DEFINED__ + +/* interface ID3D12CompilerFactoryChild */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12CompilerFactoryChild; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e0d06420-9f31-47e8-ae9a-dd2ba25ac0bc") + ID3D12CompilerFactoryChild : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetFactory( + _In_ REFIID riid, + _COM_Outptr_ void **ppCompilerFactory) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12CompilerFactoryChildVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12CompilerFactoryChild * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12CompilerFactoryChild * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12CompilerFactoryChild * This); + + DECLSPEC_XFGVIRT(ID3D12CompilerFactoryChild, GetFactory) + HRESULT ( STDMETHODCALLTYPE *GetFactory )( + ID3D12CompilerFactoryChild * This, + _In_ REFIID riid, + _COM_Outptr_ void **ppCompilerFactory); + + END_INTERFACE + } ID3D12CompilerFactoryChildVtbl; + + interface ID3D12CompilerFactoryChild + { + CONST_VTBL struct ID3D12CompilerFactoryChildVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12CompilerFactoryChild_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12CompilerFactoryChild_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12CompilerFactoryChild_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12CompilerFactoryChild_GetFactory(This,riid,ppCompilerFactory) \ + ( (This)->lpVtbl -> GetFactory(This,riid,ppCompilerFactory) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12CompilerFactoryChild_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12compiler_0000_0001 */ +/* [local] */ + +typedef +enum D3D12_COMPILER_VALUE_TYPE + { + D3D12_COMPILER_VALUE_TYPE_OBJECT_CODE = 0, + D3D12_COMPILER_VALUE_TYPE_METADATA = 1, + D3D12_COMPILER_VALUE_TYPE_DEBUG_PDB = 2, + D3D12_COMPILER_VALUE_TYPE_PERFORMANCE_DATA = 3 + } D3D12_COMPILER_VALUE_TYPE; + +typedef +enum D3D12_COMPILER_VALUE_TYPE_FLAGS + { + D3D12_COMPILER_VALUE_TYPE_FLAGS_NONE = 0, + D3D12_COMPILER_VALUE_TYPE_FLAGS_OBJECT_CODE = ( 1 << D3D12_COMPILER_VALUE_TYPE_OBJECT_CODE ) , + D3D12_COMPILER_VALUE_TYPE_FLAGS_METADATA = ( 1 << D3D12_COMPILER_VALUE_TYPE_METADATA ) , + D3D12_COMPILER_VALUE_TYPE_FLAGS_DEBUG_PDB = ( 1 << D3D12_COMPILER_VALUE_TYPE_DEBUG_PDB ) , + D3D12_COMPILER_VALUE_TYPE_FLAGS_PERFORMANCE_DATA = ( 1 << D3D12_COMPILER_VALUE_TYPE_PERFORMANCE_DATA ) + } D3D12_COMPILER_VALUE_TYPE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMPILER_VALUE_TYPE_FLAGS ) +typedef struct D3D12_COMPILER_DATABASE_PATH + { + D3D12_COMPILER_VALUE_TYPE_FLAGS Types; + LPCWSTR pPath; + } D3D12_COMPILER_DATABASE_PATH; + +typedef struct D3D12_COMPILER_CACHE_GROUP_KEY + { + _Field_size_bytes_full_(KeySize) const void *pKey; + UINT KeySize; + } D3D12_COMPILER_CACHE_GROUP_KEY; + +typedef struct D3D12_COMPILER_CACHE_VALUE_KEY + { + _Field_size_bytes_full_(KeySize) const void *pKey; + UINT KeySize; + } D3D12_COMPILER_CACHE_VALUE_KEY; + +typedef struct D3D12_COMPILER_CACHE_VALUE + { + _Field_size_bytes_full_(ValueSize) void *pValue; + UINT ValueSize; + } D3D12_COMPILER_CACHE_VALUE; + +typedef struct D3D12_COMPILER_CACHE_TYPED_VALUE + { + D3D12_COMPILER_VALUE_TYPE Type; + D3D12_COMPILER_CACHE_VALUE Value; + } D3D12_COMPILER_CACHE_TYPED_VALUE; + +typedef struct D3D12_COMPILER_CACHE_CONST_VALUE + { + _Field_size_bytes_full_(ValueSize) const void *pValue; + UINT ValueSize; + } D3D12_COMPILER_CACHE_CONST_VALUE; + +typedef struct D3D12_COMPILER_CACHE_TYPED_CONST_VALUE + { + D3D12_COMPILER_VALUE_TYPE Type; + D3D12_COMPILER_CACHE_CONST_VALUE Value; + } D3D12_COMPILER_CACHE_TYPED_CONST_VALUE; + +typedef struct D3D12_COMPILER_TARGET + { + UINT AdapterFamilyIndex; + UINT64 ABIVersion; + } D3D12_COMPILER_TARGET; + +typedef void *( __stdcall *D3D12CompilerCacheSessionAllocationFunc )( + SIZE_T SizeInBytes, + _Inout_opt_ void *pContext); + +typedef void ( __stdcall *D3D12CompilerCacheSessionGroupValueKeysFunc )( + _In_ const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKey, + _Inout_opt_ void *pContext); + +typedef void ( __stdcall *D3D12CompilerCacheSessionGroupValuesFunc )( + UINT ValueKeyIndex, + _In_ const D3D12_COMPILER_CACHE_TYPED_CONST_VALUE *pTypedValue, + _Inout_opt_ void *pContext); + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0001_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0001_v0_0_s_ifspec; + +#ifndef __ID3D12CompilerCacheSession_INTERFACE_DEFINED__ +#define __ID3D12CompilerCacheSession_INTERFACE_DEFINED__ + +/* interface ID3D12CompilerCacheSession */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12CompilerCacheSession; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5704e5e6-054b-4738-b661-7b0d68d8dde2") + ID3D12CompilerCacheSession : public ID3D12CompilerFactoryChild + { + public: + virtual HRESULT STDMETHODCALLTYPE FindGroup( + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + _Out_opt_ UINT *pGroupVersion) = 0; + + virtual HRESULT STDMETHODCALLTYPE FindGroupValueKeys( + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + _In_opt_ const UINT *pExpectedGroupVersion, + _In_ D3D12CompilerCacheSessionGroupValueKeysFunc CallbackFunc, + _Inout_opt_ void *pContext) = 0; + + virtual HRESULT STDMETHODCALLTYPE FindGroupValues( + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + _In_opt_ const UINT *pExpectedGroupVersion, + D3D12_COMPILER_VALUE_TYPE_FLAGS ValueTypeFlags, + _In_opt_ D3D12CompilerCacheSessionGroupValuesFunc CallbackFunc, + _Inout_opt_ void *pContext) = 0; + + virtual HRESULT STDMETHODCALLTYPE FindValue( + _In_ const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKey, + _Inout_count_(NumTypedValues) D3D12_COMPILER_CACHE_TYPED_VALUE *pTypedValues, + UINT NumTypedValues, + _In_opt_ D3D12CompilerCacheSessionAllocationFunc pCallbackFunc, + _Inout_opt_ void *pContext) = 0; + + virtual const D3D12_APPLICATION_DESC *STDMETHODCALLTYPE GetApplicationDesc( void) = 0; + +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) + virtual D3D12_COMPILER_TARGET STDMETHODCALLTYPE GetCompilerTarget( void) = 0; +#else + virtual D3D12_COMPILER_TARGET *STDMETHODCALLTYPE GetCompilerTarget( + D3D12_COMPILER_TARGET * RetVal) = 0; +#endif + + virtual D3D12_COMPILER_VALUE_TYPE_FLAGS STDMETHODCALLTYPE GetValueTypes( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE StoreGroupValueKeys( + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + UINT GroupVersion, + _In_reads_(NumValueKeys) const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKeys, + UINT NumValueKeys) = 0; + + virtual HRESULT STDMETHODCALLTYPE StoreValue( + _In_ const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKey, + _In_reads_(NumTypedValues) const D3D12_COMPILER_CACHE_TYPED_CONST_VALUE *pTypedValues, + UINT NumTypedValues) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12CompilerCacheSessionVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12CompilerCacheSession * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12CompilerCacheSession * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12CompilerCacheSession * This); + + DECLSPEC_XFGVIRT(ID3D12CompilerFactoryChild, GetFactory) + HRESULT ( STDMETHODCALLTYPE *GetFactory )( + ID3D12CompilerCacheSession * This, + _In_ REFIID riid, + _COM_Outptr_ void **ppCompilerFactory); + + DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, FindGroup) + HRESULT ( STDMETHODCALLTYPE *FindGroup )( + ID3D12CompilerCacheSession * This, + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + _Out_opt_ UINT *pGroupVersion); + + DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, FindGroupValueKeys) + HRESULT ( STDMETHODCALLTYPE *FindGroupValueKeys )( + ID3D12CompilerCacheSession * This, + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + _In_opt_ const UINT *pExpectedGroupVersion, + _In_ D3D12CompilerCacheSessionGroupValueKeysFunc CallbackFunc, + _Inout_opt_ void *pContext); + + DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, FindGroupValues) + HRESULT ( STDMETHODCALLTYPE *FindGroupValues )( + ID3D12CompilerCacheSession * This, + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + _In_opt_ const UINT *pExpectedGroupVersion, + D3D12_COMPILER_VALUE_TYPE_FLAGS ValueTypeFlags, + _In_opt_ D3D12CompilerCacheSessionGroupValuesFunc CallbackFunc, + _Inout_opt_ void *pContext); + + DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, FindValue) + HRESULT ( STDMETHODCALLTYPE *FindValue )( + ID3D12CompilerCacheSession * This, + _In_ const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKey, + _Inout_count_(NumTypedValues) D3D12_COMPILER_CACHE_TYPED_VALUE *pTypedValues, + UINT NumTypedValues, + _In_opt_ D3D12CompilerCacheSessionAllocationFunc pCallbackFunc, + _Inout_opt_ void *pContext); + + DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, GetApplicationDesc) + const D3D12_APPLICATION_DESC *( STDMETHODCALLTYPE *GetApplicationDesc )( + ID3D12CompilerCacheSession * This); + + DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, GetCompilerTarget) +#if !defined(_WIN32) + D3D12_COMPILER_TARGET ( STDMETHODCALLTYPE *GetCompilerTarget )( + ID3D12CompilerCacheSession * This); + +#else + D3D12_COMPILER_TARGET *( STDMETHODCALLTYPE *GetCompilerTarget )( + ID3D12CompilerCacheSession * This, + D3D12_COMPILER_TARGET * RetVal); + +#endif + + DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, GetValueTypes) + D3D12_COMPILER_VALUE_TYPE_FLAGS ( STDMETHODCALLTYPE *GetValueTypes )( + ID3D12CompilerCacheSession * This); + + DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, StoreGroupValueKeys) + HRESULT ( STDMETHODCALLTYPE *StoreGroupValueKeys )( + ID3D12CompilerCacheSession * This, + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + UINT GroupVersion, + _In_reads_(NumValueKeys) const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKeys, + UINT NumValueKeys); + + DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, StoreValue) + HRESULT ( STDMETHODCALLTYPE *StoreValue )( + ID3D12CompilerCacheSession * This, + _In_ const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKey, + _In_reads_(NumTypedValues) const D3D12_COMPILER_CACHE_TYPED_CONST_VALUE *pTypedValues, + UINT NumTypedValues); + + END_INTERFACE + } ID3D12CompilerCacheSessionVtbl; + + interface ID3D12CompilerCacheSession + { + CONST_VTBL struct ID3D12CompilerCacheSessionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12CompilerCacheSession_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12CompilerCacheSession_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12CompilerCacheSession_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12CompilerCacheSession_GetFactory(This,riid,ppCompilerFactory) \ + ( (This)->lpVtbl -> GetFactory(This,riid,ppCompilerFactory) ) + + +#define ID3D12CompilerCacheSession_FindGroup(This,pGroupKey,pGroupVersion) \ + ( (This)->lpVtbl -> FindGroup(This,pGroupKey,pGroupVersion) ) + +#define ID3D12CompilerCacheSession_FindGroupValueKeys(This,pGroupKey,pExpectedGroupVersion,CallbackFunc,pContext) \ + ( (This)->lpVtbl -> FindGroupValueKeys(This,pGroupKey,pExpectedGroupVersion,CallbackFunc,pContext) ) + +#define ID3D12CompilerCacheSession_FindGroupValues(This,pGroupKey,pExpectedGroupVersion,ValueTypeFlags,CallbackFunc,pContext) \ + ( (This)->lpVtbl -> FindGroupValues(This,pGroupKey,pExpectedGroupVersion,ValueTypeFlags,CallbackFunc,pContext) ) + +#define ID3D12CompilerCacheSession_FindValue(This,pValueKey,pTypedValues,NumTypedValues,pCallbackFunc,pContext) \ + ( (This)->lpVtbl -> FindValue(This,pValueKey,pTypedValues,NumTypedValues,pCallbackFunc,pContext) ) + +#define ID3D12CompilerCacheSession_GetApplicationDesc(This) \ + ( (This)->lpVtbl -> GetApplicationDesc(This) ) +#if !defined(_WIN32) + +#define ID3D12CompilerCacheSession_GetCompilerTarget(This) \ + ( (This)->lpVtbl -> GetCompilerTarget(This) ) +#else +#define ID3D12CompilerCacheSession_GetCompilerTarget(This,RetVal) \ + ( (This)->lpVtbl -> GetCompilerTarget(This,RetVal) ) +#endif + +#define ID3D12CompilerCacheSession_GetValueTypes(This) \ + ( (This)->lpVtbl -> GetValueTypes(This) ) + +#define ID3D12CompilerCacheSession_StoreGroupValueKeys(This,pGroupKey,GroupVersion,pValueKeys,NumValueKeys) \ + ( (This)->lpVtbl -> StoreGroupValueKeys(This,pGroupKey,GroupVersion,pValueKeys,NumValueKeys) ) + +#define ID3D12CompilerCacheSession_StoreValue(This,pValueKey,pTypedValues,NumTypedValues) \ + ( (This)->lpVtbl -> StoreValue(This,pValueKey,pTypedValues,NumTypedValues) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12CompilerCacheSession_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12CompilerStateObject_INTERFACE_DEFINED__ +#define __ID3D12CompilerStateObject_INTERFACE_DEFINED__ + +/* interface ID3D12CompilerStateObject */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12CompilerStateObject; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5981cca4-e8ae-44ca-9b92-4fa86f5a3a3a") + ID3D12CompilerStateObject : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetCompiler( + _In_ REFIID riid, + _COM_Outptr_ void **ppCompiler) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12CompilerStateObjectVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12CompilerStateObject * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12CompilerStateObject * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12CompilerStateObject * This); + + DECLSPEC_XFGVIRT(ID3D12CompilerStateObject, GetCompiler) + HRESULT ( STDMETHODCALLTYPE *GetCompiler )( + ID3D12CompilerStateObject * This, + _In_ REFIID riid, + _COM_Outptr_ void **ppCompiler); + + END_INTERFACE + } ID3D12CompilerStateObjectVtbl; + + interface ID3D12CompilerStateObject + { + CONST_VTBL struct ID3D12CompilerStateObjectVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12CompilerStateObject_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12CompilerStateObject_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12CompilerStateObject_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12CompilerStateObject_GetCompiler(This,riid,ppCompiler) \ + ( (This)->lpVtbl -> GetCompiler(This,riid,ppCompiler) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12CompilerStateObject_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12compiler_0000_0003 */ +/* [local] */ + +typedef struct D3D12_COMPILER_EXISTING_COLLECTION_DESC + { + ID3D12CompilerStateObject *pExistingCollection; + UINT NumExports; + _In_reads_(NumExports) const D3D12_EXPORT_DESC *pExports; + } D3D12_COMPILER_EXISTING_COLLECTION_DESC; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0003_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0003_v0_0_s_ifspec; + +#ifndef __ID3D12Compiler_INTERFACE_DEFINED__ +#define __ID3D12Compiler_INTERFACE_DEFINED__ + +/* interface ID3D12Compiler */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12Compiler; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8c403c12-993b-4583-80f1-6824138fa68e") + ID3D12Compiler : public ID3D12CompilerFactoryChild + { + public: + virtual HRESULT STDMETHODCALLTYPE CompilePipelineState( + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + UINT GroupVersion, + _In_ const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc) = 0; + + virtual HRESULT STDMETHODCALLTYPE CompileStateObject( + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + UINT GroupVersion, + _In_ const D3D12_STATE_OBJECT_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppCompilerStateObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE CompileAddToStateObject( + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + UINT GroupVersion, + _In_ const D3D12_STATE_OBJECT_DESC *pAddition, + _In_ ID3D12CompilerStateObject *pCompilerStateObjectToGrowFrom, + _In_ REFIID riid, + _COM_Outptr_ void **ppNewCompilerStateObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCacheSession( + _In_ REFIID riid, + _COM_Outptr_ void **ppCompilerCacheSession) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12CompilerVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12Compiler * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12Compiler * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12Compiler * This); + + DECLSPEC_XFGVIRT(ID3D12CompilerFactoryChild, GetFactory) + HRESULT ( STDMETHODCALLTYPE *GetFactory )( + ID3D12Compiler * This, + _In_ REFIID riid, + _COM_Outptr_ void **ppCompilerFactory); + + DECLSPEC_XFGVIRT(ID3D12Compiler, CompilePipelineState) + HRESULT ( STDMETHODCALLTYPE *CompilePipelineState )( + ID3D12Compiler * This, + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + UINT GroupVersion, + _In_ const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc); + + DECLSPEC_XFGVIRT(ID3D12Compiler, CompileStateObject) + HRESULT ( STDMETHODCALLTYPE *CompileStateObject )( + ID3D12Compiler * This, + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + UINT GroupVersion, + _In_ const D3D12_STATE_OBJECT_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppCompilerStateObject); + + DECLSPEC_XFGVIRT(ID3D12Compiler, CompileAddToStateObject) + HRESULT ( STDMETHODCALLTYPE *CompileAddToStateObject )( + ID3D12Compiler * This, + _In_ const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey, + UINT GroupVersion, + _In_ const D3D12_STATE_OBJECT_DESC *pAddition, + _In_ ID3D12CompilerStateObject *pCompilerStateObjectToGrowFrom, + _In_ REFIID riid, + _COM_Outptr_ void **ppNewCompilerStateObject); + + DECLSPEC_XFGVIRT(ID3D12Compiler, GetCacheSession) + HRESULT ( STDMETHODCALLTYPE *GetCacheSession )( + ID3D12Compiler * This, + _In_ REFIID riid, + _COM_Outptr_ void **ppCompilerCacheSession); + + END_INTERFACE + } ID3D12CompilerVtbl; + + interface ID3D12Compiler + { + CONST_VTBL struct ID3D12CompilerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12Compiler_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12Compiler_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12Compiler_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12Compiler_GetFactory(This,riid,ppCompilerFactory) \ + ( (This)->lpVtbl -> GetFactory(This,riid,ppCompilerFactory) ) + + +#define ID3D12Compiler_CompilePipelineState(This,pGroupKey,GroupVersion,pDesc) \ + ( (This)->lpVtbl -> CompilePipelineState(This,pGroupKey,GroupVersion,pDesc) ) + +#define ID3D12Compiler_CompileStateObject(This,pGroupKey,GroupVersion,pDesc,riid,ppCompilerStateObject) \ + ( (This)->lpVtbl -> CompileStateObject(This,pGroupKey,GroupVersion,pDesc,riid,ppCompilerStateObject) ) + +#define ID3D12Compiler_CompileAddToStateObject(This,pGroupKey,GroupVersion,pAddition,pCompilerStateObjectToGrowFrom,riid,ppNewCompilerStateObject) \ + ( (This)->lpVtbl -> CompileAddToStateObject(This,pGroupKey,GroupVersion,pAddition,pCompilerStateObjectToGrowFrom,riid,ppNewCompilerStateObject) ) + +#define ID3D12Compiler_GetCacheSession(This,riid,ppCompilerCacheSession) \ + ( (This)->lpVtbl -> GetCacheSession(This,riid,ppCompilerCacheSession) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12Compiler_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12CompilerFactory_INTERFACE_DEFINED__ +#define __ID3D12CompilerFactory_INTERFACE_DEFINED__ + +/* interface ID3D12CompilerFactory */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12CompilerFactory; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c1ee4b59-3f59-47a5-9b4e-a855c858a878") + ID3D12CompilerFactory : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE EnumerateAdapterFamilies( + UINT AdapterFamilyIndex, + _Out_ D3D12_ADAPTER_FAMILY *pAdapterFamily) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumerateAdapterFamilyABIVersions( + UINT AdapterFamilyIndex, + _Inout_ UINT32 *pNumABIVersions, + _Out_writes_opt_(*pNumABIVersions) UINT64 *pABIVersions) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumerateAdapterFamilyCompilerVersion( + UINT AdapterFamilyIndex, + _Out_ D3D12_VERSION_NUMBER *pCompilerVersion) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetApplicationProfileVersion( + _In_ const D3D12_COMPILER_TARGET *pTarget, + _In_ const D3D12_APPLICATION_DESC *pApplicationDesc, + _Out_ D3D12_VERSION_NUMBER *pApplicationProfileVersion) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateCompilerCacheSession( + _In_reads_(NumPaths) const D3D12_COMPILER_DATABASE_PATH *pPaths, + UINT NumPaths, + _In_opt_ const D3D12_COMPILER_TARGET *pTarget, + _In_opt_ const D3D12_APPLICATION_DESC *pApplicationDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppCompilerCacheSession) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateCompiler( + _In_ ID3D12CompilerCacheSession *pCompilerCacheSession, + _In_ REFIID riid, + _COM_Outptr_ void **ppCompiler) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12CompilerFactoryVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12CompilerFactory * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12CompilerFactory * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12CompilerFactory * This); + + DECLSPEC_XFGVIRT(ID3D12CompilerFactory, EnumerateAdapterFamilies) + HRESULT ( STDMETHODCALLTYPE *EnumerateAdapterFamilies )( + ID3D12CompilerFactory * This, + UINT AdapterFamilyIndex, + _Out_ D3D12_ADAPTER_FAMILY *pAdapterFamily); + + DECLSPEC_XFGVIRT(ID3D12CompilerFactory, EnumerateAdapterFamilyABIVersions) + HRESULT ( STDMETHODCALLTYPE *EnumerateAdapterFamilyABIVersions )( + ID3D12CompilerFactory * This, + UINT AdapterFamilyIndex, + _Inout_ UINT32 *pNumABIVersions, + _Out_writes_opt_(*pNumABIVersions) UINT64 *pABIVersions); + + DECLSPEC_XFGVIRT(ID3D12CompilerFactory, EnumerateAdapterFamilyCompilerVersion) + HRESULT ( STDMETHODCALLTYPE *EnumerateAdapterFamilyCompilerVersion )( + ID3D12CompilerFactory * This, + UINT AdapterFamilyIndex, + _Out_ D3D12_VERSION_NUMBER *pCompilerVersion); + + DECLSPEC_XFGVIRT(ID3D12CompilerFactory, GetApplicationProfileVersion) + HRESULT ( STDMETHODCALLTYPE *GetApplicationProfileVersion )( + ID3D12CompilerFactory * This, + _In_ const D3D12_COMPILER_TARGET *pTarget, + _In_ const D3D12_APPLICATION_DESC *pApplicationDesc, + _Out_ D3D12_VERSION_NUMBER *pApplicationProfileVersion); + + DECLSPEC_XFGVIRT(ID3D12CompilerFactory, CreateCompilerCacheSession) + HRESULT ( STDMETHODCALLTYPE *CreateCompilerCacheSession )( + ID3D12CompilerFactory * This, + _In_reads_(NumPaths) const D3D12_COMPILER_DATABASE_PATH *pPaths, + UINT NumPaths, + _In_opt_ const D3D12_COMPILER_TARGET *pTarget, + _In_opt_ const D3D12_APPLICATION_DESC *pApplicationDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppCompilerCacheSession); + + DECLSPEC_XFGVIRT(ID3D12CompilerFactory, CreateCompiler) + HRESULT ( STDMETHODCALLTYPE *CreateCompiler )( + ID3D12CompilerFactory * This, + _In_ ID3D12CompilerCacheSession *pCompilerCacheSession, + _In_ REFIID riid, + _COM_Outptr_ void **ppCompiler); + + END_INTERFACE + } ID3D12CompilerFactoryVtbl; + + interface ID3D12CompilerFactory + { + CONST_VTBL struct ID3D12CompilerFactoryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12CompilerFactory_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12CompilerFactory_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12CompilerFactory_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12CompilerFactory_EnumerateAdapterFamilies(This,AdapterFamilyIndex,pAdapterFamily) \ + ( (This)->lpVtbl -> EnumerateAdapterFamilies(This,AdapterFamilyIndex,pAdapterFamily) ) + +#define ID3D12CompilerFactory_EnumerateAdapterFamilyABIVersions(This,AdapterFamilyIndex,pNumABIVersions,pABIVersions) \ + ( (This)->lpVtbl -> EnumerateAdapterFamilyABIVersions(This,AdapterFamilyIndex,pNumABIVersions,pABIVersions) ) + +#define ID3D12CompilerFactory_EnumerateAdapterFamilyCompilerVersion(This,AdapterFamilyIndex,pCompilerVersion) \ + ( (This)->lpVtbl -> EnumerateAdapterFamilyCompilerVersion(This,AdapterFamilyIndex,pCompilerVersion) ) + +#define ID3D12CompilerFactory_GetApplicationProfileVersion(This,pTarget,pApplicationDesc,pApplicationProfileVersion) \ + ( (This)->lpVtbl -> GetApplicationProfileVersion(This,pTarget,pApplicationDesc,pApplicationProfileVersion) ) + +#define ID3D12CompilerFactory_CreateCompilerCacheSession(This,pPaths,NumPaths,pTarget,pApplicationDesc,riid,ppCompilerCacheSession) \ + ( (This)->lpVtbl -> CreateCompilerCacheSession(This,pPaths,NumPaths,pTarget,pApplicationDesc,riid,ppCompilerCacheSession) ) + +#define ID3D12CompilerFactory_CreateCompiler(This,pCompilerCacheSession,riid,ppCompiler) \ + ( (This)->lpVtbl -> CreateCompiler(This,pCompilerCacheSession,riid,ppCompiler) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12CompilerFactory_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12compiler_0000_0005 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ +#pragma endregion +DEFINE_GUID(IID_ID3D12CompilerFactoryChild,0xe0d06420,0x9f31,0x47e8,0xae,0x9a,0xdd,0x2b,0xa2,0x5a,0xc0,0xbc); +DEFINE_GUID(IID_ID3D12CompilerCacheSession,0x5704e5e6,0x054b,0x4738,0xb6,0x61,0x7b,0x0d,0x68,0xd8,0xdd,0xe2); +DEFINE_GUID(IID_ID3D12CompilerStateObject,0x5981cca4,0xe8ae,0x44ca,0x9b,0x92,0x4f,0xa8,0x6f,0x5a,0x3a,0x3a); +DEFINE_GUID(IID_ID3D12Compiler,0x8c403c12,0x993b,0x4583,0x80,0xf1,0x68,0x24,0x13,0x8f,0xa6,0x8e); +DEFINE_GUID(IID_ID3D12CompilerFactory,0xc1ee4b59,0x3f59,0x47a5,0x9b,0x4e,0xa8,0x55,0xc8,0x58,0xa8,0x78); + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0005_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0005_v0_0_s_ifspec; + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12sdklayers.h b/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12sdklayers.h index 8de3ef1..96c812b 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12sdklayers.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12sdklayers.h @@ -171,6 +171,13 @@ typedef interface ID3D12SharingContract ID3D12SharingContract; #endif /* __ID3D12SharingContract_FWD_DEFINED__ */ +#ifndef __ID3D12ManualWriteTrackingResource_FWD_DEFINED__ +#define __ID3D12ManualWriteTrackingResource_FWD_DEFINED__ +typedef interface ID3D12ManualWriteTrackingResource ID3D12ManualWriteTrackingResource; + +#endif /* __ID3D12ManualWriteTrackingResource_FWD_DEFINED__ */ + + #ifndef __ID3D12InfoQueue_FWD_DEFINED__ #define __ID3D12InfoQueue_FWD_DEFINED__ typedef interface ID3D12InfoQueue ID3D12InfoQueue; @@ -199,7 +206,7 @@ extern "C"{ /* [local] */ #include -//#pragma region App Family +#pragma region App Family #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) @@ -992,7 +999,8 @@ enum D3D12_DEBUG_DEVICE_PARAMETER_TYPE { D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS = 0, D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS = ( D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS + 1 ) , - D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR = ( D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS + 1 ) + D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR = ( D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS + 1 ) , + D3D12_DEBUG_DEVICE_PARAMETER_BYTECODE_VALIDATION_MODE = ( D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR + 1 ) } D3D12_DEBUG_DEVICE_PARAMETER_TYPE; typedef @@ -1039,6 +1047,15 @@ typedef struct D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR FLOAT SlowdownFactor; } D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR; +typedef +enum D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_MODE + { + D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_DISABLED = 0, + D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_WHEN_HASH_BYPASSED = ( D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_DISABLED + 1 ) , + D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_ALL_BYTECODE = ( D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_WHEN_HASH_BYPASSED + 1 ) , + D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_MODE_DEFAULT = D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_WHEN_HASH_BYPASSED + } D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_MODE; + extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0007_v0_0_c_ifspec; @@ -2237,7 +2254,92 @@ EXTERN_C const IID IID_ID3D12SharingContract; #endif /* __ID3D12SharingContract_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12sdklayers_0000_0017 */ +#ifndef __ID3D12ManualWriteTrackingResource_INTERFACE_DEFINED__ +#define __ID3D12ManualWriteTrackingResource_INTERFACE_DEFINED__ + +/* interface ID3D12ManualWriteTrackingResource */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12ManualWriteTrackingResource; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("86ca3b85-49ad-4b6e-aed5-eddb18540f41") + ID3D12ManualWriteTrackingResource : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE TrackWrite( + UINT Subresource, + _In_opt_ const D3D12_RANGE *pWrittenRange) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12ManualWriteTrackingResourceVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12ManualWriteTrackingResource * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12ManualWriteTrackingResource * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12ManualWriteTrackingResource * This); + + DECLSPEC_XFGVIRT(ID3D12ManualWriteTrackingResource, TrackWrite) + void ( STDMETHODCALLTYPE *TrackWrite )( + ID3D12ManualWriteTrackingResource * This, + UINT Subresource, + _In_opt_ const D3D12_RANGE *pWrittenRange); + + END_INTERFACE + } ID3D12ManualWriteTrackingResourceVtbl; + + interface ID3D12ManualWriteTrackingResource + { + CONST_VTBL struct ID3D12ManualWriteTrackingResourceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12ManualWriteTrackingResource_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12ManualWriteTrackingResource_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12ManualWriteTrackingResource_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12ManualWriteTrackingResource_TrackWrite(This,Subresource,pWrittenRange) \ + ( (This)->lpVtbl -> TrackWrite(This,Subresource,pWrittenRange) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12ManualWriteTrackingResource_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12sdklayers_0000_0018 */ /* [local] */ typedef @@ -2375,6 +2477,9 @@ enum D3D12_MESSAGE_ID D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA = 115, D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA = 116, D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK = 117, + D3D12_MESSAGE_ID_GET_PROGRAM_IDENTIFIER_ERROR = 118, + D3D12_MESSAGE_ID_GET_WORK_GRAPH_PROPERTIES_ERROR = 119, + D3D12_MESSAGE_ID_SET_PROGRAM_ERROR = 120, D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID = 135, D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET = 200, D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH = 201, @@ -3176,8 +3281,6 @@ enum D3D12_MESSAGE_ID D3D12_MESSAGE_ID_UNSUPPORTED_BARRIER_LAYOUT = 1341, D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALID_PARAMETERS = 1342, D3D12_MESSAGE_ID_ENHANCED_BARRIERS_NOT_SUPPORTED = 1343, - D3D12_MESSAGE_ID_CAST_TARGET_TEXEL_SIZE_MISMATCH = 1344, - D3D12_MESSAGE_ID_CAST_TO_PLANAR_NOT_SUPORTED = 1345, D3D12_MESSAGE_ID_LEGACY_BARRIER_VALIDATION_FORCED_ON = 1346, D3D12_MESSAGE_ID_EMPTY_ROOT_DESCRIPTOR_TABLE = 1347, D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ELEMENT_OFFSET_UNALIGNED = 1348, @@ -3191,10 +3294,76 @@ enum D3D12_MESSAGE_ID D3D12_MESSAGE_ID_NON_OPTIMAL_BARRIER_ONLY_EXECUTE_COMMAND_LISTS = 1356, D3D12_MESSAGE_ID_EXECUTE_INDIRECT_ZERO_COMMAND_COUNT = 1357, D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_TEXTURE_LAYOUT = 1358, - D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DYNAMIC_INDEX_BUFFER_STRIP_CUT_NOT_SUPPORTED = 1359, + D3D12_MESSAGE_ID_DYNAMIC_INDEX_BUFFER_STRIP_CUT_NOT_SUPPORTED = 1359, D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_TRIANGLE_FANS_NOT_SUPPORTED = 1360, D3D12_MESSAGE_ID_CREATE_SAMPLER_COMPARISON_FUNC_IGNORED = 1361, - D3D12_MESSAGE_ID_D3D12_MESSAGES_END = ( D3D12_MESSAGE_ID_CREATE_SAMPLER_COMPARISON_FUNC_IGNORED + 1 ) + D3D12_MESSAGE_ID_CREATEHEAP_INVALIDHEAPTYPE = 1362, + D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPTYPE = 1363, + D3D12_MESSAGE_ID_DYNAMIC_DEPTH_BIAS_NOT_SUPPORTED = 1364, + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_NON_WHOLE_DYNAMIC_DEPTH_BIAS = 1365, + D3D12_MESSAGE_ID_DYNAMIC_DEPTH_BIAS_FLAG_MISSING = 1366, + D3D12_MESSAGE_ID_DYNAMIC_DEPTH_BIAS_NO_PIPELINE = 1367, + D3D12_MESSAGE_ID_DYNAMIC_INDEX_BUFFER_STRIP_CUT_FLAG_MISSING = 1368, + D3D12_MESSAGE_ID_DYNAMIC_INDEX_BUFFER_STRIP_CUT_NO_PIPELINE = 1369, + D3D12_MESSAGE_ID_NONNORMALIZED_COORDINATE_SAMPLING_NOT_SUPPORTED = 1370, + D3D12_MESSAGE_ID_INVALID_CAST_TARGET = 1371, + D3D12_MESSAGE_ID_RENDER_PASS_COMMANDLIST_INVALID_END_STATE = 1372, + D3D12_MESSAGE_ID_RENDER_PASS_COMMANDLIST_INVALID_START_STATE = 1373, + D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_ACCESS = 1374, + D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_LOCAL_PRESERVE_PARAMETERS = 1375, + D3D12_MESSAGE_ID_RENDER_PASS_LOCAL_PRESERVE_RENDER_PARAMETERS_ERROR = 1376, + D3D12_MESSAGE_ID_RENDER_PASS_LOCAL_DEPTH_STENCIL_ERROR = 1377, + D3D12_MESSAGE_ID_DRAW_POTENTIALLY_OUTSIDE_OF_VALID_RENDER_AREA = 1378, + D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_LINERASTERIZATIONMODE = 1379, + D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT_SMALLRESOURCE = 1380, + D3D12_MESSAGE_ID_GENERIC_DEVICE_OPERATION_UNSUPPORTED = 1381, + D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RENDER_TARGET_WRONG_WRITE_MASK = 1382, + D3D12_MESSAGE_ID_PROBABLE_PIX_EVENT_LEAK = 1383, + D3D12_MESSAGE_ID_PIX_EVENT_UNDERFLOW = 1384, + D3D12_MESSAGE_ID_RECREATEAT_INVALID_TARGET = 1385, + D3D12_MESSAGE_ID_RECREATEAT_INSUFFICIENT_SUPPORT = 1386, + D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_STRUCTURED_BUFFER_STRIDE_MISMATCH = 1387, + D3D12_MESSAGE_ID_DISPATCH_GRAPH_INVALID = 1388, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_TARGET_FORMAT_INVALID = 1389, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_TARGET_DIMENSION_INVALID = 1390, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_SOURCE_COLOR_FORMAT_INVALID = 1391, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_SOURCE_DEPTH_FORMAT_INVALID = 1392, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXPOSURE_SCALE_FORMAT_INVALID = 1393, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_ENGINE_CREATE_FLAGS_INVALID = 1394, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXTENSION_INTERNAL_LOAD_FAILURE = 1395, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXTENSION_INTERNAL_ENGINE_CREATION_ERROR = 1396, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXTENSION_INTERNAL_UPSCALER_CREATION_ERROR = 1397, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXTENSION_INTERNAL_UPSCALER_EXECUTION_ERROR = 1398, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_REGION_INVALID = 1399, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_TIME_DELTA_INVALID = 1400, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_REQUIRED_TEXTURE_IS_NULL = 1401, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_MOTION_VECTORS_FORMAT_INVALID = 1402, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_FLAGS_INVALID = 1403, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_FORMAT_INVALID = 1404, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_EXPOSURE_SCALE_TEXTURE_SIZE_INVALID = 1405, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_VARIANT_INDEX_OUT_OF_BOUNDS = 1406, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_VARIANT_ID_NOT_FOUND = 1407, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_DUPLICATE_VARIANT_ID = 1408, + D3D12_MESSAGE_ID_DIRECTSR_OUT_OF_MEMORY = 1409, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_UNEXPECTED_TEXTURE_IS_IGNORED = 1410, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EVICT_UNDERFLOW = 1411, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_OPTIONAL_TEXTURE_IS_NULL = 1412, + D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_INVALID_CAMERA_JITTER = 1413, + D3D12_MESSAGE_ID_CREATE_STATE_OBJECT_WARNING = 1414, + D3D12_MESSAGE_ID_GUID_TEXTURE_LAYOUT_UNSUPPORTED = 1415, + D3D12_MESSAGE_ID_RESOLVE_ENCODER_INPUT_PARAM_LAYOUT_INVALID_PARAMETERS = 1416, + D3D12_MESSAGE_ID_INVALID_BARRIER_ACCESS = 1417, + D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INSTANCE_COUNT_ZERO = 1418, + D3D12_MESSAGE_ID_DESCRIPTOR_HEAP_NOT_SET_BEFORE_ROOT_SIGNATURE_WITH_DIRECTLY_INDEXED_FLAG = 1419, + D3D12_MESSAGE_ID_DIFFERENT_DESCRIPTOR_HEAP_SET_AFTER_ROOT_SIGNATURE_WITH_DIRECTLY_INDEXED_FLAG = 1420, + D3D12_MESSAGE_ID_APPLICATION_SPECIFIC_DRIVER_STATE_NOT_SUPPORTED = 1421, + D3D12_MESSAGE_ID_RENDER_TARGET_OR_DEPTH_STENCIL_RESOUCE_NOT_INITIALIZED = 1422, + D3D12_MESSAGE_ID_BYTECODE_VALIDATION_ERROR = 1423, + D3D12_MESSAGE_ID_FENCE_ZERO_WAIT = 1424, + D3D12_MESSAGE_ID_NON_COMMON_RESOURCE_IN_COPY_QUEUE = 1431, + D3D12_MESSAGE_ID_CREATEPIPELINESTATE_MULTIPLE_ROOT_SIGNATURES_DEFINED = 1435, + D3D12_MESSAGE_ID_TEXTURE_BARRIER_INVALID_FLAGS = 1436, + D3D12_MESSAGE_ID_D3D12_MESSAGES_END = 1442 } D3D12_MESSAGE_ID; typedef struct D3D12_MESSAGE @@ -3225,8 +3394,8 @@ typedef struct D3D12_INFO_QUEUE_FILTER #define D3D12_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT 1024 -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0017_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0017_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0018_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0018_v0_0_s_ifspec; #ifndef __ID3D12InfoQueue_INTERFACE_DEFINED__ #define __ID3D12InfoQueue_INTERFACE_DEFINED__ @@ -3671,7 +3840,7 @@ EXTERN_C const IID IID_ID3D12InfoQueue; #endif /* __ID3D12InfoQueue_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12sdklayers_0000_0018 */ +/* interface __MIDL_itf_d3d12sdklayers_0000_0019 */ /* [local] */ typedef @@ -3691,8 +3860,8 @@ typedef void ( __stdcall *D3D12MessageFunc )( -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0018_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0018_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0019_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0019_v0_0_s_ifspec; #ifndef __ID3D12InfoQueue1_INTERFACE_DEFINED__ #define __ID3D12InfoQueue1_INTERFACE_DEFINED__ @@ -3712,7 +3881,7 @@ EXTERN_C const IID IID_ID3D12InfoQueue1; virtual HRESULT STDMETHODCALLTYPE RegisterMessageCallback( _In_ D3D12MessageFunc CallbackFunc, _In_ D3D12_MESSAGE_CALLBACK_FLAGS CallbackFilterFlags, - _In_ void *pContext, + _Inout_ void *pContext, _Inout_ DWORD *pCallbackCookie) = 0; virtual HRESULT STDMETHODCALLTYPE UnregisterMessageCallback( @@ -3914,7 +4083,7 @@ EXTERN_C const IID IID_ID3D12InfoQueue1; ID3D12InfoQueue1 * This, _In_ D3D12MessageFunc CallbackFunc, _In_ D3D12_MESSAGE_CALLBACK_FLAGS CallbackFilterFlags, - _In_ void *pContext, + _Inout_ void *pContext, _Inout_ DWORD *pCallbackCookie); DECLSPEC_XFGVIRT(ID3D12InfoQueue1, UnregisterMessageCallback) @@ -4068,11 +4237,11 @@ EXTERN_C const IID IID_ID3D12InfoQueue1; #endif /* __ID3D12InfoQueue1_INTERFACE_DEFINED__ */ -/* interface __MIDL_itf_d3d12sdklayers_0000_0019 */ +/* interface __MIDL_itf_d3d12sdklayers_0000_0020 */ /* [local] */ #endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ -//#pragma endregion +#pragma endregion DEFINE_GUID(IID_ID3D12Debug,0x344488b7,0x6846,0x474b,0xb9,0x89,0xf0,0x27,0x44,0x82,0x45,0xe0); DEFINE_GUID(IID_ID3D12Debug1,0xaffaa4ca,0x63fe,0x4d8e,0xb8,0xad,0x15,0x90,0x00,0xaf,0x43,0x04); DEFINE_GUID(IID_ID3D12Debug2,0x93a665c4,0xa3b2,0x4e5d,0xb6,0x92,0xa2,0x6a,0xe1,0x4e,0x33,0x74); @@ -4090,12 +4259,13 @@ DEFINE_GUID(IID_ID3D12DebugCommandList,0x09e0bf36,0x54ac,0x484f,0x88,0x47,0x4b,0 DEFINE_GUID(IID_ID3D12DebugCommandList2,0xaeb575cf,0x4e06,0x48be,0xba,0x3b,0xc4,0x50,0xfc,0x96,0x65,0x2e); DEFINE_GUID(IID_ID3D12DebugCommandList3,0x197d5e15,0x4d37,0x4d34,0xaf,0x78,0x72,0x4c,0xd7,0x0f,0xdb,0x1f); DEFINE_GUID(IID_ID3D12SharingContract,0x0adf7d52,0x929c,0x4e61,0xad,0xdb,0xff,0xed,0x30,0xde,0x66,0xef); +DEFINE_GUID(IID_ID3D12ManualWriteTrackingResource,0x86ca3b85,0x49ad,0x4b6e,0xae,0xd5,0xed,0xdb,0x18,0x54,0x0f,0x41); DEFINE_GUID(IID_ID3D12InfoQueue,0x0742a90b,0xc387,0x483f,0xb9,0x46,0x30,0xa7,0xe4,0xe6,0x14,0x58); DEFINE_GUID(IID_ID3D12InfoQueue1,0x2852dd88,0xb484,0x4c0c,0xb6,0xb1,0x67,0x16,0x85,0x00,0xe6,0x00); -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0019_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0019_v0_0_s_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0020_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0020_v0_0_s_ifspec; /* Additional Prototypes for ALL interfaces */ diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12shader.h b/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12shader.h index 0acf584..56455b5 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12shader.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12shader.h @@ -37,6 +37,8 @@ typedef enum D3D12_SHADER_VERSION_TYPE D3D12_SHVER_MESH_SHADER = 13, D3D12_SHVER_AMPLIFICATION_SHADER = 14, + D3D12_SHVER_NODE_SHADER = 15, + D3D12_SHVER_RESERVED0 = 0xFFF0, } D3D12_SHADER_VERSION_TYPE; @@ -201,8 +203,10 @@ typedef struct _D3D12_SHADER_INPUT_BIND_DESC #define D3D_SHADER_REQUIRES_SAMPLER_DESCRIPTOR_HEAP_INDEXING 0x04000000 #define D3D_SHADER_REQUIRES_WAVE_MMA 0x08000000 #define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE 0x10000000 -#define D3D_SHADER_FEATURE_ADVANCED_TEXTURE_OPS 0x20000000 -#define D3D_SHADER_FEATURE_WRITEABLE_MSAA_TEXTURES 0x40000000 +#define D3D_SHADER_REQUIRES_ADVANCED_TEXTURE_OPS 0x20000000 +#define D3D_SHADER_REQUIRES_WRITEABLE_MSAA_TEXTURES 0x40000000 +#define D3D_SHADER_REQUIRES_SAMPLE_CMP_GRADIENT_OR_BIAS 0x80000000 +#define D3D_SHADER_REQUIRES_EXTENDED_COMMAND_INFO 0x100000000ull typedef struct _D3D12_LIBRARY_DESC @@ -488,3 +492,4 @@ extern "C" { #endif //__D3D12SHADER_H__ + diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12video.h b/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12video.h index add372e..2f19246 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12video.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/d3d12video.h @@ -241,6 +241,27 @@ typedef interface ID3D12VideoEncodeCommandList3 ID3D12VideoEncodeCommandList3; #endif /* __ID3D12VideoEncodeCommandList3_FWD_DEFINED__ */ +#ifndef __ID3D12VideoEncoderHeap1_FWD_DEFINED__ +#define __ID3D12VideoEncoderHeap1_FWD_DEFINED__ +typedef interface ID3D12VideoEncoderHeap1 ID3D12VideoEncoderHeap1; + +#endif /* __ID3D12VideoEncoderHeap1_FWD_DEFINED__ */ + + +#ifndef __ID3D12VideoDevice4_FWD_DEFINED__ +#define __ID3D12VideoDevice4_FWD_DEFINED__ +typedef interface ID3D12VideoDevice4 ID3D12VideoDevice4; + +#endif /* __ID3D12VideoDevice4_FWD_DEFINED__ */ + + +#ifndef __ID3D12VideoEncodeCommandList4_FWD_DEFINED__ +#define __ID3D12VideoEncodeCommandList4_FWD_DEFINED__ +typedef interface ID3D12VideoEncodeCommandList4 ID3D12VideoEncodeCommandList4; + +#endif /* __ID3D12VideoEncodeCommandList4_FWD_DEFINED__ */ + + /* header files for imported files */ #include "oaidl.h" #include "ocidl.h" @@ -338,7 +359,17 @@ enum D3D12_FEATURE_VIDEO D3D12_FEATURE_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT = 42, D3D12_FEATURE_VIDEO_ENCODER_SUPPORT = 43, D3D12_FEATURE_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT = 44, - D3D12_FEATURE_VIDEO_ENCODER_RESOURCE_REQUIREMENTS = 45 + D3D12_FEATURE_VIDEO_ENCODER_RESOURCE_REQUIREMENTS = 45, + D3D12_FEATURE_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_CONFIG = 46, + D3D12_FEATURE_VIDEO_ENCODER_SUPPORT1 = 47, + D3D12_FEATURE_VIDEO_ENCODER_RESOURCE_REQUIREMENTS1 = 48, + D3D12_FEATURE_VIDEO_ENCODER_RESOLVE_INPUT_PARAM_LAYOUT = 49, + D3D12_FEATURE_VIDEO_ENCODER_QPMAP_INPUT = 50, + D3D12_FEATURE_VIDEO_ENCODER_DIRTY_REGIONS = 51, + D3D12_FEATURE_VIDEO_ENCODER_MOTION_SEARCH = 52, + D3D12_FEATURE_VIDEO_ENCODER_SUPPORT2 = 55, + D3D12_FEATURE_VIDEO_ENCODER_HEAP_SIZE1 = 56, + D3D12_FEATURE_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS = 57 } D3D12_FEATURE_VIDEO; typedef @@ -407,7 +438,7 @@ enum D3D12_VIDEO_PROCESS_FILTER_FLAGS D3D12_VIDEO_PROCESS_FILTER_FLAG_STEREO_ADJUSTMENT = ( 1 << D3D12_VIDEO_PROCESS_FILTER_STEREO_ADJUSTMENT ) } D3D12_VIDEO_PROCESS_FILTER_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FILTER_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FILTER_FLAGS ) typedef enum D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS { @@ -416,7 +447,7 @@ enum D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_CUSTOM = 0x80000000 } D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS ) typedef struct D3D12_VIDEO_PROCESS_ALPHA_BLENDING { BOOL Enable; @@ -491,7 +522,7 @@ EXTERN_C const IID IID_ID3D12VideoDecoderHeap; ID3D12VideoDecoderHeap : public ID3D12Pageable { public: -#if defined(_MSC_VER) || !defined(_WIN32) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual D3D12_VIDEO_DECODER_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0; #else virtual D3D12_VIDEO_DECODER_HEAP_DESC *STDMETHODCALLTYPE GetDesc( @@ -777,7 +808,7 @@ EXTERN_C const IID IID_ID3D12VideoDecoder; ID3D12VideoDecoder : public ID3D12Pageable { public: -#if defined(_MSC_VER) || !defined(_WIN32) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual D3D12_VIDEO_DECODER_DESC STDMETHODCALLTYPE GetDesc( void) = 0; #else virtual D3D12_VIDEO_DECODER_DESC *STDMETHODCALLTYPE GetDesc( @@ -929,7 +960,7 @@ enum D3D12_VIDEO_DECODE_SUPPORT_FLAGS D3D12_VIDEO_DECODE_SUPPORT_FLAG_SUPPORTED = 0x1 } D3D12_VIDEO_DECODE_SUPPORT_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_SUPPORT_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_SUPPORT_FLAGS ) typedef enum D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS { @@ -940,7 +971,7 @@ enum D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_ALLOW_RESOLUTION_CHANGE_ON_NON_KEY_FRAME = 0x8 } D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS ) typedef enum D3D12_VIDEO_DECODE_STATUS { @@ -957,7 +988,7 @@ enum D3D12_VIDEO_DECODE_ARGUMENT_TYPE D3D12_VIDEO_DECODE_ARGUMENT_TYPE_PICTURE_PARAMETERS = 0, D3D12_VIDEO_DECODE_ARGUMENT_TYPE_INVERSE_QUANTIZATION_MATRIX = 1, D3D12_VIDEO_DECODE_ARGUMENT_TYPE_SLICE_CONTROL = 2, - D3D12_VIDEO_DECODE_ARGUMENT_TYPE_MAX_VALID = 3 + D3D12_VIDEO_DECODE_ARGUMENT_TYPE_HUFFMAN_TABLE = 3 } D3D12_VIDEO_DECODE_ARGUMENT_TYPE; typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT @@ -1032,7 +1063,7 @@ enum D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_A = ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_A ) } D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS ) typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM { UINT NodeIndex; @@ -1052,16 +1083,17 @@ enum D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAG_SUPPORTED = 0x1 } D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS ) typedef enum D3D12_VIDEO_SCALE_SUPPORT_FLAGS { D3D12_VIDEO_SCALE_SUPPORT_FLAG_NONE = 0, D3D12_VIDEO_SCALE_SUPPORT_FLAG_POW2_ONLY = 0x1, - D3D12_VIDEO_SCALE_SUPPORT_FLAG_EVEN_DIMENSIONS_ONLY = 0x2 + D3D12_VIDEO_SCALE_SUPPORT_FLAG_EVEN_DIMENSIONS_ONLY = 0x2, + D3D12_VIDEO_SCALE_SUPPORT_FLAG_DPB_ENCODER_RESOURCES = 0x4 } D3D12_VIDEO_SCALE_SUPPORT_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_SCALE_SUPPORT_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_SCALE_SUPPORT_FLAGS ) typedef struct D3D12_VIDEO_SCALE_SUPPORT { D3D12_VIDEO_SIZE_RANGE OutputSizeRange; @@ -1180,7 +1212,7 @@ EXTERN_C const IID IID_ID3D12VideoProcessor; UINT NumInputStreamDescs, _Out_writes_(NumInputStreamDescs) D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs) = 0; -#if defined(_MSC_VER) || !defined(_WIN32) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC STDMETHODCALLTYPE GetOutputStreamDesc( void) = 0; #else virtual D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *STDMETHODCALLTYPE GetOutputStreamDesc( @@ -1352,7 +1384,7 @@ enum D3D12_VIDEO_PROCESS_FEATURE_FLAGS D3D12_VIDEO_PROCESS_FEATURE_FLAG_PIXEL_ASPECT_RATIO = 0x40 } D3D12_VIDEO_PROCESS_FEATURE_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FEATURE_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FEATURE_FLAGS ) typedef enum D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS { @@ -1368,7 +1400,7 @@ enum D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_CUSTOM = 0x80000000 } D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS ) typedef enum D3D12_VIDEO_PROCESS_ORIENTATION { @@ -1390,7 +1422,7 @@ enum D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_FRAME_REPEAT = 0x2 } D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS ) typedef struct D3D12_VIDEO_PROCESS_FILTER_RANGE { INT Minimum; @@ -1406,7 +1438,7 @@ enum D3D12_VIDEO_PROCESS_SUPPORT_FLAGS D3D12_VIDEO_PROCESS_SUPPORT_FLAG_SUPPORTED = 0x1 } D3D12_VIDEO_PROCESS_SUPPORT_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_SUPPORT_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_SUPPORT_FLAGS ) typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT { UINT NodeIndex; @@ -2761,7 +2793,7 @@ enum D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_16X16 = ( 1 << D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_16X16 ) } D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS ) typedef enum D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION { @@ -2775,7 +2807,7 @@ enum D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAG_QUARTER_PEL = ( 1 << D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_QUARTER_PEL ) } D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS ) typedef struct D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT { UINT NodeIndex; @@ -2836,7 +2868,7 @@ EXTERN_C const IID IID_ID3D12VideoMotionEstimator; ID3D12VideoMotionEstimator : public ID3D12Pageable { public: -#if defined(_MSC_VER) || !defined(_WIN32) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual D3D12_VIDEO_MOTION_ESTIMATOR_DESC STDMETHODCALLTYPE GetDesc( void) = 0; #else virtual D3D12_VIDEO_MOTION_ESTIMATOR_DESC *STDMETHODCALLTYPE GetDesc( @@ -3014,7 +3046,7 @@ EXTERN_C const IID IID_ID3D12VideoMotionVectorHeap; ID3D12VideoMotionVectorHeap : public ID3D12Pageable { public: -#if defined(_MSC_VER) || !defined(_WIN32) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0; #else virtual D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *STDMETHODCALLTYPE GetDesc( @@ -3705,7 +3737,7 @@ enum D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAG_SUPPORTED = 0x1 } D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS ) typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES { UINT NodeIndex; @@ -3780,7 +3812,7 @@ enum D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAG_WRITE = 0x2 } D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS ); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS ) typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT { UINT NodeIndex; @@ -4358,7 +4390,7 @@ EXTERN_C const IID IID_ID3D12VideoExtensionCommand; ID3D12VideoExtensionCommand : public ID3D12Pageable { public: -#if defined(_MSC_VER) || !defined(_WIN32) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) virtual D3D12_VIDEO_EXTENSION_COMMAND_DESC STDMETHODCALLTYPE GetDesc( void) = 0; #else virtual D3D12_VIDEO_EXTENSION_COMMAND_DESC *STDMETHODCALLTYPE GetDesc( @@ -6311,6 +6343,16 @@ DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG4PT2_SIMPLE, 0xefd64d74, 0xc9e8,0x41d DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG4PT2_ADVSIMPLE_NOGMC, 0xed418a9f, 0x010d, 0x4eda, 0x9a, 0xe3, 0x9a, 0x65, 0x35, 0x8d, 0x8d, 0x2e); DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN, 0x5b11d51b, 0x2f4c, 0x4452, 0xbc, 0xc3, 0x09, 0xf2, 0xa1, 0x16, 0x0c, 0xc0); DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN10, 0x107af0e0, 0xef1a, 0x4d19, 0xab, 0xa8, 0x67, 0xa1, 0x63, 0x07, 0x3d, 0x13); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MONOCHROME, 0x0685b993, 0x3d8c, 0x43a0, 0x8b, 0x28, 0xd7, 0x4c, 0x2d, 0x68, 0x99, 0xa4); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MONOCHROME10, 0x142a1d0f, 0x69dd, 0x4ec9, 0x85, 0x91, 0xb1, 0x2f, 0xfc, 0xb9, 0x1a, 0x29); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN12, 0x1a72925f, 0x0c2c, 0x4f15, 0x96, 0xfb, 0xb1, 0x7d, 0x14, 0x73, 0x60, 0x3f); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN10_422, 0x0bac4fe5, 0x1532, 0x4429, 0xa8, 0x54, 0xf8, 0x4d, 0xe0, 0x49, 0x53, 0xdb); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN12_422, 0x55bcac81, 0xf311, 0x4093, 0xa7, 0xd0, 0x1c, 0xbc, 0x0b, 0x84, 0x9b, 0xee); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN_444, 0x4008018f, 0xf537, 0x4b36, 0x98, 0xcf, 0x61, 0xaf, 0x8a, 0x2c, 0x1a, 0x33); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN10_EXT, 0x9cc55490, 0xe37c, 0x4932, 0x86, 0x84, 0x49, 0x20, 0xf9, 0xf6, 0x40, 0x9c); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN10_444, 0x0dabeffa, 0x4458, 0x4602, 0xbc, 0x03, 0x07, 0x95, 0x65, 0x9d, 0x61, 0x7c); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN12_444, 0x9798634d, 0xfe9d, 0x48e5, 0xb4, 0xda, 0xdb, 0xec, 0x45, 0xb3, 0xdf, 0x01); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN16, 0xa4fbdbb0, 0xa113, 0x482b, 0xa2, 0x32, 0x63, 0x5c, 0xc0, 0x69, 0x7f, 0x6d); DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP9, 0x463707f8, 0xa1d0, 0x4585, 0x87, 0x6d, 0x83, 0xaa, 0x6d, 0x60, 0xb8, 0x9e); DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP9_10BIT_PROFILE2, 0xa4c749ef, 0x6ecf, 0x48aa, 0x84, 0x48, 0x50, 0xa7, 0xa1, 0x16, 0x5f, 0xf7); DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP8, 0x90b899ea, 0x3a62, 0x4705, 0x88, 0xb3, 0x8d, 0xf0, 0x4b, 0x27, 0x44, 0xe7); @@ -6319,6 +6361,470 @@ DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE1, 0x6936ff0f, 0x45b1, 0x4163, DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE2, 0x0c5f2aa1, 0xe541, 0x4089, 0xbb, 0x7b, 0x98, 0x11, 0x0a, 0x19, 0xd7, 0xc8); DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_12BIT_PROFILE2, 0x17127009, 0xa00f, 0x4ce1, 0x99, 0x4e, 0xbf, 0x40, 0x81, 0xf6, 0xf3, 0xf0); DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_12BIT_PROFILE2_420, 0x2d80bed6, 0x9cac, 0x4835, 0x9e, 0x91, 0x32, 0x7b, 0xbc, 0x4f, 0x9e, 0xe8); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MJPEG_VLD_420, 0x725cb506, 0xc29, 0x43c4, 0x94, 0x40, 0x8e, 0x93, 0x97, 0x90, 0x3a, 0x4); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MJPEG_VLD_422, 0x5b77b9cd, 0x1a35, 0x4c30, 0x9f, 0xd8, 0xef, 0x4b, 0x60, 0xc0, 0x35, 0xdd); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MJPEG_VLD_444, 0xd95161f9, 0xd44, 0x47e6, 0xbc, 0xf5, 0x1b, 0xfb, 0xfb, 0x26, 0x8f, 0x97); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MJPEG_VLD_4444, 0xc91748d5, 0xfd18, 0x4aca, 0x9d, 0xb3, 0x3a, 0x66, 0x34, 0xab, 0x54, 0x7d); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_JPEG_VLD_420, 0xcf782c83, 0xbef5, 0x4a2c, 0x87, 0xcb, 0x60, 0x19, 0xe7, 0xb1, 0x75, 0xac); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_JPEG_VLD_422, 0xf04df417, 0xeee2, 0x4067, 0xa7, 0x78, 0xf3, 0x5c, 0x15, 0xab, 0x97, 0x21); +DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_JPEG_VLD_444, 0x4cd00e17, 0x89ba, 0x48ef, 0xb9, 0xf9, 0xed, 0xcb, 0x82, 0x71, 0x3f, 0x65); +typedef +enum D3D12_VIDEO_ENCODER_AV1_PROFILE + { + D3D12_VIDEO_ENCODER_AV1_PROFILE_MAIN = 0, + D3D12_VIDEO_ENCODER_AV1_PROFILE_HIGH = 1, + D3D12_VIDEO_ENCODER_AV1_PROFILE_PROFESSIONAL = 2 + } D3D12_VIDEO_ENCODER_AV1_PROFILE; + +typedef +enum D3D12_VIDEO_ENCODER_AV1_LEVELS + { + D3D12_VIDEO_ENCODER_AV1_LEVELS_2_0 = 0, + D3D12_VIDEO_ENCODER_AV1_LEVELS_2_1 = 1, + D3D12_VIDEO_ENCODER_AV1_LEVELS_2_2 = 2, + D3D12_VIDEO_ENCODER_AV1_LEVELS_2_3 = 3, + D3D12_VIDEO_ENCODER_AV1_LEVELS_3_0 = 4, + D3D12_VIDEO_ENCODER_AV1_LEVELS_3_1 = 5, + D3D12_VIDEO_ENCODER_AV1_LEVELS_3_2 = 6, + D3D12_VIDEO_ENCODER_AV1_LEVELS_3_3 = 7, + D3D12_VIDEO_ENCODER_AV1_LEVELS_4_0 = 8, + D3D12_VIDEO_ENCODER_AV1_LEVELS_4_1 = 9, + D3D12_VIDEO_ENCODER_AV1_LEVELS_4_2 = 10, + D3D12_VIDEO_ENCODER_AV1_LEVELS_4_3 = 11, + D3D12_VIDEO_ENCODER_AV1_LEVELS_5_0 = 12, + D3D12_VIDEO_ENCODER_AV1_LEVELS_5_1 = 13, + D3D12_VIDEO_ENCODER_AV1_LEVELS_5_2 = 14, + D3D12_VIDEO_ENCODER_AV1_LEVELS_5_3 = 15, + D3D12_VIDEO_ENCODER_AV1_LEVELS_6_0 = 16, + D3D12_VIDEO_ENCODER_AV1_LEVELS_6_1 = 17, + D3D12_VIDEO_ENCODER_AV1_LEVELS_6_2 = 18, + D3D12_VIDEO_ENCODER_AV1_LEVELS_6_3 = 19, + D3D12_VIDEO_ENCODER_AV1_LEVELS_7_0 = 20, + D3D12_VIDEO_ENCODER_AV1_LEVELS_7_1 = 21, + D3D12_VIDEO_ENCODER_AV1_LEVELS_7_2 = 22, + D3D12_VIDEO_ENCODER_AV1_LEVELS_7_3 = 23 + } D3D12_VIDEO_ENCODER_AV1_LEVELS; + +typedef +enum D3D12_VIDEO_ENCODER_AV1_TIER + { + D3D12_VIDEO_ENCODER_AV1_TIER_MAIN = 0, + D3D12_VIDEO_ENCODER_AV1_TIER_HIGH = 1 + } D3D12_VIDEO_ENCODER_AV1_TIER; + +typedef struct D3D12_VIDEO_ENCODER_AV1_LEVEL_TIER_CONSTRAINTS + { + D3D12_VIDEO_ENCODER_AV1_LEVELS Level; + D3D12_VIDEO_ENCODER_AV1_TIER Tier; + } D3D12_VIDEO_ENCODER_AV1_LEVEL_TIER_CONSTRAINTS; + +typedef +enum D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAGS + { + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_128x128_SUPERBLOCK = 0x1, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_FILTER_INTRA = 0x2, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_INTRA_EDGE_FILTER = 0x4, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_INTERINTRA_COMPOUND = 0x8, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_MASKED_COMPOUND = 0x10, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_WARPED_MOTION = 0x20, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_DUAL_FILTER = 0x40, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_JNT_COMP = 0x80, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_FORCED_INTEGER_MOTION_VECTORS = 0x100, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_SUPER_RESOLUTION = 0x200, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_LOOP_RESTORATION_FILTER = 0x400, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_PALETTE_ENCODING = 0x800, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_CDEF_FILTERING = 0x1000, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_INTRA_BLOCK_COPY = 0x2000, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_FRAME_REFERENCE_MOTION_VECTORS = 0x4000, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_ORDER_HINT_TOOLS = 0x8000, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_AUTO_SEGMENTATION = 0x10000, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_CUSTOM_SEGMENTATION = 0x20000, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_LOOP_FILTER_DELTAS = 0x40000, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_QUANTIZATION_DELTAS = 0x80000, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_QUANTIZATION_MATRIX = 0x100000, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_REDUCED_TX_SET = 0x200000, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_MOTION_MODE_SWITCHABLE = 0x400000, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_ALLOW_HIGH_PRECISION_MV = 0x800000, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_SKIP_MODE_PRESENT = 0x1000000, + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAG_DELTA_LF_PARAMS = 0x2000000 + } D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAGS) +typedef +enum D3D12_VIDEO_ENCODER_AV1_TX_MODE + { + D3D12_VIDEO_ENCODER_AV1_TX_MODE_ONLY4x4 = 0, + D3D12_VIDEO_ENCODER_AV1_TX_MODE_LARGEST = 1, + D3D12_VIDEO_ENCODER_AV1_TX_MODE_SELECT = 2 + } D3D12_VIDEO_ENCODER_AV1_TX_MODE; + +typedef +enum D3D12_VIDEO_ENCODER_AV1_TX_MODE_FLAGS + { + D3D12_VIDEO_ENCODER_AV1_TX_MODE_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_AV1_TX_MODE_FLAG_ONLY4x4 = ( 1 << D3D12_VIDEO_ENCODER_AV1_TX_MODE_ONLY4x4 ) , + D3D12_VIDEO_ENCODER_AV1_TX_MODE_FLAG_LARGEST = ( 1 << D3D12_VIDEO_ENCODER_AV1_TX_MODE_LARGEST ) , + D3D12_VIDEO_ENCODER_AV1_TX_MODE_FLAG_SELECT = ( 1 << D3D12_VIDEO_ENCODER_AV1_TX_MODE_SELECT ) + } D3D12_VIDEO_ENCODER_AV1_TX_MODE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_TX_MODE_FLAGS) +typedef +enum D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS + { + D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_EIGHTTAP = 0, + D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_EIGHTTAP_SMOOTH = 1, + D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_EIGHTTAP_SHARP = 2, + D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_BILINEAR = 3, + D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_SWITCHABLE = 4 + } D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS; + +typedef +enum D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAGS + { + D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAG_EIGHTTAP = ( 1 << D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_EIGHTTAP ) , + D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAG_EIGHTTAP_SMOOTH = ( 1 << D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_EIGHTTAP_SMOOTH ) , + D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAG_EIGHTTAP_SHARP = ( 1 << D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_EIGHTTAP_SHARP ) , + D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAG_BILINEAR = ( 1 << D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_BILINEAR ) , + D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAG_SWITCHABLE = ( 1 << D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_SWITCHABLE ) + } D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAGS) +typedef +enum D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_BLOCK_SIZE + { + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_BLOCK_SIZE_4x4 = 0, + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_BLOCK_SIZE_8x8 = 1, + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_BLOCK_SIZE_16x16 = 2, + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_BLOCK_SIZE_32x32 = 3, + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_BLOCK_SIZE_64x64 = 4 + } D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_BLOCK_SIZE; + +typedef +enum D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE + { + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_DISABLED = 0, + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_Q = 1, + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_LF_Y_V = 2, + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_LF_Y_H = 3, + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_LF_U = 4, + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_LF_V = 5, + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_REF_FRAME = 6, + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_SKIP = 7, + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_GLOBALMV = 8 + } D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE; + +typedef +enum D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAGS + { + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAG_DISABLED = ( 1 << D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_DISABLED ) , + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAG_ALT_Q = ( 1 << D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_Q ) , + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAG_ALT_LF_Y_V = ( 1 << D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_LF_Y_V ) , + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAG_ALT_LF_Y_H = ( 1 << D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_LF_Y_H ) , + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAG_ALT_LF_U = ( 1 << D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_LF_U ) , + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAG_ALT_LF_V = ( 1 << D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_LF_V ) , + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAG_REF_FRAME = ( 1 << D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_REF_FRAME ) , + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAG_ALT_SKIP = ( 1 << D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_SKIP ) , + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAG_ALT_GLOBALMV = ( 1 << D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_ALT_GLOBALMV ) + } D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAGS) +typedef +enum D3D12_VIDEO_ENCODER_AV1_RESTORATION_TYPE + { + D3D12_VIDEO_ENCODER_AV1_RESTORATION_TYPE_DISABLED = 0, + D3D12_VIDEO_ENCODER_AV1_RESTORATION_TYPE_SWITCHABLE = 1, + D3D12_VIDEO_ENCODER_AV1_RESTORATION_TYPE_WIENER = 2, + D3D12_VIDEO_ENCODER_AV1_RESTORATION_TYPE_SGRPROJ = 3 + } D3D12_VIDEO_ENCODER_AV1_RESTORATION_TYPE; + +typedef +enum D3D12_VIDEO_ENCODER_AV1_RESTORATION_TILESIZE + { + D3D12_VIDEO_ENCODER_AV1_RESTORATION_TILESIZE_DISABLED = 0, + D3D12_VIDEO_ENCODER_AV1_RESTORATION_TILESIZE_32x32 = 1, + D3D12_VIDEO_ENCODER_AV1_RESTORATION_TILESIZE_64x64 = 2, + D3D12_VIDEO_ENCODER_AV1_RESTORATION_TILESIZE_128x128 = 3, + D3D12_VIDEO_ENCODER_AV1_RESTORATION_TILESIZE_256x256 = 4 + } D3D12_VIDEO_ENCODER_AV1_RESTORATION_TILESIZE; + +typedef +enum D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAGS + { + D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAG_NOT_SUPPORTED = 0, + D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAG_32x32 = 0x1, + D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAG_64x64 = 0x2, + D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAG_128x128 = 0x4, + D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAG_256x256 = 0x8 + } D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAGS) +typedef +enum D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION + { + D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_IDENTITY = 0, + D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_TRANSLATION = 1, + D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_ROTZOOM = 2, + D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_AFFINE = 3 + } D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION; + +typedef +enum D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAGS + { + D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAG_IDENTITY = ( 1 << D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_IDENTITY ) , + D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAG_TRANSLATION = ( 1 << D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_TRANSLATION ) , + D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAG_ROTZOOM = ( 1 << D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_ROTZOOM ) , + D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAG_AFFINE = ( 1 << D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_AFFINE ) + } D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAGS) +typedef +enum D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAGS + { + D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_QUANTIZATION = 0x1, + D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_QUANTIZATION_DELTA = 0x2, + D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_LOOP_FILTER = 0x4, + D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_LOOP_FILTER_DELTA = 0x8, + D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_CDEF_DATA = 0x10, + D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_CONTEXT_UPDATE_TILE_ID = 0x20, + D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_COMPOUND_PREDICTION_MODE = 0x40, + D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_PRIMARY_REF_FRAME = 0x80, + D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAG_REFERENCE_INDICES = 0x100 + } D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAGS) +typedef struct D3D12_VIDEO_ENCODER_AV1_CODEC_CONFIGURATION_SUPPORT + { + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAGS SupportedFeatureFlags; + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAGS RequiredFeatureFlags; + D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS_FLAGS SupportedInterpolationFilters; + D3D12_VIDEO_ENCODER_AV1_RESTORATION_SUPPORT_FLAGS SupportedRestorationParams[ 3 ][ 3 ]; + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MODE_FLAGS SupportedSegmentationModes; + D3D12_VIDEO_ENCODER_AV1_TX_MODE_FLAGS SupportedTxModes[ 4 ]; + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_BLOCK_SIZE SegmentationBlockSize; + D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES_FLAGS PostEncodeValuesFlags; + UINT MaxTemporalLayers; + UINT MaxSpatialLayers; + } D3D12_VIDEO_ENCODER_AV1_CODEC_CONFIGURATION_SUPPORT; + +typedef +enum D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE + { + D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_KEY_FRAME = 0, + D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_INTER_FRAME = 1, + D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_INTRA_ONLY_FRAME = 2, + D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_SWITCH_FRAME = 3 + } D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE; + +typedef +enum D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAGS + { + D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAG_KEY_FRAME = ( 1 << D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_KEY_FRAME ) , + D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAG_INTER_FRAME = ( 1 << D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_INTER_FRAME ) , + D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAG_INTRA_ONLY_FRAME = ( 1 << D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_INTRA_ONLY_FRAME ) , + D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAG_SWITCH_FRAME = ( 1 << D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_SWITCH_FRAME ) + } D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAGS) +typedef +enum D3D12_VIDEO_ENCODER_AV1_COMP_PREDICTION_TYPE + { + D3D12_VIDEO_ENCODER_AV1_COMP_PREDICTION_TYPE_SINGLE_REFERENCE = 0, + D3D12_VIDEO_ENCODER_AV1_COMP_PREDICTION_TYPE_COMPOUND_REFERENCE = 1 + } D3D12_VIDEO_ENCODER_AV1_COMP_PREDICTION_TYPE; + +typedef struct D3D12_VIDEO_ENCODER_CODEC_AV1_PICTURE_CONTROL_SUPPORT + { + D3D12_VIDEO_ENCODER_AV1_COMP_PREDICTION_TYPE PredictionMode; + UINT MaxUniqueReferencesPerFrame; + D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE_FLAGS SupportedFrameTypes; + D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION_FLAGS SupportedReferenceWarpedMotionFlags; + } D3D12_VIDEO_ENCODER_CODEC_AV1_PICTURE_CONTROL_SUPPORT; + +typedef struct D3D12_VIDEO_ENCODER_AV1_CODEC_CONFIGURATION + { + D3D12_VIDEO_ENCODER_AV1_FEATURE_FLAGS FeatureFlags; + UINT OrderHintBitsMinus1; + } D3D12_VIDEO_ENCODER_AV1_CODEC_CONFIGURATION; + +typedef struct D3D12_VIDEO_ENCODER_AV1_SEQUENCE_STRUCTURE + { + UINT IntraDistance; + UINT InterFramePeriod; + } D3D12_VIDEO_ENCODER_AV1_SEQUENCE_STRUCTURE; + +typedef struct D3D12_VIDEO_ENCODER_AV1_REFERENCE_PICTURE_WARPED_MOTION_INFO + { + D3D12_VIDEO_ENCODER_AV1_REFERENCE_WARPED_MOTION_TRANSFORMATION TransformationType; + INT TransformationMatrix[ 8 ]; + BOOL InvalidAffineSet; + } D3D12_VIDEO_ENCODER_AV1_REFERENCE_PICTURE_WARPED_MOTION_INFO; + +typedef struct D3D12_VIDEO_ENCODER_AV1_REFERENCE_PICTURE_DESCRIPTOR + { + UINT ReconstructedPictureResourceIndex; + UINT TemporalLayerIndexPlus1; + UINT SpatialLayerIndexPlus1; + D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE FrameType; + D3D12_VIDEO_ENCODER_AV1_REFERENCE_PICTURE_WARPED_MOTION_INFO WarpedMotionInfo; + UINT OrderHint; + UINT PictureIndex; + } D3D12_VIDEO_ENCODER_AV1_REFERENCE_PICTURE_DESCRIPTOR; + +typedef +enum D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAGS + { + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_ENABLE_ERROR_RESILIENT_MODE = 0x1, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_DISABLE_CDF_UPDATE = 0x2, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_ENABLE_PALETTE_ENCODING = 0x4, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_ENABLE_SKIP_MODE = 0x8, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_FRAME_REFERENCE_MOTION_VECTORS = 0x10, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_FORCE_INTEGER_MOTION_VECTORS = 0x20, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_ALLOW_INTRA_BLOCK_COPY = 0x40, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_USE_SUPER_RESOLUTION = 0x80, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_DISABLE_FRAME_END_UPDATE_CDF = 0x100, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_ENABLE_FRAME_SEGMENTATION_AUTO = 0x200, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_ENABLE_FRAME_SEGMENTATION_CUSTOM = 0x400, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_ENABLE_WARPED_MOTION = 0x800, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_REDUCED_TX_SET = 0x1000, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_MOTION_MODE_SWITCHABLE = 0x2000, + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAG_ALLOW_HIGH_PRECISION_MV = 0x4000 + } D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAGS) +typedef struct D3D12_VIDEO_ENCODER_AV1_RESTORATION_CONFIG + { + D3D12_VIDEO_ENCODER_AV1_RESTORATION_TYPE FrameRestorationType[ 3 ]; + D3D12_VIDEO_ENCODER_AV1_RESTORATION_TILESIZE LoopRestorationPixelSize[ 3 ]; + } D3D12_VIDEO_ENCODER_AV1_RESTORATION_CONFIG; + +typedef struct D3D12_VIDEO_ENCODER_AV1_SEGMENT_DATA + { + UINT64 EnabledFeatures; + INT64 FeatureValue[ 8 ]; + } D3D12_VIDEO_ENCODER_AV1_SEGMENT_DATA; + +typedef struct D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_CONFIG + { + UINT64 UpdateMap; + UINT64 TemporalUpdate; + UINT64 UpdateData; + UINT64 NumSegments; + D3D12_VIDEO_ENCODER_AV1_SEGMENT_DATA SegmentsData[ 8 ]; + } D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_CONFIG; + +typedef struct D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MAP + { + UINT SegmentsMapByteSize; + UINT8 *pSegmentsMap; + } D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MAP; + +typedef struct D3D12_VIDEO_ENCODER_CODEC_AV1_LOOP_FILTER_CONFIG + { + UINT64 LoopFilterLevel[ 2 ]; + UINT64 LoopFilterLevelU; + UINT64 LoopFilterLevelV; + UINT64 LoopFilterSharpnessLevel; + UINT64 LoopFilterDeltaEnabled; + UINT64 UpdateRefDelta; + INT64 RefDeltas[ 8 ]; + UINT64 UpdateModeDelta; + INT64 ModeDeltas[ 2 ]; + } D3D12_VIDEO_ENCODER_CODEC_AV1_LOOP_FILTER_CONFIG; + +typedef struct D3D12_VIDEO_ENCODER_CODEC_AV1_LOOP_FILTER_DELTA_CONFIG + { + UINT64 DeltaLFPresent; + UINT64 DeltaLFMulti; + UINT64 DeltaLFRes; + } D3D12_VIDEO_ENCODER_CODEC_AV1_LOOP_FILTER_DELTA_CONFIG; + +typedef struct D3D12_VIDEO_ENCODER_CODEC_AV1_QUANTIZATION_CONFIG + { + UINT64 BaseQIndex; + INT64 YDCDeltaQ; + INT64 UDCDeltaQ; + INT64 UACDeltaQ; + INT64 VDCDeltaQ; + INT64 VACDeltaQ; + UINT64 UsingQMatrix; + UINT64 QMY; + UINT64 QMU; + UINT64 QMV; + } D3D12_VIDEO_ENCODER_CODEC_AV1_QUANTIZATION_CONFIG; + +typedef struct D3D12_VIDEO_ENCODER_CODEC_AV1_QUANTIZATION_DELTA_CONFIG + { + UINT64 DeltaQPresent; + UINT64 DeltaQRes; + } D3D12_VIDEO_ENCODER_CODEC_AV1_QUANTIZATION_DELTA_CONFIG; + +typedef struct D3D12_VIDEO_ENCODER_AV1_CDEF_CONFIG + { + UINT64 CdefBits; + UINT64 CdefDampingMinus3; + UINT64 CdefYPriStrength[ 8 ]; + UINT64 CdefUVPriStrength[ 8 ]; + UINT64 CdefYSecStrength[ 8 ]; + UINT64 CdefUVSecStrength[ 8 ]; + } D3D12_VIDEO_ENCODER_AV1_CDEF_CONFIG; + +typedef struct D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_CODEC_DATA + { + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_FLAGS Flags; + D3D12_VIDEO_ENCODER_AV1_FRAME_TYPE FrameType; + D3D12_VIDEO_ENCODER_AV1_COMP_PREDICTION_TYPE CompoundPredictionType; + D3D12_VIDEO_ENCODER_AV1_INTERPOLATION_FILTERS InterpolationFilter; + D3D12_VIDEO_ENCODER_AV1_RESTORATION_CONFIG FrameRestorationConfig; + D3D12_VIDEO_ENCODER_AV1_TX_MODE TxMode; + UINT SuperResDenominator; + UINT OrderHint; + UINT PictureIndex; + UINT TemporalLayerIndexPlus1; + UINT SpatialLayerIndexPlus1; + D3D12_VIDEO_ENCODER_AV1_REFERENCE_PICTURE_DESCRIPTOR ReferenceFramesReconPictureDescriptors[ 8 ]; + UINT ReferenceIndices[ 7 ]; + UINT PrimaryRefFrame; + UINT RefreshFrameFlags; + D3D12_VIDEO_ENCODER_CODEC_AV1_LOOP_FILTER_CONFIG LoopFilter; + D3D12_VIDEO_ENCODER_CODEC_AV1_LOOP_FILTER_DELTA_CONFIG LoopFilterDelta; + D3D12_VIDEO_ENCODER_CODEC_AV1_QUANTIZATION_CONFIG Quantization; + D3D12_VIDEO_ENCODER_CODEC_AV1_QUANTIZATION_DELTA_CONFIG QuantizationDelta; + D3D12_VIDEO_ENCODER_AV1_CDEF_CONFIG CDEF; + UINT QPMapValuesCount; + _Field_size_full_(QPMapValuesCount) INT16 *pRateControlQPMap; + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_CONFIG CustomSegmentation; + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_MAP CustomSegmentsMap; + } D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_CODEC_DATA; + +typedef struct D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_TILES + { + UINT64 RowCount; + UINT64 ColCount; + UINT64 RowHeights[ 64 ]; + UINT64 ColWidths[ 64 ]; + UINT64 ContextUpdateTileId; + } D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_TILES; + +typedef struct D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES + { + UINT64 CompoundPredictionType; + D3D12_VIDEO_ENCODER_CODEC_AV1_LOOP_FILTER_CONFIG LoopFilter; + D3D12_VIDEO_ENCODER_CODEC_AV1_LOOP_FILTER_DELTA_CONFIG LoopFilterDelta; + D3D12_VIDEO_ENCODER_CODEC_AV1_QUANTIZATION_CONFIG Quantization; + D3D12_VIDEO_ENCODER_CODEC_AV1_QUANTIZATION_DELTA_CONFIG QuantizationDelta; + D3D12_VIDEO_ENCODER_AV1_CDEF_CONFIG CDEF; + D3D12_VIDEO_ENCODER_AV1_SEGMENTATION_CONFIG SegmentationConfig; + UINT64 PrimaryRefFrame; + UINT64 ReferenceIndices[ 7 ]; + } D3D12_VIDEO_ENCODER_AV1_POST_ENCODE_VALUES; + typedef enum D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE { @@ -6338,10 +6844,13 @@ enum D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_QP_RANGE = 0x4, D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_INITIAL_QP = 0x8, D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_MAX_FRAME_SIZE = 0x10, - D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_VBV_SIZES = 0x20 + D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_VBV_SIZES = 0x20, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_EXTENSION1_SUPPORT = 0x40, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_QUALITY_VS_SPEED = 0x80, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_SPATIAL_ADAPTIVE_QP = 0x100 } D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS) typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP { UINT ConstantQP_FullIntracodedFrame; @@ -6349,6 +6858,14 @@ typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP UINT ConstantQP_InterPredictedFrame_BiDirectionalRef; } D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP; +typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP1 + { + UINT ConstantQP_FullIntracodedFrame; + UINT ConstantQP_InterPredictedFrame_PrevRefOnly; + UINT ConstantQP_InterPredictedFrame_BiDirectionalRef; + UINT QualityVsSpeed; + } D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP1; + typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR { UINT InitialQP; @@ -6360,6 +6877,18 @@ typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR UINT64 InitialVBVFullness; } D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR; +typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR1 + { + UINT InitialQP; + UINT MinQP; + UINT MaxQP; + UINT64 MaxFrameBitSize; + UINT64 TargetBitRate; + UINT64 VBVCapacity; + UINT64 InitialVBVFullness; + UINT QualityVsSpeed; + } D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR1; + typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR { UINT InitialQP; @@ -6372,6 +6901,19 @@ typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR UINT64 InitialVBVFullness; } D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR; +typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR1 + { + UINT InitialQP; + UINT MinQP; + UINT MaxQP; + UINT64 MaxFrameBitSize; + UINT64 TargetAvgBitRate; + UINT64 PeakBitRate; + UINT64 VBVCapacity; + UINT64 InitialVBVFullness; + UINT QualityVsSpeed; + } D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR1; + typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR { UINT InitialQP; @@ -6383,6 +6925,25 @@ typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR UINT ConstantQualityTarget; } D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR; +typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR1 + { + UINT InitialQP; + UINT MinQP; + UINT MaxQP; + UINT64 MaxFrameBitSize; + UINT64 TargetAvgBitRate; + UINT64 PeakBitRate; + UINT ConstantQualityTarget; + UINT64 VBVCapacity; + UINT64 InitialVBVFullness; + UINT QualityVsSpeed; + } D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR1; + +typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_ABSOLUTE_QP_MAP + { + UINT QualityVsSpeed; + } D3D12_VIDEO_ENCODER_RATE_CONTROL_ABSOLUTE_QP_MAP; + typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS { UINT DataSize; @@ -6392,6 +6953,11 @@ typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS const D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR *pConfiguration_CBR; const D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR *pConfiguration_VBR; const D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR *pConfiguration_QVBR; + const D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP1 *pConfiguration_CQP1; + const D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR1 *pConfiguration_CBR1; + const D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR1 *pConfiguration_VBR1; + const D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR1 *pConfiguration_QVBR1; + const D3D12_VIDEO_ENCODER_RATE_CONTROL_ABSOLUTE_QP_MAP *pConfiguration_AbsoluteQPMap; } ; } D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS; @@ -6407,7 +6973,8 @@ typedef enum D3D12_VIDEO_ENCODER_CODEC { D3D12_VIDEO_ENCODER_CODEC_H264 = 0, - D3D12_VIDEO_ENCODER_CODEC_HEVC = 1 + D3D12_VIDEO_ENCODER_CODEC_HEVC = 1, + D3D12_VIDEO_ENCODER_CODEC_AV1 = 2 } D3D12_VIDEO_ENCODER_CODEC; typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC @@ -6429,7 +6996,14 @@ typedef enum D3D12_VIDEO_ENCODER_PROFILE_HEVC { D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN = 0, - D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN10 = 1 + D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN10 = 1, + D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN12 = 2, + D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN10_422 = 3, + D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN12_422 = 4, + D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN_444 = 5, + D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN10_444 = 6, + D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN12_444 = 7, + D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN16_444 = 8 } D3D12_VIDEO_ENCODER_PROFILE_HEVC; typedef struct D3D12_VIDEO_ENCODER_PROFILE_DESC @@ -6439,6 +7013,7 @@ typedef struct D3D12_VIDEO_ENCODER_PROFILE_DESC { D3D12_VIDEO_ENCODER_PROFILE_H264 *pH264Profile; D3D12_VIDEO_ENCODER_PROFILE_HEVC *pHEVCProfile; + D3D12_VIDEO_ENCODER_AV1_PROFILE *pAV1Profile; } ; } D3D12_VIDEO_ENCODER_PROFILE_DESC; @@ -6505,6 +7080,7 @@ typedef struct D3D12_VIDEO_ENCODER_LEVEL_SETTING { D3D12_VIDEO_ENCODER_LEVELS_H264 *pH264LevelSetting; D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC *pHEVCLevelSetting; + D3D12_VIDEO_ENCODER_AV1_LEVEL_TIER_CONSTRAINTS *pAV1LevelSetting; } ; } D3D12_VIDEO_ENCODER_LEVEL_SETTING; @@ -6591,7 +7167,10 @@ enum D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_BYTES_PER_SUBREGION = 1, D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_SQUARE_UNITS_PER_SUBREGION_ROW_UNALIGNED = 2, D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_PARTITIONING_ROWS_PER_SUBREGION = 3, - D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_PARTITIONING_SUBREGIONS_PER_FRAME = 4 + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_PARTITIONING_SUBREGIONS_PER_FRAME = 4, + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_GRID_PARTITION = 5, + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_CONFIGURABLE_GRID_PARTITION = 6, + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_AUTO = 7 } D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE; typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE @@ -6604,13 +7183,69 @@ typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE BOOL IsSupported; } D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE; +typedef +enum D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAGS + { + D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAG_NOT_SPECIFIED = 0x1, + D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAG_CODEC_CONSTRAINT = 0x2, + D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAG_HARDWARE_CONSTRAINT = 0x4, + D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAG_ROWS_COUNT = 0x8, + D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAG_COLS_COUNT = 0x10, + D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAG_WIDTH = 0x20, + D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAG_AREA = 0x40, + D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAG_TOTAL_TILES = 0x80 + } D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAGS) +typedef struct D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_SUPPORT + { + BOOL Use128SuperBlocks; + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_TILES TilesConfiguration; + D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_VALIDATION_FLAGS ValidationFlags; + UINT MinTileRows; + UINT MaxTileRows; + UINT MinTileCols; + UINT MaxTileCols; + UINT MinTileWidth; + UINT MaxTileWidth; + UINT MinTileArea; + UINT MaxTileArea; + UINT TileSizeBytesMinus1; + } D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_SUPPORT; + +typedef struct D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_CONFIG_SUPPORT + { + UINT DataSize; + union + { + D3D12_VIDEO_ENCODER_AV1_FRAME_SUBREGION_LAYOUT_CONFIG_SUPPORT *pAV1Support; + } ; + } D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_CONFIG_SUPPORT; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_CONFIG + { + UINT NodeIndex; + D3D12_VIDEO_ENCODER_CODEC Codec; + D3D12_VIDEO_ENCODER_PROFILE_DESC Profile; + D3D12_VIDEO_ENCODER_LEVEL_SETTING Level; + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE SubregionMode; + D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC FrameResolution; + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_CONFIG_SUPPORT CodecSupport; + BOOL IsSupported; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_CONFIG; + typedef enum D3D12_VIDEO_ENCODER_HEAP_FLAGS { - D3D12_VIDEO_ENCODER_HEAP_FLAG_NONE = 0 + D3D12_VIDEO_ENCODER_HEAP_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_HEAP_FLAG_ALLOW_SUBREGION_NOTIFICATION_ARRAY_OF_BUFFERS = 0x1, + D3D12_VIDEO_ENCODER_HEAP_FLAG_ALLOW_SUBREGION_NOTIFICATION_SINGLE_BUFFER = 0x2, + D3D12_VIDEO_ENCODER_HEAP_FLAG_ALLOW_DIRTY_REGIONS = 0x4, + D3D12_VIDEO_ENCODER_HEAP_FLAG_ALLOW_RATE_CONTROL_FRAME_ANALYSIS = 0x8 } D3D12_VIDEO_ENCODER_HEAP_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_HEAP_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_HEAP_FLAGS) typedef struct D3D12_VIDEO_ENCODER_HEAP_DESC { UINT NodeMask; @@ -6640,10 +7275,11 @@ enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_ADAPTIVE_8x8_TRANSFORM_ENCODING_SUPPORT = 0x8, D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_DIRECT_SPATIAL_ENCODING_SUPPORT = 0x10, D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_DIRECT_TEMPORAL_ENCODING_SUPPORT = 0x20, - D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_CONSTRAINED_INTRAPREDICTION_SUPPORT = 0x40 + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_CONSTRAINED_INTRAPREDICTION_SUPPORT = 0x40, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_NUM_REF_IDX_ACTIVE_OVERRIDE_FLAG_SLICE_SUPPORT = 0x80 } D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS) typedef enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES { @@ -6669,7 +7305,7 @@ enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING = ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING ) } D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS) typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264 { D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS SupportFlags; @@ -6688,10 +7324,33 @@ enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_ASYMETRIC_MOTION_PARTITION_REQUIRED = 0x20, D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_TRANSFORM_SKIP_SUPPORT = 0x40, D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_DISABLING_LOOP_FILTER_ACROSS_SLICES_SUPPORT = 0x80, - D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_P_FRAMES_IMPLEMENTED_AS_LOW_DELAY_B_FRAMES = 0x100 + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_P_FRAMES_IMPLEMENTED_AS_LOW_DELAY_B_FRAMES = 0x100, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_NUM_REF_IDX_ACTIVE_OVERRIDE_FLAG_SLICE_SUPPORT = 0x200, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_TRANSFORM_SKIP_ROTATION_ENABLED_SUPPORT = 0x400, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_TRANSFORM_SKIP_ROTATION_ENABLED_REQUIRED = 0x800, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_TRANSFORM_SKIP_CONTEXT_ENABLED_SUPPORT = 0x1000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_TRANSFORM_SKIP_CONTEXT_ENABLED_REQUIRED = 0x2000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_IMPLICIT_RDPCM_ENABLED_SUPPORT = 0x4000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_IMPLICIT_RDPCM_ENABLED_REQUIRED = 0x8000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_EXPLICIT_RDPCM_ENABLED_SUPPORT = 0x10000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_EXPLICIT_RDPCM_ENABLED_REQUIRED = 0x20000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_EXTENDED_PRECISION_PROCESSING_SUPPORT = 0x40000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_EXTENDED_PRECISION_PROCESSING_REQUIRED = 0x80000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_INTRA_SMOOTHING_DISABLED_SUPPORT = 0x100000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_INTRA_SMOOTHING_DISABLED_REQUIRED = 0x200000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_HIGH_PRECISION_OFFSETS_ENABLED_SUPPORT = 0x400000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_HIGH_PRECISION_OFFSETS_ENABLED_REQUIRED = 0x800000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_PERSISTENT_RICE_ADAPTATION_ENABLED_SUPPORT = 0x1000000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_PERSISTENT_RICE_ADAPTATION_ENABLED_REQUIRED = 0x2000000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_CABAC_BYPASS_ALIGNMENT_ENABLED_SUPPORT = 0x4000000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_CABAC_BYPASS_ALIGNMENT_ENABLED_REQUIRED = 0x8000000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_CROSS_COMPONENT_PREDICTION_ENABLED_FLAG_SUPPORT = 0x10000000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_CROSS_COMPONENT_PREDICTION_ENABLED_FLAG_REQUIRED = 0x20000000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_CHROMA_QP_OFFSET_LIST_ENABLED_FLAG_SUPPORT = 0x40000000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_CHROMA_QP_OFFSET_LIST_ENABLED_FLAG_REQUIRED = 0x80000000 } D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS) typedef enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE { @@ -6721,6 +7380,34 @@ typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC UCHAR max_transform_hierarchy_depth_intra; } D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC; +typedef +enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS1 + { + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG1_NONE = 0, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG1_SEPARATE_COLOUR_PLANE_SUPPORT = 0x1, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG1_SEPARATE_COLOUR_PLANE_REQUIRED = 0x2 + } D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS1; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS1) +typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC1 + { + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS SupportFlags; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MinLumaCodingUnitSize; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MaxLumaCodingUnitSize; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MinLumaTransformUnitSize; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MaxLumaTransformUnitSize; + UCHAR max_transform_hierarchy_depth_inter; + UCHAR max_transform_hierarchy_depth_intra; + UINT allowed_diff_cu_chroma_qp_offset_depth_values; + UINT allowed_log2_sao_offset_scale_luma_values; + UINT allowed_log2_sao_offset_scale_chroma_values; + UINT allowed_log2_max_transform_skip_block_size_minus2_values; + UINT allowed_chroma_qp_offset_list_len_minus1_values; + UINT allowed_cb_qp_offset_list_values[ 6 ]; + UINT allowed_cr_qp_offset_list_values[ 6 ]; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS1 SupportFlags1; + } D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC1; + typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT { UINT DataSize; @@ -6728,6 +7415,8 @@ typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT { D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264 *pH264Support; D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC *pHEVCSupport; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC1 *pHEVCSupport1; + D3D12_VIDEO_ENCODER_AV1_CODEC_CONFIGURATION_SUPPORT *pAV1Support; } ; } D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT; @@ -6765,6 +7454,7 @@ typedef struct D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT { D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264 *pH264Support; D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC *pHEVCSupport; + D3D12_VIDEO_ENCODER_CODEC_AV1_PICTURE_CONTROL_SUPPORT *pAV1Support; } ; } D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT; @@ -6793,10 +7483,21 @@ enum D3D12_VIDEO_ENCODER_SUPPORT_FLAGS D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_INITIAL_QP_AVAILABLE = 0x200, D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_MAX_FRAME_SIZE_AVAILABLE = 0x400, D3D12_VIDEO_ENCODER_SUPPORT_FLAG_SEQUENCE_GOP_RECONFIGURATION_AVAILABLE = 0x800, - D3D12_VIDEO_ENCODER_SUPPORT_FLAG_MOTION_ESTIMATION_PRECISION_MODE_LIMIT_AVAILABLE = 0x1000 + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_MOTION_ESTIMATION_PRECISION_MODE_LIMIT_AVAILABLE = 0x1000, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_EXTENSION1_SUPPORT = 0x2000, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_QUALITY_VS_SPEED_AVAILABLE = 0x4000, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_READABLE_RECONSTRUCTED_PICTURE_LAYOUT_AVAILABLE = 0x8000, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_PER_BLOCK_QP_MAP_METADATA_AVAILABLE = 0x10000, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_PER_BLOCK_SATD_MAP_METADATA_AVAILABLE = 0x20000, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_PER_BLOCK_RC_BIT_ALLOCATION_MAP_METADATA_AVAILABLE = 0x40000, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_SUBREGION_NOTIFICATION_ARRAY_OF_BUFFERS_AVAILABLE = 0x80000, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_SUBREGION_NOTIFICATION_SINGLE_BUFFER_AVAILABLE = 0x100000, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_FRAME_PSNR_METADATA_AVAILABLE = 0x200000, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_SUBREGIONS_PSNR_METADATA_AVAILABLE = 0x400000, + D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_SPATIAL_ADAPTIVE_QP_AVAILABLE = 0x800000 } D3D12_VIDEO_ENCODER_SUPPORT_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SUPPORT_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SUPPORT_FLAGS) typedef enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS { @@ -6807,7 +7508,7 @@ enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_ALLOW_REQUEST_INTRA_CONSTRAINED_SLICES = 0x8 } D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS) typedef enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES { @@ -6833,10 +7534,20 @@ enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_LONG_TERM_REFERENCES = 0x8, D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_USE_ASYMETRIC_MOTION_PARTITION = 0x10, D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_TRANSFORM_SKIPPING = 0x20, - D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_USE_CONSTRAINED_INTRAPREDICTION = 0x40 + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_USE_CONSTRAINED_INTRAPREDICTION = 0x40, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_TRANSFORM_SKIP_ROTATION = 0x80, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_TRANSFORM_SKIP_CONTEXT = 0x100, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_IMPLICIT_RDPCM = 0x200, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_EXPLICIT_RDPCM = 0x400, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_EXTENDED_PRECISION_PROCESSING = 0x800, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_INTRA_SMOOTHING_DISABLED = 0x1000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_HIGH_PRECISION_OFFSETS = 0x2000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_PERSISTENT_RICE_ADAPTATION = 0x4000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_CABAC_BYPASS_ALIGNMENT = 0x8000, + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_SEPARATE_COLOUR_PLANE = 0x10000 } D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS) typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC { D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS ConfigurationFlags; @@ -6855,6 +7566,7 @@ typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION { D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264 *pH264Config; D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC *pHEVCConfig; + D3D12_VIDEO_ENCODER_AV1_CODEC_CONFIGURATION *pAV1Config; } ; } D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION; @@ -6870,7 +7582,8 @@ enum D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_MAXIMUM = 0, D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_FULL_PIXEL = 1, D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_HALF_PIXEL = 2, - D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_QUARTER_PIXEL = 3 + D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_QUARTER_PIXEL = 3, + D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_EIGHTH_PIXEL = 4 } D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE; typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS @@ -6893,10 +7606,15 @@ enum D3D12_VIDEO_ENCODER_VALIDATION_FLAGS D3D12_VIDEO_ENCODER_VALIDATION_FLAG_INTRA_REFRESH_MODE_NOT_SUPPORTED = 0x80, D3D12_VIDEO_ENCODER_VALIDATION_FLAG_SUBREGION_LAYOUT_MODE_NOT_SUPPORTED = 0x100, D3D12_VIDEO_ENCODER_VALIDATION_FLAG_RESOLUTION_NOT_SUPPORTED_IN_LIST = 0x200, - D3D12_VIDEO_ENCODER_VALIDATION_FLAG_GOP_STRUCTURE_NOT_SUPPORTED = 0x800 + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_GOP_STRUCTURE_NOT_SUPPORTED = 0x800, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_SUBREGION_LAYOUT_DATA_NOT_SUPPORTED = 0x1000, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_QPMAP_NOT_SUPPORTED = 0x2000, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_DIRTY_REGIONS_NOT_SUPPORTED = 0x4000, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_MOTION_SEARCH_NOT_SUPPORTED = 0x8000, + D3D12_VIDEO_ENCODER_VALIDATION_FLAG_FRAME_ANALYSIS_NOT_SUPPORTED = 0x10000 } D3D12_VIDEO_ENCODER_VALIDATION_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_VALIDATION_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_VALIDATION_FLAGS) typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264 { UINT GOPLength; @@ -6920,6 +7638,7 @@ typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE { D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264 *pH264GroupOfPictures; D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC *pHEVCGroupOfPictures; + D3D12_VIDEO_ENCODER_AV1_SEQUENCE_STRUCTURE *pAV1SequenceStructure; } ; } D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE; @@ -6943,6 +7662,50 @@ typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT _Field_size_full_(ResolutionsListCount) D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS *pResolutionDependentSupport; } D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT; +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES + { + union + { + UINT MaxBytesPerSlice; + UINT NumberOfCodingUnitsPerSlice; + UINT NumberOfRowsPerSlice; + UINT NumberOfSlicesPerFrame; + } ; + } D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES; + +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA + { + UINT DataSize; + union + { + const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES *pSlicesPartition_H264; + const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES *pSlicesPartition_HEVC; + const D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_TILES *pTilesPartition_AV1; + } ; + } D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT1 + { + UINT NodeIndex; + D3D12_VIDEO_ENCODER_CODEC Codec; + DXGI_FORMAT InputFormat; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION CodecConfiguration; + D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE CodecGopSequence; + D3D12_VIDEO_ENCODER_RATE_CONTROL RateControl; + D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE IntraRefresh; + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE SubregionFrameEncoding; + UINT ResolutionsListCount; + const D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList; + UINT MaxReferenceFramesInDPB; + D3D12_VIDEO_ENCODER_VALIDATION_FLAGS ValidationFlags; + D3D12_VIDEO_ENCODER_SUPPORT_FLAGS SupportFlags; + D3D12_VIDEO_ENCODER_PROFILE_DESC SuggestedProfile; + D3D12_VIDEO_ENCODER_LEVEL_SETTING SuggestedLevel; + _Field_size_full_(ResolutionsListCount) D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS *pResolutionDependentSupport; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA SubregionFrameEncodingData; + UINT MaxQualityVsSpeed; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT1; + typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS { UINT NodeIndex; @@ -6962,7 +7725,7 @@ enum D3D12_VIDEO_ENCODER_FLAGS D3D12_VIDEO_ENCODER_FLAG_NONE = 0 } D3D12_VIDEO_ENCODER_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_FLAGS) typedef struct D3D12_VIDEO_ENCODER_DESC { UINT NodeMask; @@ -7616,10 +8379,11 @@ typedef enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS { D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAG_NONE = 0, - D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAG_REQUEST_INTRA_CONSTRAINED_SLICES = 0x1 + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAG_REQUEST_INTRA_CONSTRAINED_SLICES = 0x1, + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAG_REQUEST_NUM_REF_IDX_ACTIVE_OVERRIDE_FLAG_SLICE = 0x2 } D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS) typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION { UCHAR memory_management_control_operation; @@ -7684,10 +8448,13 @@ typedef enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS { D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_NONE = 0, - D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_REQUEST_INTRA_CONSTRAINED_SLICES = 0x1 + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_REQUEST_INTRA_CONSTRAINED_SLICES = 0x1, + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_REQUEST_NUM_REF_IDX_ACTIVE_OVERRIDE_FLAG_SLICE = 0x2, + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_CROSS_COMPONENT_PREDICTION = 0x4, + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_CHROMA_QP_OFFSET_LIST = 0x8 } D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS) typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC { D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS Flags; @@ -7709,6 +8476,34 @@ typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC _Field_size_full_(QPMapValuesCount) INT8 *pRateControlQPMap; } D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC; +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC1 + { + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS Flags; + D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC FrameType; + UINT slice_pic_parameter_set_id; + UINT PictureOrderCountNumber; + UINT TemporalLayerIndex; + UINT List0ReferenceFramesCount; + _Field_size_full_(List0ReferenceFramesCount) UINT *pList0ReferenceFrames; + UINT List1ReferenceFramesCount; + _Field_size_full_(List1ReferenceFramesCount) UINT *pList1ReferenceFrames; + UINT ReferenceFramesReconPictureDescriptorsCount; + _Field_size_full_(ReferenceFramesReconPictureDescriptorsCount) D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC *pReferenceFramesReconPictureDescriptors; + UINT List0RefPicModificationsCount; + _Field_size_full_(List0RefPicModificationsCount) UINT *pList0RefPicModifications; + UINT List1RefPicModificationsCount; + _Field_size_full_(List1RefPicModificationsCount) UINT *pList1RefPicModifications; + UINT QPMapValuesCount; + _Field_size_full_(QPMapValuesCount) INT8 *pRateControlQPMap; + UCHAR diff_cu_chroma_qp_offset_depth; + UCHAR log2_sao_offset_scale_luma; + UCHAR log2_sao_offset_scale_chroma; + UCHAR log2_max_transform_skip_block_size_minus2; + UCHAR chroma_qp_offset_list_len_minus1; + CHAR cb_qp_offset_list[ 6 ]; + CHAR cr_qp_offset_list[ 6 ]; + } D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC1; + typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA { UINT DataSize; @@ -7716,6 +8511,8 @@ typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA { D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264 *pH264PicData; D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC *pHEVCPicData; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC1 *pHEVCPicData1; + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_CODEC_DATA *pAV1PicData; } ; } D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA; @@ -7730,10 +8527,13 @@ typedef enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS { D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_NONE = 0, - D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_USED_AS_REFERENCE_PICTURE = 0x1 + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_USED_AS_REFERENCE_PICTURE = 0x1, + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_ENABLE_QUANTIZATION_MATRIX_INPUT = 0x2, + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_ENABLE_DIRTY_REGIONS_INPUT = 0x4, + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_ENABLE_MOTION_VECTORS_INPUT = 0x8 } D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS) typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC { UINT IntraRefreshFrameIndex; @@ -7753,28 +8553,7 @@ enum D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_GOP_SEQUENCE_CHANGE = 0x10 } D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS); -typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES - { - union - { - UINT MaxBytesPerSlice; - UINT NumberOfCodingUnitsPerSlice; - UINT NumberOfRowsPerSlice; - UINT NumberOfSlicesPerFrame; - } ; - } D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES; - -typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA - { - UINT DataSize; - union - { - const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES *pSlicesPartition_H264; - const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES *pSlicesPartition_HEVC; - } ; - } D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA; - +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS) typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC { D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS Flags; @@ -7825,7 +8604,7 @@ enum D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_INVALID_METADATA_BUFFER_SOURCE = 0x10 } D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS; -DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS); +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS) typedef struct D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS { UINT64 AverageQP; @@ -8537,39 +9316,1402 @@ EXTERN_C const IID IID_ID3D12VideoEncodeCommandList3; /* interface __MIDL_itf_d3d12video_0000_0027 */ /* [local] */ -#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ -#pragma endregion -DEFINE_GUID(IID_ID3D12VideoDecoderHeap,0x0946B7C9,0xEBF6,0x4047,0xBB,0x73,0x86,0x83,0xE2,0x7D,0xBB,0x1F); -DEFINE_GUID(IID_ID3D12VideoDevice,0x1F052807,0x0B46,0x4ACC,0x8A,0x89,0x36,0x4F,0x79,0x37,0x18,0xA4); -DEFINE_GUID(IID_ID3D12VideoDecoder,0xC59B6BDC,0x7720,0x4074,0xA1,0x36,0x17,0xA1,0x56,0x03,0x74,0x70); -DEFINE_GUID(IID_ID3D12VideoProcessor,0x304FDB32,0xBEDE,0x410A,0x85,0x45,0x94,0x3A,0xC6,0xA4,0x61,0x38); -DEFINE_GUID(IID_ID3D12VideoDecodeCommandList,0x3B60536E,0xAD29,0x4E64,0xA2,0x69,0xF8,0x53,0x83,0x7E,0x5E,0x53); -DEFINE_GUID(IID_ID3D12VideoProcessCommandList,0xAEB2543A,0x167F,0x4682,0xAC,0xC8,0xD1,0x59,0xED,0x4A,0x62,0x09); -DEFINE_GUID(IID_ID3D12VideoDecodeCommandList1,0xD52F011B,0xB56E,0x453C,0xA0,0x5A,0xA7,0xF3,0x11,0xC8,0xF4,0x72); -DEFINE_GUID(IID_ID3D12VideoProcessCommandList1,0x542C5C4D,0x7596,0x434F,0x8C,0x93,0x4E,0xFA,0x67,0x66,0xF2,0x67); -DEFINE_GUID(IID_ID3D12VideoMotionEstimator,0x33FDAE0E,0x098B,0x428F,0x87,0xBB,0x34,0xB6,0x95,0xDE,0x08,0xF8); -DEFINE_GUID(IID_ID3D12VideoMotionVectorHeap,0x5BE17987,0x743A,0x4061,0x83,0x4B,0x23,0xD2,0x2D,0xAE,0xA5,0x05); -DEFINE_GUID(IID_ID3D12VideoDevice1,0x981611AD,0xA144,0x4C83,0x98,0x90,0xF3,0x0E,0x26,0xD6,0x58,0xAB); -DEFINE_GUID(IID_ID3D12VideoEncodeCommandList,0x8455293A,0x0CBD,0x4831,0x9B,0x39,0xFB,0xDB,0xAB,0x72,0x47,0x23); -DEFINE_GUID(IID_ID3D12VideoDecoder1,0x79A2E5FB,0xCCD2,0x469A,0x9F,0xDE,0x19,0x5D,0x10,0x95,0x1F,0x7E); -DEFINE_GUID(IID_ID3D12VideoDecoderHeap1,0xDA1D98C5,0x539F,0x41B2,0xBF,0x6B,0x11,0x98,0xA0,0x3B,0x6D,0x26); -DEFINE_GUID(IID_ID3D12VideoProcessor1,0xF3CFE615,0x553F,0x425C,0x86,0xD8,0xEE,0x8C,0x1B,0x1F,0xB0,0x1C); -DEFINE_GUID(IID_ID3D12VideoExtensionCommand,0x554E41E8,0xAE8E,0x4A8C,0xB7,0xD2,0x5B,0x4F,0x27,0x4A,0x30,0xE4); -DEFINE_GUID(IID_ID3D12VideoDevice2,0xF019AC49,0xF838,0x4A95,0x9B,0x17,0x57,0x94,0x37,0xC8,0xF5,0x13); -DEFINE_GUID(IID_ID3D12VideoDecodeCommandList2,0x6e120880,0xc114,0x4153,0x80,0x36,0xd2,0x47,0x05,0x1e,0x17,0x29); -DEFINE_GUID(IID_ID3D12VideoDecodeCommandList3,0x2aee8c37,0x9562,0x42da,0x8a,0xbf,0x61,0xef,0xeb,0x2e,0x45,0x13); -DEFINE_GUID(IID_ID3D12VideoProcessCommandList2,0xdb525ae4,0x6ad6,0x473c,0xba,0xa7,0x59,0xb2,0xe3,0x70,0x82,0xe4); -DEFINE_GUID(IID_ID3D12VideoProcessCommandList3,0x1a0a4ca4,0x9f08,0x40ce,0x95,0x58,0xb4,0x11,0xfd,0x26,0x66,0xff); -DEFINE_GUID(IID_ID3D12VideoEncodeCommandList1,0x94971eca,0x2bdb,0x4769,0x88,0xcf,0x36,0x75,0xea,0x75,0x7e,0xbc); -DEFINE_GUID(IID_ID3D12VideoEncoder,0x2E0D212D,0x8DF9,0x44A6,0xA7,0x70,0xBB,0x28,0x9B,0x18,0x27,0x37); -DEFINE_GUID(IID_ID3D12VideoEncoderHeap,0x22B35D96,0x876A,0x44C0,0xB2,0x5E,0xFB,0x8C,0x9C,0x7F,0x1C,0x4A); -DEFINE_GUID(IID_ID3D12VideoDevice3,0x4243ADB4,0x3A32,0x4666,0x97,0x3C,0x0C,0xCC,0x56,0x25,0xDC,0x44); -DEFINE_GUID(IID_ID3D12VideoEncodeCommandList2,0x895491e2,0xe701,0x46a9,0x9a,0x1f,0x8d,0x34,0x80,0xed,0x86,0x7a); -DEFINE_GUID(IID_ID3D12VideoEncodeCommandList3,0x7f027b22,0x1515,0x4e85,0xaa,0x0d,0x02,0x64,0x86,0x58,0x05,0x76); - - -extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0027_v0_0_c_ifspec; -extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0027_v0_0_s_ifspec; +typedef struct D3D12_VIDEO_ENCODER_HEAP_DESC1 + { + UINT NodeMask; + D3D12_VIDEO_ENCODER_HEAP_FLAGS Flags; + D3D12_VIDEO_ENCODER_CODEC EncodeCodec; + D3D12_VIDEO_ENCODER_PROFILE_DESC EncodeProfile; + D3D12_VIDEO_ENCODER_LEVEL_SETTING EncodeLevel; + UINT ResolutionsListCount; + _Field_size_full_(ResolutionsListCount) const D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList; + UINT Pow2DownscaleFactor; + } D3D12_VIDEO_ENCODER_HEAP_DESC1; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0027_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0027_v0_0_s_ifspec; + +#ifndef __ID3D12VideoEncoderHeap1_INTERFACE_DEFINED__ +#define __ID3D12VideoEncoderHeap1_INTERFACE_DEFINED__ + +/* interface ID3D12VideoEncoderHeap1 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12VideoEncoderHeap1; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ea8f1968-4aa0-43a4-9d30-ba86ec84d4f9") + ID3D12VideoEncoderHeap1 : public ID3D12VideoEncoderHeap + { + public: + virtual UINT STDMETHODCALLTYPE GetPow2DownscaleFactor( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12VideoEncoderHeap1Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12VideoEncoderHeap1 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12VideoEncoderHeap1 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12VideoEncoderHeap1 * This); + + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12VideoEncoderHeap1 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12VideoEncoderHeap1 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12VideoEncoderHeap1 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12VideoEncoderHeap1 * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12VideoEncoderHeap1 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetNodeMask) + UINT ( STDMETHODCALLTYPE *GetNodeMask )( + ID3D12VideoEncoderHeap1 * This); + + DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetEncoderHeapFlags) + D3D12_VIDEO_ENCODER_HEAP_FLAGS ( STDMETHODCALLTYPE *GetEncoderHeapFlags )( + ID3D12VideoEncoderHeap1 * This); + + DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetCodec) + D3D12_VIDEO_ENCODER_CODEC ( STDMETHODCALLTYPE *GetCodec )( + ID3D12VideoEncoderHeap1 * This); + + DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetCodecProfile) + HRESULT ( STDMETHODCALLTYPE *GetCodecProfile )( + ID3D12VideoEncoderHeap1 * This, + _Inout_ D3D12_VIDEO_ENCODER_PROFILE_DESC dstProfile); + + DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetCodecLevel) + HRESULT ( STDMETHODCALLTYPE *GetCodecLevel )( + ID3D12VideoEncoderHeap1 * This, + _Inout_ D3D12_VIDEO_ENCODER_LEVEL_SETTING dstLevel); + + DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetResolutionListCount) + UINT ( STDMETHODCALLTYPE *GetResolutionListCount )( + ID3D12VideoEncoderHeap1 * This); + + DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetResolutionList) + HRESULT ( STDMETHODCALLTYPE *GetResolutionList )( + ID3D12VideoEncoderHeap1 * This, + const UINT ResolutionsListCount, + _Out_writes_(ResolutionsListCount) D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList); + + DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap1, GetPow2DownscaleFactor) + UINT ( STDMETHODCALLTYPE *GetPow2DownscaleFactor )( + ID3D12VideoEncoderHeap1 * This); + + END_INTERFACE + } ID3D12VideoEncoderHeap1Vtbl; + + interface ID3D12VideoEncoderHeap1 + { + CONST_VTBL struct ID3D12VideoEncoderHeap1Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12VideoEncoderHeap1_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12VideoEncoderHeap1_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12VideoEncoderHeap1_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12VideoEncoderHeap1_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12VideoEncoderHeap1_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12VideoEncoderHeap1_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12VideoEncoderHeap1_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12VideoEncoderHeap1_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + + +#define ID3D12VideoEncoderHeap1_GetNodeMask(This) \ + ( (This)->lpVtbl -> GetNodeMask(This) ) + +#define ID3D12VideoEncoderHeap1_GetEncoderHeapFlags(This) \ + ( (This)->lpVtbl -> GetEncoderHeapFlags(This) ) + +#define ID3D12VideoEncoderHeap1_GetCodec(This) \ + ( (This)->lpVtbl -> GetCodec(This) ) + +#define ID3D12VideoEncoderHeap1_GetCodecProfile(This,dstProfile) \ + ( (This)->lpVtbl -> GetCodecProfile(This,dstProfile) ) + +#define ID3D12VideoEncoderHeap1_GetCodecLevel(This,dstLevel) \ + ( (This)->lpVtbl -> GetCodecLevel(This,dstLevel) ) + +#define ID3D12VideoEncoderHeap1_GetResolutionListCount(This) \ + ( (This)->lpVtbl -> GetResolutionListCount(This) ) + +#define ID3D12VideoEncoderHeap1_GetResolutionList(This,ResolutionsListCount,pResolutionList) \ + ( (This)->lpVtbl -> GetResolutionList(This,ResolutionsListCount,pResolutionList) ) + + +#define ID3D12VideoEncoderHeap1_GetPow2DownscaleFactor(This) \ + ( (This)->lpVtbl -> GetPow2DownscaleFactor(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12VideoEncoderHeap1_INTERFACE_DEFINED__ */ + + +#ifndef __ID3D12VideoDevice4_INTERFACE_DEFINED__ +#define __ID3D12VideoDevice4_INTERFACE_DEFINED__ + +/* interface ID3D12VideoDevice4 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12VideoDevice4; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e59ad09e-f1ae-42bb-8983-9f6e5586c4eb") + ID3D12VideoDevice4 : public ID3D12VideoDevice3 + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateVideoEncoderHeap1( + _In_ const D3D12_VIDEO_ENCODER_HEAP_DESC1 *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppVideoEncoderHeap) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12VideoDevice4Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12VideoDevice4 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12VideoDevice4 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12VideoDevice4 * This); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice, CheckFeatureSupport) + HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( + ID3D12VideoDevice4 * This, + D3D12_FEATURE_VIDEO FeatureVideo, + _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, + UINT FeatureSupportDataSize); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoder) + HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder )( + ID3D12VideoDevice4 * This, + _In_ const D3D12_VIDEO_DECODER_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppVideoDecoder); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoderHeap) + HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap )( + ID3D12VideoDevice4 * This, + _In_ const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppVideoDecoderHeap); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoProcessor) + HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor )( + ID3D12VideoDevice4 * This, + UINT NodeMask, + _In_ const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc, + UINT NumInputStreamDescs, + _In_reads_(NumInputStreamDescs) const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs, + _In_ REFIID riid, + _COM_Outptr_ void **ppVideoProcessor); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionEstimator) + HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionEstimator )( + ID3D12VideoDevice4 * This, + _In_ const D3D12_VIDEO_MOTION_ESTIMATOR_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession, + _In_ REFIID riid, + _COM_Outptr_ void **ppVideoMotionEstimator); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionVectorHeap) + HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionVectorHeap )( + ID3D12VideoDevice4 * This, + _In_ const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession, + _In_ REFIID riid, + _COM_Outptr_ void **ppVideoMotionVectorHeap); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoDecoder1) + HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder1 )( + ID3D12VideoDevice4 * This, + _In_ const D3D12_VIDEO_DECODER_DESC *pDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession, + _In_ REFIID riid, + _COM_Outptr_ void **ppVideoDecoder); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoDecoderHeap1) + HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap1 )( + ID3D12VideoDevice4 * This, + _In_ const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession, + _In_ REFIID riid, + _COM_Outptr_ void **ppVideoDecoderHeap); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoProcessor1) + HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor1 )( + ID3D12VideoDevice4 * This, + UINT NodeMask, + _In_ const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc, + UINT NumInputStreamDescs, + _In_reads_(NumInputStreamDescs) const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession, + _In_ REFIID riid, + _COM_Outptr_ void **ppVideoProcessor); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoExtensionCommand) + HRESULT ( STDMETHODCALLTYPE *CreateVideoExtensionCommand )( + ID3D12VideoDevice4 * This, + _In_ const D3D12_VIDEO_EXTENSION_COMMAND_DESC *pDesc, + _In_reads_bytes_(CreationParametersDataSizeInBytes) const void *pCreationParameters, + SIZE_T CreationParametersDataSizeInBytes, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession, + _In_ REFIID riid, + _COM_Outptr_ void **ppVideoExtensionCommand); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice2, ExecuteExtensionCommand) + HRESULT ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( + ID3D12VideoDevice4 * This, + _In_ ID3D12VideoExtensionCommand *pExtensionCommand, + _In_reads_bytes_(ExecutionParametersSizeInBytes) const void *pExecutionParameters, + SIZE_T ExecutionParametersSizeInBytes, + _Out_writes_bytes_(OutputDataSizeInBytes) void *pOutputData, + SIZE_T OutputDataSizeInBytes); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice3, CreateVideoEncoder) + HRESULT ( STDMETHODCALLTYPE *CreateVideoEncoder )( + ID3D12VideoDevice4 * This, + _In_ const D3D12_VIDEO_ENCODER_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppVideoEncoder); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice3, CreateVideoEncoderHeap) + HRESULT ( STDMETHODCALLTYPE *CreateVideoEncoderHeap )( + ID3D12VideoDevice4 * This, + _In_ const D3D12_VIDEO_ENCODER_HEAP_DESC *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppVideoEncoderHeap); + + DECLSPEC_XFGVIRT(ID3D12VideoDevice4, CreateVideoEncoderHeap1) + HRESULT ( STDMETHODCALLTYPE *CreateVideoEncoderHeap1 )( + ID3D12VideoDevice4 * This, + _In_ const D3D12_VIDEO_ENCODER_HEAP_DESC1 *pDesc, + _In_ REFIID riid, + _COM_Outptr_ void **ppVideoEncoderHeap); + + END_INTERFACE + } ID3D12VideoDevice4Vtbl; + + interface ID3D12VideoDevice4 + { + CONST_VTBL struct ID3D12VideoDevice4Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12VideoDevice4_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12VideoDevice4_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12VideoDevice4_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12VideoDevice4_CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize) \ + ( (This)->lpVtbl -> CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize) ) + +#define ID3D12VideoDevice4_CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder) \ + ( (This)->lpVtbl -> CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder) ) + +#define ID3D12VideoDevice4_CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap) \ + ( (This)->lpVtbl -> CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap) ) + +#define ID3D12VideoDevice4_CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor) \ + ( (This)->lpVtbl -> CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor) ) + + +#define ID3D12VideoDevice4_CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator) \ + ( (This)->lpVtbl -> CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator) ) + +#define ID3D12VideoDevice4_CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap) \ + ( (This)->lpVtbl -> CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap) ) + + +#define ID3D12VideoDevice4_CreateVideoDecoder1(This,pDesc,pProtectedResourceSession,riid,ppVideoDecoder) \ + ( (This)->lpVtbl -> CreateVideoDecoder1(This,pDesc,pProtectedResourceSession,riid,ppVideoDecoder) ) + +#define ID3D12VideoDevice4_CreateVideoDecoderHeap1(This,pVideoDecoderHeapDesc,pProtectedResourceSession,riid,ppVideoDecoderHeap) \ + ( (This)->lpVtbl -> CreateVideoDecoderHeap1(This,pVideoDecoderHeapDesc,pProtectedResourceSession,riid,ppVideoDecoderHeap) ) + +#define ID3D12VideoDevice4_CreateVideoProcessor1(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,pProtectedResourceSession,riid,ppVideoProcessor) \ + ( (This)->lpVtbl -> CreateVideoProcessor1(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,pProtectedResourceSession,riid,ppVideoProcessor) ) + +#define ID3D12VideoDevice4_CreateVideoExtensionCommand(This,pDesc,pCreationParameters,CreationParametersDataSizeInBytes,pProtectedResourceSession,riid,ppVideoExtensionCommand) \ + ( (This)->lpVtbl -> CreateVideoExtensionCommand(This,pDesc,pCreationParameters,CreationParametersDataSizeInBytes,pProtectedResourceSession,riid,ppVideoExtensionCommand) ) + +#define ID3D12VideoDevice4_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes,pOutputData,OutputDataSizeInBytes) \ + ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes,pOutputData,OutputDataSizeInBytes) ) + + +#define ID3D12VideoDevice4_CreateVideoEncoder(This,pDesc,riid,ppVideoEncoder) \ + ( (This)->lpVtbl -> CreateVideoEncoder(This,pDesc,riid,ppVideoEncoder) ) + +#define ID3D12VideoDevice4_CreateVideoEncoderHeap(This,pDesc,riid,ppVideoEncoderHeap) \ + ( (This)->lpVtbl -> CreateVideoEncoderHeap(This,pDesc,riid,ppVideoEncoderHeap) ) + + +#define ID3D12VideoDevice4_CreateVideoEncoderHeap1(This,pDesc,riid,ppVideoEncoderHeap) \ + ( (This)->lpVtbl -> CreateVideoEncoderHeap1(This,pDesc,riid,ppVideoEncoderHeap) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12VideoDevice4_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12video_0000_0029 */ +/* [local] */ + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_HEAP_SIZE1 + { + D3D12_VIDEO_ENCODER_HEAP_DESC1 HeapDesc; + BOOL IsSupported; + UINT64 MemoryPoolL0Size; + UINT64 MemoryPoolL1Size; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_HEAP_SIZE1; + +typedef +enum D3D12_VIDEO_ENCODER_OPTIONAL_METADATA_ENABLE_FLAGS + { + D3D12_VIDEO_ENCODER_OPTIONAL_METADATA_ENABLE_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_OPTIONAL_METADATA_ENABLE_FLAG_QP_MAP = 0x1, + D3D12_VIDEO_ENCODER_OPTIONAL_METADATA_ENABLE_FLAG_SATD_MAP = 0x2, + D3D12_VIDEO_ENCODER_OPTIONAL_METADATA_ENABLE_FLAG_RC_BIT_ALLOCATION_MAP = 0x4, + D3D12_VIDEO_ENCODER_OPTIONAL_METADATA_ENABLE_FLAG_FRAME_PSNR = 0x8, + D3D12_VIDEO_ENCODER_OPTIONAL_METADATA_ENABLE_FLAG_SUBREGIONS_PSNR = 0x10 + } D3D12_VIDEO_ENCODER_OPTIONAL_METADATA_ENABLE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_OPTIONAL_METADATA_ENABLE_FLAGS ) +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS1 + { + UINT NodeIndex; + D3D12_VIDEO_ENCODER_CODEC Codec; + D3D12_VIDEO_ENCODER_PROFILE_DESC Profile; + DXGI_FORMAT InputFormat; + D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC PictureTargetResolution; + BOOL IsSupported; + UINT CompressedBitstreamBufferAccessAlignment; + UINT EncoderMetadataBufferAccessAlignment; + UINT MaxEncoderOutputMetadataBufferSize; + D3D12_VIDEO_ENCODER_OPTIONAL_METADATA_ENABLE_FLAGS OptionalMetadata; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION CodecConfiguration; + D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC EncoderOutputMetadataQPMapTextureDimensions; + D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC EncoderOutputMetadataSATDMapTextureDimensions; + D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC EncoderOutputMetadataBitAllocationMapTextureDimensions; + UINT EncoderOutputMetadataFramePSNRComponentsNumber; + UINT EncoderOutputMetadataSubregionsPSNRComponentsNumber; + UINT EncoderOutputMetadataSubregionsPSNRResolvedMetadataBufferSize; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS1; + +typedef struct D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_PSNR_RESOLVED_LAYOUT + { + float PSNRY; + float PSNRU; + float PSNRV; + } D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_PSNR_RESOLVED_LAYOUT; + +typedef +enum D3D12_VIDEO_ENCODER_INPUT_MAP_SOURCE + { + D3D12_VIDEO_ENCODER_INPUT_MAP_SOURCE_CPU_BUFFER = 0, + D3D12_VIDEO_ENCODER_INPUT_MAP_SOURCE_GPU_TEXTURE = 1 + } D3D12_VIDEO_ENCODER_INPUT_MAP_SOURCE; + +typedef +enum D3D12_VIDEO_ENCODER_DIRTY_REGIONS_MAP_VALUES_MODE + { + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_MAP_VALUES_MODE_DIRTY = 0, + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_MAP_VALUES_MODE_SKIP = 1 + } D3D12_VIDEO_ENCODER_DIRTY_REGIONS_MAP_VALUES_MODE; + +typedef struct D3D12_VIDEO_ENCODER_INPUT_MAP_SESSION_INFO + { + D3D12_VIDEO_ENCODER_CODEC Codec; + D3D12_VIDEO_ENCODER_PROFILE_DESC Profile; + D3D12_VIDEO_ENCODER_LEVEL_SETTING Level; + DXGI_FORMAT InputFormat; + D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC InputResolution; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION CodecConfiguration; + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE SubregionFrameEncoding; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA SubregionFrameEncodingData; + } D3D12_VIDEO_ENCODER_INPUT_MAP_SESSION_INFO; + +typedef +enum D3D12_VIDEO_ENCODER_INPUT_MAP_TYPE + { + D3D12_VIDEO_ENCODER_INPUT_MAP_TYPE_QUANTIZATION_MATRIX = 0, + D3D12_VIDEO_ENCODER_INPUT_MAP_TYPE_DIRTY_REGIONS = 1, + D3D12_VIDEO_ENCODER_INPUT_MAP_TYPE_MOTION_VECTORS = 2 + } D3D12_VIDEO_ENCODER_INPUT_MAP_TYPE; + +typedef +enum D3D12_VIDEO_ENCODER_FRAME_MOTION_SEARCH_MODE + { + D3D12_VIDEO_ENCODER_FRAME_MOTION_SEARCH_MODE_FULL_SEARCH = 0, + D3D12_VIDEO_ENCODER_FRAME_MOTION_SEARCH_MODE_START_HINT = 1, + D3D12_VIDEO_ENCODER_FRAME_MOTION_SEARCH_MODE_START_HINT_LIMITED_DISTANCE = 2 + } D3D12_VIDEO_ENCODER_FRAME_MOTION_SEARCH_MODE; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_QPMAP_INPUT + { + UINT NodeIndex; + D3D12_VIDEO_ENCODER_INPUT_MAP_SESSION_INFO SessionInfo; + D3D12_VIDEO_ENCODER_INPUT_MAP_SOURCE MapSource; + BOOL IsSupported; + UINT MapSourcePreferenceRanking; + UINT BlockSize; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_QPMAP_INPUT; + +typedef +enum D3D12_VIDEO_ENCODER_DIRTY_REGIONS_SUPPORT_FLAGS + { + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_SUPPORT_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_SUPPORT_FLAG_REPEAT_FRAME = 0x1, + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_SUPPORT_FLAG_DIRTY_REGIONS = 0x2, + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_SUPPORT_FLAG_DIRTY_REGIONS_REQUIRE_FULL_ROW = 0x4 + } D3D12_VIDEO_ENCODER_DIRTY_REGIONS_SUPPORT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_ENCODER_DIRTY_REGIONS_SUPPORT_FLAGS ) +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_DIRTY_REGIONS + { + UINT NodeIndex; + D3D12_VIDEO_ENCODER_INPUT_MAP_SESSION_INFO SessionInfo; + D3D12_VIDEO_ENCODER_INPUT_MAP_SOURCE MapSource; + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_MAP_VALUES_MODE MapValuesType; + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_SUPPORT_FLAGS SupportFlags; + UINT MapSourcePreferenceRanking; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_DIRTY_REGIONS; + +typedef +enum D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION + { + D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_FULL_PIXEL = 0, + D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_HALF_PIXEL = 1, + D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_QUARTER_PIXEL = 2 + } D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION; + +typedef +enum D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_SUPPORT_FLAGS + { + D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_SUPPORT_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_SUPPORT_FLAG_FULL_PIXEL = ( 1 << D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_FULL_PIXEL ) , + D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_SUPPORT_FLAG_HALF_PIXEL = ( 1 << D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_HALF_PIXEL ) , + D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_SUPPORT_FLAG_QUARTER_PIXEL = ( 1 << D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_QUARTER_PIXEL ) + } D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_SUPPORT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_SUPPORT_FLAGS ) +typedef +enum D3D12_VIDEO_ENCODER_MOTION_SEARCH_SUPPORT_FLAGS + { + D3D12_VIDEO_ENCODER_MOTION_SEARCH_SUPPORT_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_MOTION_SEARCH_SUPPORT_FLAG_SUPPORTED = 0x1, + D3D12_VIDEO_ENCODER_MOTION_SEARCH_SUPPORT_FLAG_MULTIPLE_HINTS = 0x2, + D3D12_VIDEO_ENCODER_MOTION_SEARCH_SUPPORT_FLAG_GPU_TEXTURE_MULTIPLE_REFERENCES = 0x4 + } D3D12_VIDEO_ENCODER_MOTION_SEARCH_SUPPORT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_ENCODER_MOTION_SEARCH_SUPPORT_FLAGS ) +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_MOTION_SEARCH + { + UINT NodeIndex; + D3D12_VIDEO_ENCODER_INPUT_MAP_SESSION_INFO SessionInfo; + D3D12_VIDEO_ENCODER_FRAME_MOTION_SEARCH_MODE MotionSearchMode; + D3D12_VIDEO_ENCODER_INPUT_MAP_SOURCE MapSource; + BOOL BidirectionalRefFrameEnabled; + D3D12_VIDEO_ENCODER_MOTION_SEARCH_SUPPORT_FLAGS SupportFlags; + UINT MaxMotionHints; + UINT MinDeviation; + UINT MaxDeviation; + UINT MapSourcePreferenceRanking; + D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_SUPPORT_FLAGS MotionUnitPrecisionSupport; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_MOTION_SEARCH; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLVE_INPUT_PARAM_LAYOUT + { + UINT NodeIndex; + D3D12_VIDEO_ENCODER_INPUT_MAP_SESSION_INFO SessionInfo; + D3D12_VIDEO_ENCODER_INPUT_MAP_TYPE MapType; + BOOL IsSupported; + UINT64 MaxResolvedBufferAllocationSize; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLVE_INPUT_PARAM_LAYOUT; + +typedef struct D3D12_VIDEO_ENCODER_QPMAP_CONFIGURATION + { + BOOL Enabled; + D3D12_VIDEO_ENCODER_INPUT_MAP_SOURCE MapSource; + } D3D12_VIDEO_ENCODER_QPMAP_CONFIGURATION; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_QPMAP + { + UINT MapSourcePreferenceRanking; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_QPMAP; + +typedef struct D3D12_VIDEO_ENCODER_DIRTY_REGIONS_CONFIGURATION + { + BOOL Enabled; + D3D12_VIDEO_ENCODER_INPUT_MAP_SOURCE MapSource; + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_MAP_VALUES_MODE MapValuesType; + } D3D12_VIDEO_ENCODER_DIRTY_REGIONS_CONFIGURATION; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_DIRTY_REGIONS + { + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_SUPPORT_FLAGS DirtyRegionsSupportFlags; + UINT MapSourcePreferenceRanking; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_DIRTY_REGIONS; + +typedef struct D3D12_VIDEO_ENCODER_MOTION_SEARCH_CONFIGURATION + { + BOOL Enabled; + D3D12_VIDEO_ENCODER_INPUT_MAP_SOURCE MapSource; + D3D12_VIDEO_ENCODER_FRAME_MOTION_SEARCH_MODE MotionSearchMode; + BOOL BidirectionalRefFrameEnabled; + } D3D12_VIDEO_ENCODER_MOTION_SEARCH_CONFIGURATION; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_MOTION_SEARCH + { + UINT MaxMotionHints; + UINT MinDeviation; + UINT MaxDeviation; + UINT MapSourcePreferenceRanking; + D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION_SUPPORT_FLAGS MotionUnitPrecisionSupportFlags; + D3D12_VIDEO_ENCODER_MOTION_SEARCH_SUPPORT_FLAGS SupportFlags; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_MOTION_SEARCH; + +typedef +enum D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAGS + { + D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAG_INTRACODED_FRAME_SUPPORTED = 0x1, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAG_UNIDIR_INTER_FRAME_SUPPORTED = 0x2, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAG_BIDIR_INTER_FRAME_SUPPORTED = 0x4, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAG_EXTERNAL_DPB_DOWNSCALING = 0x8, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAG_DYNAMIC_1ST_PASS_SKIP = 0x10, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAG_DYNAMIC_DOWNSCALE_FACTOR_CHANGE_KEY_FRAME = 0x20, + D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAG_SUPPORTED = ( ( D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAG_INTRACODED_FRAME_SUPPORTED | D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAG_UNIDIR_INTER_FRAME_SUPPORTED ) | D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAG_BIDIR_INTER_FRAME_SUPPORTED ) + } D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAGS ) +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS + { + UINT NodeIndex; + D3D12_VIDEO_ENCODER_CODEC Codec; + D3D12_VIDEO_ENCODER_PROFILE_DESC Profile; + D3D12_VIDEO_ENCODER_LEVEL_SETTING Level; + DXGI_FORMAT InputFormat; + D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC InputResolution; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION CodecConfiguration; + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE SubregionFrameEncoding; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA SubregionFrameEncodingData; + D3D12_VIDEO_ENCODER_QPMAP_CONFIGURATION QPMap; + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_CONFIGURATION DirtyRegions; + D3D12_VIDEO_ENCODER_MOTION_SEARCH_CONFIGURATION MotionSearch; + UINT Pow2DownscaleFactor; + D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAGS SupportFlags; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_FRAME_ANALYSIS + { + D3D12_VIDEO_ENCODER_RATE_CONTROL_FRAME_ANALYSIS_SUPPORT_FLAGS SupportFlags; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_FRAME_ANALYSIS; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS1 + { + UINT MaxSubregionsNumber; + UINT MaxIntraRefreshFrameDuration; + UINT SubregionBlockPixelsSize; + UINT QPMapRegionPixelsSize; + D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_QPMAP QPMap; + D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_DIRTY_REGIONS DirtyRegions; + D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_MOTION_SEARCH MotionSearch; + D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_FRAME_ANALYSIS FrameAnalysis; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS1; + +typedef struct D3D12_VIDEO_ENCODER_FRAME_ANALYSIS_CONFIGURATION + { + BOOL Enabled; + UINT Pow2DownscaleFactor; + } D3D12_VIDEO_ENCODER_FRAME_ANALYSIS_CONFIGURATION; + +typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT2 + { + UINT NodeIndex; + D3D12_VIDEO_ENCODER_CODEC Codec; + DXGI_FORMAT InputFormat; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION CodecConfiguration; + D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE CodecGopSequence; + D3D12_VIDEO_ENCODER_RATE_CONTROL RateControl; + D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE IntraRefresh; + D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE SubregionFrameEncoding; + UINT ResolutionsListCount; + const D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList; + UINT MaxReferenceFramesInDPB; + D3D12_VIDEO_ENCODER_VALIDATION_FLAGS ValidationFlags; + D3D12_VIDEO_ENCODER_SUPPORT_FLAGS SupportFlags; + D3D12_VIDEO_ENCODER_PROFILE_DESC SuggestedProfile; + D3D12_VIDEO_ENCODER_LEVEL_SETTING SuggestedLevel; + _Field_size_full_(ResolutionsListCount) D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS1 *pResolutionDependentSupport; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA SubregionFrameEncodingData; + UINT MaxQualityVsSpeed; + D3D12_VIDEO_ENCODER_QPMAP_CONFIGURATION QPMap; + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_CONFIGURATION DirtyRegions; + D3D12_VIDEO_ENCODER_MOTION_SEARCH_CONFIGURATION MotionSearch; + D3D12_VIDEO_ENCODER_FRAME_ANALYSIS_CONFIGURATION FrameAnalysis; + } D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT2; + +typedef struct D3D12_VIDEO_ENCODER_DIRTY_RECT_INFO + { + BOOL FullFrameIdentical; + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_MAP_VALUES_MODE MapValuesType; + UINT NumDirtyRects; + _Field_size_full_(NumDirtyRects) RECT *pDirtyRects; + UINT SourceDPBFrameReference; + } D3D12_VIDEO_ENCODER_DIRTY_RECT_INFO; + +typedef struct D3D12_VIDEO_ENCODER_DIRTY_REGIONS + { + D3D12_VIDEO_ENCODER_INPUT_MAP_SOURCE MapSource; + union + { + ID3D12Resource *pOpaqueLayoutBuffer; + D3D12_VIDEO_ENCODER_DIRTY_RECT_INFO *pCPUBuffer; + } ; + } D3D12_VIDEO_ENCODER_DIRTY_REGIONS; + +typedef struct D3D12_VIDEO_ENCODER_QUANTIZATION_OPAQUE_MAP + { + ID3D12Resource *pOpaqueQuantizationMap; + } D3D12_VIDEO_ENCODER_QUANTIZATION_OPAQUE_MAP; + +typedef struct D3D12_VIDEO_ENCODER_FRAME_MOTION_SEARCH_MODE_CONFIG + { + D3D12_VIDEO_ENCODER_FRAME_MOTION_SEARCH_MODE MotionSearchMode; + UINT SearchDeviationLimit; + } D3D12_VIDEO_ENCODER_FRAME_MOTION_SEARCH_MODE_CONFIG; + +typedef struct D3D12_VIDEO_ENCODER_MOVE_RECT + { + POINT SourcePoint; + RECT DestRect; + } D3D12_VIDEO_ENCODER_MOVE_RECT; + +typedef +enum D3D12_VIDEO_ENCODER_MOVEREGION_INFO_FLAGS + { + D3D12_VIDEO_ENCODER_MOVEREGION_INFO_FLAG_NONE = 0, + D3D12_VIDEO_ENCODER_MOVEREGION_INFO_FLAG_MULTIPLE_HINTS = 0x1 + } D3D12_VIDEO_ENCODER_MOVEREGION_INFO_FLAGS; + +typedef struct D3D12_VIDEO_ENCODER_MOVEREGION_INFO + { + UINT NumMoveRegions; + _Field_size_full_(NumMoveRegions) D3D12_VIDEO_ENCODER_MOVE_RECT *pMoveRegions; + D3D12_VIDEO_ENCODER_FRAME_MOTION_SEARCH_MODE_CONFIG MotionSearchModeConfiguration; + UINT SourceDPBFrameReference; + D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION MotionUnitPrecision; + D3D12_VIDEO_ENCODER_MOVEREGION_INFO_FLAGS Flags; + } D3D12_VIDEO_ENCODER_MOVEREGION_INFO; + +typedef struct D3D12_VIDEO_ENCODER_FRAME_MOTION_VECTORS + { + D3D12_VIDEO_ENCODER_INPUT_MAP_SOURCE MapSource; + union + { + ID3D12Resource *pOpaqueLayoutBuffer; + D3D12_VIDEO_ENCODER_MOVEREGION_INFO *pCPUBuffer; + } ; + } D3D12_VIDEO_ENCODER_FRAME_MOTION_VECTORS; + +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC2 + { + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS Flags; + D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC FrameType; + UINT slice_pic_parameter_set_id; + UINT PictureOrderCountNumber; + UINT TemporalLayerIndex; + UINT List0ReferenceFramesCount; + _Field_size_full_(List0ReferenceFramesCount) UINT *pList0ReferenceFrames; + UINT List1ReferenceFramesCount; + _Field_size_full_(List1ReferenceFramesCount) UINT *pList1ReferenceFrames; + UINT ReferenceFramesReconPictureDescriptorsCount; + _Field_size_full_(ReferenceFramesReconPictureDescriptorsCount) D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC *pReferenceFramesReconPictureDescriptors; + UINT List0RefPicModificationsCount; + _Field_size_full_(List0RefPicModificationsCount) UINT *pList0RefPicModifications; + UINT List1RefPicModificationsCount; + _Field_size_full_(List1RefPicModificationsCount) UINT *pList1RefPicModifications; + UINT QPMapValuesCount; + _Field_size_full_(QPMapValuesCount) INT8 *pRateControlQPMap; + UCHAR diff_cu_chroma_qp_offset_depth; + UCHAR log2_sao_offset_scale_luma; + UCHAR log2_sao_offset_scale_chroma; + UCHAR log2_max_transform_skip_block_size_minus2; + UCHAR chroma_qp_offset_list_len_minus1; + CHAR cb_qp_offset_list[ 6 ]; + CHAR cr_qp_offset_list[ 6 ]; + UINT num_ref_idx_l0_active_minus1; + UINT num_ref_idx_l1_active_minus1; + } D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC2; + +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA1 + { + UINT DataSize; + union + { + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264 *pH264PicData; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC2 *pHEVCPicData; + D3D12_VIDEO_ENCODER_AV1_PICTURE_CONTROL_CODEC_DATA *pAV1PicData; + } ; + } D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA1; + +typedef struct D3D12_VIDEO_ENCODER_FRAME_ANALYSIS + { + ID3D12Resource *pDownscaledFrame; + UINT64 Subresource; + D3D12_VIDEO_ENCODE_REFERENCE_FRAMES DownscaledReferences; + } D3D12_VIDEO_ENCODER_FRAME_ANALYSIS; + +typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC1 + { + UINT IntraRefreshFrameIndex; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS Flags; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA1 PictureControlCodecData; + D3D12_VIDEO_ENCODE_REFERENCE_FRAMES ReferenceFrames; + D3D12_VIDEO_ENCODER_FRAME_MOTION_VECTORS MotionVectors; + D3D12_VIDEO_ENCODER_DIRTY_REGIONS DirtyRects; + D3D12_VIDEO_ENCODER_QUANTIZATION_OPAQUE_MAP QuantizationTextureMap; + D3D12_VIDEO_ENCODER_FRAME_ANALYSIS FrameAnalysis; + } D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC1; + +typedef struct D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS1 + { + D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC SequenceControlDesc; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC1 PictureControlDesc; + ID3D12Resource *pInputFrame; + UINT InputFrameSubresource; + UINT CurrentFrameBitstreamMetadataSize; + D3D12_VIDEO_ENCODER_OPTIONAL_METADATA_ENABLE_FLAGS OptionalMetadata; + } D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS1; + +typedef +enum D3D12_VIDEO_ENCODER_SUBREGION_COMPRESSED_BITSTREAM_BUFFER_MODE + { + D3D12_VIDEO_ENCODER_SUBREGION_COMPRESSED_BITSTREAM_BUFFER_MODE_ARRAY_OF_BUFFERS = 0, + D3D12_VIDEO_ENCODER_SUBREGION_COMPRESSED_BITSTREAM_BUFFER_MODE_SINGLE_BUFFER = 1 + } D3D12_VIDEO_ENCODER_SUBREGION_COMPRESSED_BITSTREAM_BUFFER_MODE; + +typedef struct D3D12_VIDEO_ENCODER_SUBREGION_COMPRESSED_BITSTREAM + { + D3D12_VIDEO_ENCODER_SUBREGION_COMPRESSED_BITSTREAM_BUFFER_MODE BufferMode; + UINT ExpectedSubregionCount; + UINT64 *pSubregionBitstreamsBaseOffsets; + ID3D12Resource **ppSubregionBitstreams; + ID3D12Resource **ppSubregionSizes; + ID3D12Resource **ppSubregionOffsets; + ID3D12Fence **ppSubregionFences; + UINT64 *pSubregionFenceValues; + } D3D12_VIDEO_ENCODER_SUBREGION_COMPRESSED_BITSTREAM; + +typedef +enum D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM_NOTIFICATION_MODE + { + D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM_NOTIFICATION_MODE_FULL_FRAME = 0, + D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM_NOTIFICATION_MODE_SUBREGIONS = 1 + } D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM_NOTIFICATION_MODE; + +typedef struct D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM1 + { + D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM_NOTIFICATION_MODE NotificationMode; + union + { + D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM FrameOutputBuffer; + D3D12_VIDEO_ENCODER_SUBREGION_COMPRESSED_BITSTREAM SubregionOutputBuffers; + } ; + } D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM1; + +typedef struct D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS1 + { + D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM1 Bitstream; + D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE ReconstructedPicture; + D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER EncoderOutputMetadata; + D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE FrameAnalysisReconstructedPicture; + } D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS1; + +typedef struct D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS1 + { + D3D12_VIDEO_ENCODER_CODEC EncoderCodec; + D3D12_VIDEO_ENCODER_PROFILE_DESC EncoderProfile; + DXGI_FORMAT EncoderInputFormat; + D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC EncodedPictureEffectiveResolution; + D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER HWLayoutMetadata; + D3D12_VIDEO_ENCODER_OPTIONAL_METADATA_ENABLE_FLAGS OptionalMetadata; + D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION CodecConfiguration; + } D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS1; + +typedef struct D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS1 + { + D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER ResolvedLayoutMetadata; + ID3D12Resource *pOutputQPMap; + ID3D12Resource *pOutputSATDMap; + ID3D12Resource *pOutputBitAllocationMap; + D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER ResolvedFramePSNRData; + D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER ResolvedSubregionsPSNRData; + } D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS1; + +typedef struct D3D12_VIDEO_ENCODER_INPUT_MAP_DATA_QUANTIZATION_MATRIX + { + ID3D12Resource *pQuantizationMap; + } D3D12_VIDEO_ENCODER_INPUT_MAP_DATA_QUANTIZATION_MATRIX; + +typedef struct D3D12_VIDEO_ENCODER_INPUT_MAP_DATA_DIRTY_REGIONS + { + BOOL FullFrameIdentical; + D3D12_VIDEO_ENCODER_DIRTY_REGIONS_MAP_VALUES_MODE MapValuesType; + ID3D12Resource *pDirtyRegionsMap; + UINT SourceDPBFrameReference; + } D3D12_VIDEO_ENCODER_INPUT_MAP_DATA_DIRTY_REGIONS; + +typedef struct D3D12_VIDEO_ENCODER_INPUT_MAP_DATA_MOTION_VECTORS + { + D3D12_VIDEO_ENCODER_FRAME_MOTION_SEARCH_MODE_CONFIG MotionSearchModeConfiguration; + UINT NumHintsPerPixel; + _Field_size_full_(NumHintsPerPixel) ID3D12Resource **ppMotionVectorMaps; + _Field_size_full_(NumHintsPerPixel) UINT *pMotionVectorMapsSubresources; + _Field_size_full_(NumHintsPerPixel) ID3D12Resource **ppMotionVectorMapsMetadata; + _Field_size_full_(NumHintsPerPixel) UINT *pMotionVectorMapsMetadataSubresources; + D3D12_VIDEO_ENCODER_FRAME_INPUT_MOTION_UNIT_PRECISION MotionUnitPrecision; + D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA1 PictureControlConfiguration; + } D3D12_VIDEO_ENCODER_INPUT_MAP_DATA_MOTION_VECTORS; + +typedef struct D3D12_VIDEO_ENCODER_INPUT_MAP_DATA + { + D3D12_VIDEO_ENCODER_INPUT_MAP_TYPE MapType; + union + { + D3D12_VIDEO_ENCODER_INPUT_MAP_DATA_QUANTIZATION_MATRIX Quantization; + D3D12_VIDEO_ENCODER_INPUT_MAP_DATA_DIRTY_REGIONS DirtyRegions; + D3D12_VIDEO_ENCODER_INPUT_MAP_DATA_MOTION_VECTORS MotionVectors; + } ; + } D3D12_VIDEO_ENCODER_INPUT_MAP_DATA; + +typedef struct D3D12_VIDEO_ENCODER_RESOLVE_INPUT_PARAM_LAYOUT_INPUT_ARGUMENTS + { + D3D12_VIDEO_ENCODER_INPUT_MAP_SESSION_INFO SessionInfo; + D3D12_VIDEO_ENCODER_INPUT_MAP_DATA InputData; + } D3D12_VIDEO_ENCODER_RESOLVE_INPUT_PARAM_LAYOUT_INPUT_ARGUMENTS; + +typedef struct D3D12_VIDEO_ENCODER_RESOLVE_INPUT_PARAM_LAYOUT_OUTPUT_ARGUMENTS + { + ID3D12Resource *pOpaqueLayoutBuffer; + } D3D12_VIDEO_ENCODER_RESOLVE_INPUT_PARAM_LAYOUT_OUTPUT_ARGUMENTS; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0029_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0029_v0_0_s_ifspec; + +#ifndef __ID3D12VideoEncodeCommandList4_INTERFACE_DEFINED__ +#define __ID3D12VideoEncodeCommandList4_INTERFACE_DEFINED__ + +/* interface ID3D12VideoEncodeCommandList4 */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3D12VideoEncodeCommandList4; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("69aeb5b7-55f2-4012-8b73-3a88d65a204c") + ID3D12VideoEncodeCommandList4 : public ID3D12VideoEncodeCommandList3 + { + public: + virtual void STDMETHODCALLTYPE EncodeFrame1( + _In_ ID3D12VideoEncoder *pEncoder, + _In_ ID3D12VideoEncoderHeap1 *pHeap, + _In_ const D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS1 *pInputArguments, + _In_ const D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS1 *pOutputArguments) = 0; + + virtual void STDMETHODCALLTYPE ResolveEncoderOutputMetadata1( + _In_ const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS1 *pInputArguments, + _In_ const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS1 *pOutputArguments) = 0; + + virtual void STDMETHODCALLTYPE ResolveInputParamLayout( + _In_ const D3D12_VIDEO_ENCODER_RESOLVE_INPUT_PARAM_LAYOUT_INPUT_ARGUMENTS *pInputArguments, + _In_ const D3D12_VIDEO_ENCODER_RESOLVE_INPUT_PARAM_LAYOUT_OUTPUT_ARGUMENTS *pOutputArguments) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3D12VideoEncodeCommandList4Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3D12VideoEncodeCommandList4 * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3D12VideoEncodeCommandList4 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3D12VideoEncodeCommandList4 * This); + + DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData) + HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( + ID3D12VideoEncodeCommandList4 * This, + _In_ REFGUID guid, + _Inout_ UINT *pDataSize, + _Out_writes_bytes_opt_( *pDataSize ) void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData) + HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( + ID3D12VideoEncodeCommandList4 * This, + _In_ REFGUID guid, + _In_ UINT DataSize, + _In_reads_bytes_opt_( DataSize ) const void *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface) + HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( + ID3D12VideoEncodeCommandList4 * This, + _In_ REFGUID guid, + _In_opt_ const IUnknown *pData); + + DECLSPEC_XFGVIRT(ID3D12Object, SetName) + HRESULT ( STDMETHODCALLTYPE *SetName )( + ID3D12VideoEncodeCommandList4 * This, + _In_z_ LPCWSTR Name); + + DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice) + HRESULT ( STDMETHODCALLTYPE *GetDevice )( + ID3D12VideoEncodeCommandList4 * This, + REFIID riid, + _COM_Outptr_opt_ void **ppvDevice); + + DECLSPEC_XFGVIRT(ID3D12CommandList, GetType) + D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( + ID3D12VideoEncodeCommandList4 * This); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Close) + HRESULT ( STDMETHODCALLTYPE *Close )( + ID3D12VideoEncodeCommandList4 * This); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Reset) + HRESULT ( STDMETHODCALLTYPE *Reset )( + ID3D12VideoEncodeCommandList4 * This, + _In_ ID3D12CommandAllocator *pAllocator); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ClearState) + void ( STDMETHODCALLTYPE *ClearState )( + ID3D12VideoEncodeCommandList4 * This); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResourceBarrier) + void ( STDMETHODCALLTYPE *ResourceBarrier )( + ID3D12VideoEncodeCommandList4 * This, + _In_ UINT NumBarriers, + _In_reads_(NumBarriers) const D3D12_RESOURCE_BARRIER *pBarriers); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, DiscardResource) + void ( STDMETHODCALLTYPE *DiscardResource )( + ID3D12VideoEncodeCommandList4 * This, + _In_ ID3D12Resource *pResource, + _In_opt_ const D3D12_DISCARD_REGION *pRegion); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginQuery) + void ( STDMETHODCALLTYPE *BeginQuery )( + ID3D12VideoEncodeCommandList4 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndQuery) + void ( STDMETHODCALLTYPE *EndQuery )( + ID3D12VideoEncodeCommandList4 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT Index); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveQueryData) + void ( STDMETHODCALLTYPE *ResolveQueryData )( + ID3D12VideoEncodeCommandList4 * This, + _In_ ID3D12QueryHeap *pQueryHeap, + _In_ D3D12_QUERY_TYPE Type, + _In_ UINT StartIndex, + _In_ UINT NumQueries, + _In_ ID3D12Resource *pDestinationBuffer, + _In_ UINT64 AlignedDestinationBufferOffset); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetPredication) + void ( STDMETHODCALLTYPE *SetPredication )( + ID3D12VideoEncodeCommandList4 * This, + _In_opt_ ID3D12Resource *pBuffer, + _In_ UINT64 AlignedBufferOffset, + _In_ D3D12_PREDICATION_OP Operation); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetMarker) + void ( STDMETHODCALLTYPE *SetMarker )( + ID3D12VideoEncodeCommandList4 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginEvent) + void ( STDMETHODCALLTYPE *BeginEvent )( + ID3D12VideoEncodeCommandList4 * This, + UINT Metadata, + _In_reads_bytes_opt_(Size) const void *pData, + UINT Size); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndEvent) + void ( STDMETHODCALLTYPE *EndEvent )( + ID3D12VideoEncodeCommandList4 * This); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EstimateMotion) + void ( STDMETHODCALLTYPE *EstimateMotion )( + ID3D12VideoEncodeCommandList4 * This, + _In_ ID3D12VideoMotionEstimator *pMotionEstimator, + _In_ const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *pOutputArguments, + _In_ const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *pInputArguments); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveMotionVectorHeap) + void ( STDMETHODCALLTYPE *ResolveMotionVectorHeap )( + ID3D12VideoEncodeCommandList4 * This, + const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *pOutputArguments, + const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *pInputArguments); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, WriteBufferImmediate) + void ( STDMETHODCALLTYPE *WriteBufferImmediate )( + ID3D12VideoEncodeCommandList4 * This, + UINT Count, + _In_reads_(Count) const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams, + _In_reads_opt_(Count) const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetProtectedResourceSession) + void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( + ID3D12VideoEncodeCommandList4 * This, + _In_opt_ ID3D12ProtectedResourceSession *pProtectedResourceSession); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, InitializeExtensionCommand) + void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( + ID3D12VideoEncodeCommandList4 * This, + _In_ ID3D12VideoExtensionCommand *pExtensionCommand, + _In_reads_bytes_(InitializationParametersSizeInBytes) const void *pInitializationParameters, + SIZE_T InitializationParametersSizeInBytes); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, ExecuteExtensionCommand) + void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( + ID3D12VideoEncodeCommandList4 * This, + _In_ ID3D12VideoExtensionCommand *pExtensionCommand, + _In_reads_bytes_(ExecutionParametersSizeInBytes) const void *pExecutionParameters, + SIZE_T ExecutionParametersSizeInBytes); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList2, EncodeFrame) + void ( STDMETHODCALLTYPE *EncodeFrame )( + ID3D12VideoEncodeCommandList4 * This, + _In_ ID3D12VideoEncoder *pEncoder, + _In_ ID3D12VideoEncoderHeap *pHeap, + _In_ const D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS *pInputArguments, + _In_ const D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS *pOutputArguments); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList2, ResolveEncoderOutputMetadata) + void ( STDMETHODCALLTYPE *ResolveEncoderOutputMetadata )( + ID3D12VideoEncodeCommandList4 * This, + _In_ const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS *pInputArguments, + _In_ const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS *pOutputArguments); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList3, Barrier) + void ( STDMETHODCALLTYPE *Barrier )( + ID3D12VideoEncodeCommandList4 * This, + UINT32 NumBarrierGroups, + _In_reads_(NumBarrierGroups) const D3D12_BARRIER_GROUP *pBarrierGroups); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList4, EncodeFrame1) + void ( STDMETHODCALLTYPE *EncodeFrame1 )( + ID3D12VideoEncodeCommandList4 * This, + _In_ ID3D12VideoEncoder *pEncoder, + _In_ ID3D12VideoEncoderHeap1 *pHeap, + _In_ const D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS1 *pInputArguments, + _In_ const D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS1 *pOutputArguments); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList4, ResolveEncoderOutputMetadata1) + void ( STDMETHODCALLTYPE *ResolveEncoderOutputMetadata1 )( + ID3D12VideoEncodeCommandList4 * This, + _In_ const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS1 *pInputArguments, + _In_ const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS1 *pOutputArguments); + + DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList4, ResolveInputParamLayout) + void ( STDMETHODCALLTYPE *ResolveInputParamLayout )( + ID3D12VideoEncodeCommandList4 * This, + _In_ const D3D12_VIDEO_ENCODER_RESOLVE_INPUT_PARAM_LAYOUT_INPUT_ARGUMENTS *pInputArguments, + _In_ const D3D12_VIDEO_ENCODER_RESOLVE_INPUT_PARAM_LAYOUT_OUTPUT_ARGUMENTS *pOutputArguments); + + END_INTERFACE + } ID3D12VideoEncodeCommandList4Vtbl; + + interface ID3D12VideoEncodeCommandList4 + { + CONST_VTBL struct ID3D12VideoEncodeCommandList4Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3D12VideoEncodeCommandList4_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3D12VideoEncodeCommandList4_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3D12VideoEncodeCommandList4_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3D12VideoEncodeCommandList4_GetPrivateData(This,guid,pDataSize,pData) \ + ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) + +#define ID3D12VideoEncodeCommandList4_SetPrivateData(This,guid,DataSize,pData) \ + ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) + +#define ID3D12VideoEncodeCommandList4_SetPrivateDataInterface(This,guid,pData) \ + ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) + +#define ID3D12VideoEncodeCommandList4_SetName(This,Name) \ + ( (This)->lpVtbl -> SetName(This,Name) ) + + +#define ID3D12VideoEncodeCommandList4_GetDevice(This,riid,ppvDevice) \ + ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) + + +#define ID3D12VideoEncodeCommandList4_GetType(This) \ + ( (This)->lpVtbl -> GetType(This) ) + + +#define ID3D12VideoEncodeCommandList4_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + +#define ID3D12VideoEncodeCommandList4_Reset(This,pAllocator) \ + ( (This)->lpVtbl -> Reset(This,pAllocator) ) + +#define ID3D12VideoEncodeCommandList4_ClearState(This) \ + ( (This)->lpVtbl -> ClearState(This) ) + +#define ID3D12VideoEncodeCommandList4_ResourceBarrier(This,NumBarriers,pBarriers) \ + ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) + +#define ID3D12VideoEncodeCommandList4_DiscardResource(This,pResource,pRegion) \ + ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) + +#define ID3D12VideoEncodeCommandList4_BeginQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12VideoEncodeCommandList4_EndQuery(This,pQueryHeap,Type,Index) \ + ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) + +#define ID3D12VideoEncodeCommandList4_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) \ + ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) + +#define ID3D12VideoEncodeCommandList4_SetPredication(This,pBuffer,AlignedBufferOffset,Operation) \ + ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) + +#define ID3D12VideoEncodeCommandList4_SetMarker(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) + +#define ID3D12VideoEncodeCommandList4_BeginEvent(This,Metadata,pData,Size) \ + ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) + +#define ID3D12VideoEncodeCommandList4_EndEvent(This) \ + ( (This)->lpVtbl -> EndEvent(This) ) + +#define ID3D12VideoEncodeCommandList4_EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments) \ + ( (This)->lpVtbl -> EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments) ) + +#define ID3D12VideoEncodeCommandList4_ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments) \ + ( (This)->lpVtbl -> ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments) ) + +#define ID3D12VideoEncodeCommandList4_WriteBufferImmediate(This,Count,pParams,pModes) \ + ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) + +#define ID3D12VideoEncodeCommandList4_SetProtectedResourceSession(This,pProtectedResourceSession) \ + ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) + + +#define ID3D12VideoEncodeCommandList4_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) \ + ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) + +#define ID3D12VideoEncodeCommandList4_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) \ + ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) + + +#define ID3D12VideoEncodeCommandList4_EncodeFrame(This,pEncoder,pHeap,pInputArguments,pOutputArguments) \ + ( (This)->lpVtbl -> EncodeFrame(This,pEncoder,pHeap,pInputArguments,pOutputArguments) ) + +#define ID3D12VideoEncodeCommandList4_ResolveEncoderOutputMetadata(This,pInputArguments,pOutputArguments) \ + ( (This)->lpVtbl -> ResolveEncoderOutputMetadata(This,pInputArguments,pOutputArguments) ) + + +#define ID3D12VideoEncodeCommandList4_Barrier(This,NumBarrierGroups,pBarrierGroups) \ + ( (This)->lpVtbl -> Barrier(This,NumBarrierGroups,pBarrierGroups) ) + + +#define ID3D12VideoEncodeCommandList4_EncodeFrame1(This,pEncoder,pHeap,pInputArguments,pOutputArguments) \ + ( (This)->lpVtbl -> EncodeFrame1(This,pEncoder,pHeap,pInputArguments,pOutputArguments) ) + +#define ID3D12VideoEncodeCommandList4_ResolveEncoderOutputMetadata1(This,pInputArguments,pOutputArguments) \ + ( (This)->lpVtbl -> ResolveEncoderOutputMetadata1(This,pInputArguments,pOutputArguments) ) + +#define ID3D12VideoEncodeCommandList4_ResolveInputParamLayout(This,pInputArguments,pOutputArguments) \ + ( (This)->lpVtbl -> ResolveInputParamLayout(This,pInputArguments,pOutputArguments) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3D12VideoEncodeCommandList4_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3d12video_0000_0030 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ +#pragma endregion +DEFINE_GUID(IID_ID3D12VideoDecoderHeap,0x0946B7C9,0xEBF6,0x4047,0xBB,0x73,0x86,0x83,0xE2,0x7D,0xBB,0x1F); +DEFINE_GUID(IID_ID3D12VideoDevice,0x1F052807,0x0B46,0x4ACC,0x8A,0x89,0x36,0x4F,0x79,0x37,0x18,0xA4); +DEFINE_GUID(IID_ID3D12VideoDecoder,0xC59B6BDC,0x7720,0x4074,0xA1,0x36,0x17,0xA1,0x56,0x03,0x74,0x70); +DEFINE_GUID(IID_ID3D12VideoProcessor,0x304FDB32,0xBEDE,0x410A,0x85,0x45,0x94,0x3A,0xC6,0xA4,0x61,0x38); +DEFINE_GUID(IID_ID3D12VideoDecodeCommandList,0x3B60536E,0xAD29,0x4E64,0xA2,0x69,0xF8,0x53,0x83,0x7E,0x5E,0x53); +DEFINE_GUID(IID_ID3D12VideoProcessCommandList,0xAEB2543A,0x167F,0x4682,0xAC,0xC8,0xD1,0x59,0xED,0x4A,0x62,0x09); +DEFINE_GUID(IID_ID3D12VideoDecodeCommandList1,0xD52F011B,0xB56E,0x453C,0xA0,0x5A,0xA7,0xF3,0x11,0xC8,0xF4,0x72); +DEFINE_GUID(IID_ID3D12VideoProcessCommandList1,0x542C5C4D,0x7596,0x434F,0x8C,0x93,0x4E,0xFA,0x67,0x66,0xF2,0x67); +DEFINE_GUID(IID_ID3D12VideoMotionEstimator,0x33FDAE0E,0x098B,0x428F,0x87,0xBB,0x34,0xB6,0x95,0xDE,0x08,0xF8); +DEFINE_GUID(IID_ID3D12VideoMotionVectorHeap,0x5BE17987,0x743A,0x4061,0x83,0x4B,0x23,0xD2,0x2D,0xAE,0xA5,0x05); +DEFINE_GUID(IID_ID3D12VideoDevice1,0x981611AD,0xA144,0x4C83,0x98,0x90,0xF3,0x0E,0x26,0xD6,0x58,0xAB); +DEFINE_GUID(IID_ID3D12VideoEncodeCommandList,0x8455293A,0x0CBD,0x4831,0x9B,0x39,0xFB,0xDB,0xAB,0x72,0x47,0x23); +DEFINE_GUID(IID_ID3D12VideoDecoder1,0x79A2E5FB,0xCCD2,0x469A,0x9F,0xDE,0x19,0x5D,0x10,0x95,0x1F,0x7E); +DEFINE_GUID(IID_ID3D12VideoDecoderHeap1,0xDA1D98C5,0x539F,0x41B2,0xBF,0x6B,0x11,0x98,0xA0,0x3B,0x6D,0x26); +DEFINE_GUID(IID_ID3D12VideoProcessor1,0xF3CFE615,0x553F,0x425C,0x86,0xD8,0xEE,0x8C,0x1B,0x1F,0xB0,0x1C); +DEFINE_GUID(IID_ID3D12VideoExtensionCommand,0x554E41E8,0xAE8E,0x4A8C,0xB7,0xD2,0x5B,0x4F,0x27,0x4A,0x30,0xE4); +DEFINE_GUID(IID_ID3D12VideoDevice2,0xF019AC49,0xF838,0x4A95,0x9B,0x17,0x57,0x94,0x37,0xC8,0xF5,0x13); +DEFINE_GUID(IID_ID3D12VideoDecodeCommandList2,0x6e120880,0xc114,0x4153,0x80,0x36,0xd2,0x47,0x05,0x1e,0x17,0x29); +DEFINE_GUID(IID_ID3D12VideoDecodeCommandList3,0x2aee8c37,0x9562,0x42da,0x8a,0xbf,0x61,0xef,0xeb,0x2e,0x45,0x13); +DEFINE_GUID(IID_ID3D12VideoProcessCommandList2,0xdb525ae4,0x6ad6,0x473c,0xba,0xa7,0x59,0xb2,0xe3,0x70,0x82,0xe4); +DEFINE_GUID(IID_ID3D12VideoProcessCommandList3,0x1a0a4ca4,0x9f08,0x40ce,0x95,0x58,0xb4,0x11,0xfd,0x26,0x66,0xff); +DEFINE_GUID(IID_ID3D12VideoEncodeCommandList1,0x94971eca,0x2bdb,0x4769,0x88,0xcf,0x36,0x75,0xea,0x75,0x7e,0xbc); +DEFINE_GUID(IID_ID3D12VideoEncoder,0x2E0D212D,0x8DF9,0x44A6,0xA7,0x70,0xBB,0x28,0x9B,0x18,0x27,0x37); +DEFINE_GUID(IID_ID3D12VideoEncoderHeap,0x22B35D96,0x876A,0x44C0,0xB2,0x5E,0xFB,0x8C,0x9C,0x7F,0x1C,0x4A); +DEFINE_GUID(IID_ID3D12VideoDevice3,0x4243ADB4,0x3A32,0x4666,0x97,0x3C,0x0C,0xCC,0x56,0x25,0xDC,0x44); +DEFINE_GUID(IID_ID3D12VideoEncodeCommandList2,0x895491e2,0xe701,0x46a9,0x9a,0x1f,0x8d,0x34,0x80,0xed,0x86,0x7a); +DEFINE_GUID(IID_ID3D12VideoEncodeCommandList3,0x7f027b22,0x1515,0x4e85,0xaa,0x0d,0x02,0x64,0x86,0x58,0x05,0x76); +DEFINE_GUID(IID_ID3D12VideoEncoderHeap1,0xea8f1968,0x4aa0,0x43a4,0x9d,0x30,0xba,0x86,0xec,0x84,0xd4,0xf9); +DEFINE_GUID(IID_ID3D12VideoDevice4,0xe59ad09e,0xf1ae,0x42bb,0x89,0x83,0x9f,0x6e,0x55,0x86,0xc4,0xeb); +DEFINE_GUID(IID_ID3D12VideoEncodeCommandList4,0x69aeb5b7,0x55f2,0x4012,0x8b,0x73,0x3a,0x88,0xd6,0x5a,0x20,0x4c); + + +extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0030_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0030_v0_0_s_ifspec; /* Additional Prototypes for ALL interfaces */ diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/d3dcommon.h b/libs/bgfx/3rdparty/directx-headers/include/directx/d3dcommon.h index f7e455d..2e2418d 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/d3dcommon.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/d3dcommon.h @@ -16,7 +16,7 @@ /* verify that the version is high enough to compile this file*/ #ifndef __REQUIRED_RPCNDR_H_VERSION__ -#define __REQUIRED_RPCNDR_H_VERSION__ 475 +#define __REQUIRED_RPCNDR_H_VERSION__ 500 #endif /* verify that the version is high enough to compile this file*/ @@ -93,6 +93,7 @@ enum D3D_DRIVER_TYPE typedef enum D3D_FEATURE_LEVEL { + D3D_FEATURE_LEVEL_1_0_GENERIC = 0x100, D3D_FEATURE_LEVEL_1_0_CORE = 0x1000, D3D_FEATURE_LEVEL_9_1 = 0x9100, D3D_FEATURE_LEVEL_9_2 = 0x9200, @@ -389,6 +390,10 @@ enum D3D_SRV_DIMENSION #define D3D_SHADER_FEATURE_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE 0x10000000 #define D3D_SHADER_FEATURE_ADVANCED_TEXTURE_OPS 0x20000000 #define D3D_SHADER_FEATURE_WRITEABLE_MSAA_TEXTURES 0x40000000 +#define D3D_SHADER_FEATURE_SAMPLE_CMP_GRADIENT_OR_BIAS 0x80000000 +#define D3D_SHADER_FEATURE_EXTENDED_COMMAND_INFO 0x100000000ull +#define D3D_OPT_SHADER_FEATURE_USES_DERIVATIVES 0x0000010000000000ull +#define D3D_OPT_SHADER_FEATURE_REQUIRES_GROUP 0x0000020000000000ull typedef struct _D3D_SHADER_MACRO { LPCSTR Name; @@ -960,10 +965,22 @@ enum D3D_REGISTER_COMPONENT_TYPE D3D_REGISTER_COMPONENT_UINT32 = 1, D3D_REGISTER_COMPONENT_SINT32 = 2, D3D_REGISTER_COMPONENT_FLOAT32 = 3, + D3D_REGISTER_COMPONENT_UINT16 = 4, + D3D_REGISTER_COMPONENT_SINT16 = 5, + D3D_REGISTER_COMPONENT_FLOAT16 = 6, + D3D_REGISTER_COMPONENT_UINT64 = 7, + D3D_REGISTER_COMPONENT_SINT64 = 8, + D3D_REGISTER_COMPONENT_FLOAT64 = 9, D3D10_REGISTER_COMPONENT_UNKNOWN = D3D_REGISTER_COMPONENT_UNKNOWN, D3D10_REGISTER_COMPONENT_UINT32 = D3D_REGISTER_COMPONENT_UINT32, D3D10_REGISTER_COMPONENT_SINT32 = D3D_REGISTER_COMPONENT_SINT32, - D3D10_REGISTER_COMPONENT_FLOAT32 = D3D_REGISTER_COMPONENT_FLOAT32 + D3D10_REGISTER_COMPONENT_FLOAT32 = D3D_REGISTER_COMPONENT_FLOAT32, + D3D10_REGISTER_COMPONENT_UINT16 = D3D_REGISTER_COMPONENT_UINT16, + D3D10_REGISTER_COMPONENT_SINT16 = D3D_REGISTER_COMPONENT_SINT16, + D3D10_REGISTER_COMPONENT_FLOAT16 = D3D_REGISTER_COMPONENT_FLOAT16, + D3D10_REGISTER_COMPONENT_UINT64 = D3D_REGISTER_COMPONENT_UINT64, + D3D10_REGISTER_COMPONENT_SINT64 = D3D_REGISTER_COMPONENT_SINT64, + D3D10_REGISTER_COMPONENT_FLOAT64 = D3D_REGISTER_COMPONENT_FLOAT64 } D3D_REGISTER_COMPONENT_TYPE; typedef diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/d3dshadercacheregistration.h b/libs/bgfx/3rdparty/directx-headers/include/directx/d3dshadercacheregistration.h new file mode 100644 index 0000000..671866a --- /dev/null +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/d3dshadercacheregistration.h @@ -0,0 +1,998 @@ +/*------------------------------------------------------------------------------------- + * + * Copyright (c) Microsoft Corporation + * Licensed under the MIT license + * + *-------------------------------------------------------------------------------------*/ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.01.0628 */ + + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCSAL_H_VERSION__ +#define __REQUIRED_RPCSAL_H_VERSION__ 100 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif /* __RPCNDR_H_VERSION__ */ + +#ifndef COM_NO_WINDOWS_H +#include "windows.h" +#include "ole2.h" +#endif /*COM_NO_WINDOWS_H*/ + +#ifndef __d3dshadercacheregistration_h__ +#define __d3dshadercacheregistration_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +#ifndef DECLSPEC_XFGVIRT +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func)) +#else +#define DECLSPEC_XFGVIRT(base, func) +#endif +#endif + +/* Forward Declarations */ + +#ifndef __ID3DShaderCacheInstallerClient_FWD_DEFINED__ +#define __ID3DShaderCacheInstallerClient_FWD_DEFINED__ +typedef interface ID3DShaderCacheInstallerClient ID3DShaderCacheInstallerClient; + +#endif /* __ID3DShaderCacheInstallerClient_FWD_DEFINED__ */ + + +#ifndef __ID3DShaderCacheComponent_FWD_DEFINED__ +#define __ID3DShaderCacheComponent_FWD_DEFINED__ +typedef interface ID3DShaderCacheComponent ID3DShaderCacheComponent; + +#endif /* __ID3DShaderCacheComponent_FWD_DEFINED__ */ + + +#ifndef __ID3DShaderCacheApplication_FWD_DEFINED__ +#define __ID3DShaderCacheApplication_FWD_DEFINED__ +typedef interface ID3DShaderCacheApplication ID3DShaderCacheApplication; + +#endif /* __ID3DShaderCacheApplication_FWD_DEFINED__ */ + + +#ifndef __ID3DShaderCacheInstaller_FWD_DEFINED__ +#define __ID3DShaderCacheInstaller_FWD_DEFINED__ +typedef interface ID3DShaderCacheInstaller ID3DShaderCacheInstaller; + +#endif /* __ID3DShaderCacheInstaller_FWD_DEFINED__ */ + + +#ifndef __ID3DShaderCacheExplorer_FWD_DEFINED__ +#define __ID3DShaderCacheExplorer_FWD_DEFINED__ +typedef interface ID3DShaderCacheExplorer ID3DShaderCacheExplorer; + +#endif /* __ID3DShaderCacheExplorer_FWD_DEFINED__ */ + + +#ifndef __ID3DShaderCacheInstallerFactory_FWD_DEFINED__ +#define __ID3DShaderCacheInstallerFactory_FWD_DEFINED__ +typedef interface ID3DShaderCacheInstallerFactory ID3DShaderCacheInstallerFactory; + +#endif /* __ID3DShaderCacheInstallerFactory_FWD_DEFINED__ */ + + +/* header files for imported files */ +#include "oaidl.h" +#include "ocidl.h" + +#ifdef __cplusplus +extern "C"{ +#endif + + +/* interface __MIDL_itf_d3dshadercacheregistration_0000_0000 */ +/* [local] */ + +#pragma once +DEFINE_GUID(CLSID_D3DShaderCacheInstallerFactory, 0x16195a0b, 0x607c, 0x41f1, 0xbf, 0x03, 0xc7, 0x69, 0x4d, 0x60, 0xa8, 0xd4); +typedef +enum D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE + { + D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE_USER = 0, + D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE_SYSTEM = ( D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE_USER + 1 ) + } D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE; + + + + +extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0000_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0000_v0_0_s_ifspec; + +#ifndef __ID3DShaderCacheInstallerClient_INTERFACE_DEFINED__ +#define __ID3DShaderCacheInstallerClient_INTERFACE_DEFINED__ + +/* interface ID3DShaderCacheInstallerClient */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3DShaderCacheInstallerClient; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("a16ee930-d9f6-4222-a514-244473e5d266") + ID3DShaderCacheInstallerClient + { + public: + BEGIN_INTERFACE + virtual HRESULT STDMETHODCALLTYPE GetInstallerName( + _Inout_ SIZE_T *pNameLength, + _Out_writes_opt_(*pNameLength) wchar_t *pName) = 0; + + virtual D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE STDMETHODCALLTYPE GetInstallerScope( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE HandleDriverUpdate( + _In_ ID3DShaderCacheInstaller *pInstaller) = 0; + + END_INTERFACE + }; + + +#else /* C style interface */ + + typedef struct ID3DShaderCacheInstallerClientVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstallerClient, GetInstallerName) + HRESULT ( STDMETHODCALLTYPE *GetInstallerName )( + ID3DShaderCacheInstallerClient * This, + _Inout_ SIZE_T *pNameLength, + _Out_writes_opt_(*pNameLength) wchar_t *pName); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstallerClient, GetInstallerScope) + D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE ( STDMETHODCALLTYPE *GetInstallerScope )( + ID3DShaderCacheInstallerClient * This); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstallerClient, HandleDriverUpdate) + HRESULT ( STDMETHODCALLTYPE *HandleDriverUpdate )( + ID3DShaderCacheInstallerClient * This, + _In_ ID3DShaderCacheInstaller *pInstaller); + + END_INTERFACE + } ID3DShaderCacheInstallerClientVtbl; + + interface ID3DShaderCacheInstallerClient + { + CONST_VTBL struct ID3DShaderCacheInstallerClientVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3DShaderCacheInstallerClient_GetInstallerName(This,pNameLength,pName) \ + ( (This)->lpVtbl -> GetInstallerName(This,pNameLength,pName) ) + +#define ID3DShaderCacheInstallerClient_GetInstallerScope(This) \ + ( (This)->lpVtbl -> GetInstallerScope(This) ) + +#define ID3DShaderCacheInstallerClient_HandleDriverUpdate(This,pInstaller) \ + ( (This)->lpVtbl -> HandleDriverUpdate(This,pInstaller) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3DShaderCacheInstallerClient_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3dshadercacheregistration_0000_0001 */ +/* [local] */ + +typedef struct D3D_SHADER_CACHE_PSDB_PROPERTIES + { + const wchar_t *pAdapterFamily; + const wchar_t *pPsdbPath; + } D3D_SHADER_CACHE_PSDB_PROPERTIES; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0001_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0001_v0_0_s_ifspec; + +#ifndef __ID3DShaderCacheComponent_INTERFACE_DEFINED__ +#define __ID3DShaderCacheComponent_INTERFACE_DEFINED__ + +/* interface ID3DShaderCacheComponent */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3DShaderCacheComponent; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("eed1bf00-f5c7-4cf7-885c-d0f9c0cb4828") + ID3DShaderCacheComponent : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetComponentName( + _Out_ const wchar_t **pName) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStateObjectDatabasePath( + _Out_ const wchar_t **pPath) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPrecompiledCachePath( + _In_ const wchar_t *pAdapterFamily, + _Inout_ const wchar_t **pPath) = 0; + + virtual UINT STDMETHODCALLTYPE GetPrecompiledShaderDatabaseCount( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPrecompiledShaderDatabases( + UINT ArraySize, + _Out_writes_(ArraySize) D3D_SHADER_CACHE_PSDB_PROPERTIES *pPSDBs) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3DShaderCacheComponentVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3DShaderCacheComponent * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3DShaderCacheComponent * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3DShaderCacheComponent * This); + + DECLSPEC_XFGVIRT(ID3DShaderCacheComponent, GetComponentName) + HRESULT ( STDMETHODCALLTYPE *GetComponentName )( + ID3DShaderCacheComponent * This, + _Out_ const wchar_t **pName); + + DECLSPEC_XFGVIRT(ID3DShaderCacheComponent, GetStateObjectDatabasePath) + HRESULT ( STDMETHODCALLTYPE *GetStateObjectDatabasePath )( + ID3DShaderCacheComponent * This, + _Out_ const wchar_t **pPath); + + DECLSPEC_XFGVIRT(ID3DShaderCacheComponent, GetPrecompiledCachePath) + HRESULT ( STDMETHODCALLTYPE *GetPrecompiledCachePath )( + ID3DShaderCacheComponent * This, + _In_ const wchar_t *pAdapterFamily, + _Inout_ const wchar_t **pPath); + + DECLSPEC_XFGVIRT(ID3DShaderCacheComponent, GetPrecompiledShaderDatabaseCount) + UINT ( STDMETHODCALLTYPE *GetPrecompiledShaderDatabaseCount )( + ID3DShaderCacheComponent * This); + + DECLSPEC_XFGVIRT(ID3DShaderCacheComponent, GetPrecompiledShaderDatabases) + HRESULT ( STDMETHODCALLTYPE *GetPrecompiledShaderDatabases )( + ID3DShaderCacheComponent * This, + UINT ArraySize, + _Out_writes_(ArraySize) D3D_SHADER_CACHE_PSDB_PROPERTIES *pPSDBs); + + END_INTERFACE + } ID3DShaderCacheComponentVtbl; + + interface ID3DShaderCacheComponent + { + CONST_VTBL struct ID3DShaderCacheComponentVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3DShaderCacheComponent_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3DShaderCacheComponent_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3DShaderCacheComponent_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3DShaderCacheComponent_GetComponentName(This,pName) \ + ( (This)->lpVtbl -> GetComponentName(This,pName) ) + +#define ID3DShaderCacheComponent_GetStateObjectDatabasePath(This,pPath) \ + ( (This)->lpVtbl -> GetStateObjectDatabasePath(This,pPath) ) + +#define ID3DShaderCacheComponent_GetPrecompiledCachePath(This,pAdapterFamily,pPath) \ + ( (This)->lpVtbl -> GetPrecompiledCachePath(This,pAdapterFamily,pPath) ) + +#define ID3DShaderCacheComponent_GetPrecompiledShaderDatabaseCount(This) \ + ( (This)->lpVtbl -> GetPrecompiledShaderDatabaseCount(This) ) + +#define ID3DShaderCacheComponent_GetPrecompiledShaderDatabases(This,ArraySize,pPSDBs) \ + ( (This)->lpVtbl -> GetPrecompiledShaderDatabases(This,ArraySize,pPSDBs) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3DShaderCacheComponent_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3dshadercacheregistration_0000_0002 */ +/* [local] */ + +typedef +enum D3D_SHADER_CACHE_TARGET_FLAGS + { + D3D_SHADER_CACHE_TARGET_FLAG_NONE = 0 + } D3D_SHADER_CACHE_TARGET_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS( D3D_SHADER_CACHE_TARGET_FLAGS ) +typedef union D3D_VERSION_NUMBER + { + UINT64 Version; + UINT16 VersionParts[ 4 ]; + } D3D_VERSION_NUMBER; + +typedef struct D3D_SHADER_CACHE_COMPILER_PROPERTIES + { + wchar_t szAdapterFamily[ 128 ]; + UINT64 MinimumABISupportVersion; + UINT64 MaximumABISupportVersion; + D3D_VERSION_NUMBER CompilerVersion; + D3D_VERSION_NUMBER ApplicationProfileVersion; + } D3D_SHADER_CACHE_COMPILER_PROPERTIES; + +typedef struct D3D_SHADER_CACHE_APPLICATION_DESC + { + const wchar_t *pExeFilename; + const wchar_t *pName; + D3D_VERSION_NUMBER Version; + const wchar_t *pEngineName; + D3D_VERSION_NUMBER EngineVersion; + } D3D_SHADER_CACHE_APPLICATION_DESC; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0002_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0002_v0_0_s_ifspec; + +#ifndef __ID3DShaderCacheApplication_INTERFACE_DEFINED__ +#define __ID3DShaderCacheApplication_INTERFACE_DEFINED__ + +/* interface ID3DShaderCacheApplication */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3DShaderCacheApplication; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("fc688ee2-1b35-4913-93be-1ca3fa7df39e") + ID3DShaderCacheApplication : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetExePath( + _Out_ const wchar_t **pExePath) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDesc( + _Out_ D3D_SHADER_CACHE_APPLICATION_DESC *pApplicationDesc) = 0; + + virtual HRESULT STDMETHODCALLTYPE RegisterComponent( + _In_ const wchar_t *pName, + _In_ const wchar_t *pStateObjectDBPath, + _In_ UINT NumPSDB, + _In_reads_(NumPSDB) const D3D_SHADER_CACHE_PSDB_PROPERTIES *pPSDBs, + REFIID riid, + _COM_Outptr_ void **ppvComponent) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveComponent( + _In_ ID3DShaderCacheComponent *pComponent) = 0; + + virtual UINT STDMETHODCALLTYPE GetComponentCount( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetComponent( + _In_ UINT index, + REFIID riid, + _COM_Outptr_ void **ppvComponent) = 0; + + virtual UINT STDMETHODCALLTYPE GetPrecompileTargetCount( + D3D_SHADER_CACHE_TARGET_FLAGS flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPrecompileTargets( + _In_ UINT ArraySize, + _In_reads_(ArraySize) D3D_SHADER_CACHE_COMPILER_PROPERTIES *pArray, + D3D_SHADER_CACHE_TARGET_FLAGS flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInstallerName( + _Out_ const wchar_t **pInstallerName) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3DShaderCacheApplicationVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3DShaderCacheApplication * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3DShaderCacheApplication * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3DShaderCacheApplication * This); + + DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetExePath) + HRESULT ( STDMETHODCALLTYPE *GetExePath )( + ID3DShaderCacheApplication * This, + _Out_ const wchar_t **pExePath); + + DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetDesc) + HRESULT ( STDMETHODCALLTYPE *GetDesc )( + ID3DShaderCacheApplication * This, + _Out_ D3D_SHADER_CACHE_APPLICATION_DESC *pApplicationDesc); + + DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, RegisterComponent) + HRESULT ( STDMETHODCALLTYPE *RegisterComponent )( + ID3DShaderCacheApplication * This, + _In_ const wchar_t *pName, + _In_ const wchar_t *pStateObjectDBPath, + _In_ UINT NumPSDB, + _In_reads_(NumPSDB) const D3D_SHADER_CACHE_PSDB_PROPERTIES *pPSDBs, + REFIID riid, + _COM_Outptr_ void **ppvComponent); + + DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, RemoveComponent) + HRESULT ( STDMETHODCALLTYPE *RemoveComponent )( + ID3DShaderCacheApplication * This, + _In_ ID3DShaderCacheComponent *pComponent); + + DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetComponentCount) + UINT ( STDMETHODCALLTYPE *GetComponentCount )( + ID3DShaderCacheApplication * This); + + DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetComponent) + HRESULT ( STDMETHODCALLTYPE *GetComponent )( + ID3DShaderCacheApplication * This, + _In_ UINT index, + REFIID riid, + _COM_Outptr_ void **ppvComponent); + + DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetPrecompileTargetCount) + UINT ( STDMETHODCALLTYPE *GetPrecompileTargetCount )( + ID3DShaderCacheApplication * This, + D3D_SHADER_CACHE_TARGET_FLAGS flags); + + DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetPrecompileTargets) + HRESULT ( STDMETHODCALLTYPE *GetPrecompileTargets )( + ID3DShaderCacheApplication * This, + _In_ UINT ArraySize, + _In_reads_(ArraySize) D3D_SHADER_CACHE_COMPILER_PROPERTIES *pArray, + D3D_SHADER_CACHE_TARGET_FLAGS flags); + + DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetInstallerName) + HRESULT ( STDMETHODCALLTYPE *GetInstallerName )( + ID3DShaderCacheApplication * This, + _Out_ const wchar_t **pInstallerName); + + END_INTERFACE + } ID3DShaderCacheApplicationVtbl; + + interface ID3DShaderCacheApplication + { + CONST_VTBL struct ID3DShaderCacheApplicationVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3DShaderCacheApplication_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3DShaderCacheApplication_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3DShaderCacheApplication_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3DShaderCacheApplication_GetExePath(This,pExePath) \ + ( (This)->lpVtbl -> GetExePath(This,pExePath) ) + +#define ID3DShaderCacheApplication_GetDesc(This,pApplicationDesc) \ + ( (This)->lpVtbl -> GetDesc(This,pApplicationDesc) ) + +#define ID3DShaderCacheApplication_RegisterComponent(This,pName,pStateObjectDBPath,NumPSDB,pPSDBs,riid,ppvComponent) \ + ( (This)->lpVtbl -> RegisterComponent(This,pName,pStateObjectDBPath,NumPSDB,pPSDBs,riid,ppvComponent) ) + +#define ID3DShaderCacheApplication_RemoveComponent(This,pComponent) \ + ( (This)->lpVtbl -> RemoveComponent(This,pComponent) ) + +#define ID3DShaderCacheApplication_GetComponentCount(This) \ + ( (This)->lpVtbl -> GetComponentCount(This) ) + +#define ID3DShaderCacheApplication_GetComponent(This,index,riid,ppvComponent) \ + ( (This)->lpVtbl -> GetComponent(This,index,riid,ppvComponent) ) + +#define ID3DShaderCacheApplication_GetPrecompileTargetCount(This,flags) \ + ( (This)->lpVtbl -> GetPrecompileTargetCount(This,flags) ) + +#define ID3DShaderCacheApplication_GetPrecompileTargets(This,ArraySize,pArray,flags) \ + ( (This)->lpVtbl -> GetPrecompileTargets(This,ArraySize,pArray,flags) ) + +#define ID3DShaderCacheApplication_GetInstallerName(This,pInstallerName) \ + ( (This)->lpVtbl -> GetInstallerName(This,pInstallerName) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3DShaderCacheApplication_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3dshadercacheregistration_0000_0003 */ +/* [local] */ + +typedef struct SC_HANDLE__ *SC_HANDLE; + + + +extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0003_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0003_v0_0_s_ifspec; + +#ifndef __ID3DShaderCacheInstaller_INTERFACE_DEFINED__ +#define __ID3DShaderCacheInstaller_INTERFACE_DEFINED__ + +/* interface ID3DShaderCacheInstaller */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3DShaderCacheInstaller; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("bbe30de1-6318-4526-ae17-776693191bb4") + ID3DShaderCacheInstaller : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE RegisterDriverUpdateListener( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnregisterDriverUpdateListener( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE RegisterServiceDriverUpdateTrigger( + SC_HANDLE hServiceHandle) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnregisterServiceDriverUpdateTrigger( + SC_HANDLE hServiceHandle) = 0; + + virtual HRESULT STDMETHODCALLTYPE RegisterApplication( + _In_ const wchar_t *pExePath, + _In_ const D3D_SHADER_CACHE_APPLICATION_DESC *pApplicationDesc, + REFIID riid, + _COM_Outptr_ void **ppvApp) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveApplication( + _In_ ID3DShaderCacheApplication *pApplication) = 0; + + virtual UINT STDMETHODCALLTYPE GetApplicationCount( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetApplication( + _In_ UINT index, + REFIID riid, + _COM_Outptr_ void **ppvApp) = 0; + + virtual HRESULT STDMETHODCALLTYPE ClearAllState( void) = 0; + + virtual UINT STDMETHODCALLTYPE GetMaxPrecompileTargetCount( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPrecompileTargets( + _In_opt_ const D3D_SHADER_CACHE_APPLICATION_DESC *pApplicationDesc, + _Inout_ UINT *pArraySize, + _Out_writes_(*pArraySize) D3D_SHADER_CACHE_COMPILER_PROPERTIES *pArray, + D3D_SHADER_CACHE_TARGET_FLAGS flags) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3DShaderCacheInstallerVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3DShaderCacheInstaller * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3DShaderCacheInstaller * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3DShaderCacheInstaller * This); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, RegisterDriverUpdateListener) + HRESULT ( STDMETHODCALLTYPE *RegisterDriverUpdateListener )( + ID3DShaderCacheInstaller * This); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, UnregisterDriverUpdateListener) + HRESULT ( STDMETHODCALLTYPE *UnregisterDriverUpdateListener )( + ID3DShaderCacheInstaller * This); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, RegisterServiceDriverUpdateTrigger) + HRESULT ( STDMETHODCALLTYPE *RegisterServiceDriverUpdateTrigger )( + ID3DShaderCacheInstaller * This, + SC_HANDLE hServiceHandle); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, UnregisterServiceDriverUpdateTrigger) + HRESULT ( STDMETHODCALLTYPE *UnregisterServiceDriverUpdateTrigger )( + ID3DShaderCacheInstaller * This, + SC_HANDLE hServiceHandle); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, RegisterApplication) + HRESULT ( STDMETHODCALLTYPE *RegisterApplication )( + ID3DShaderCacheInstaller * This, + _In_ const wchar_t *pExePath, + _In_ const D3D_SHADER_CACHE_APPLICATION_DESC *pApplicationDesc, + REFIID riid, + _COM_Outptr_ void **ppvApp); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, RemoveApplication) + HRESULT ( STDMETHODCALLTYPE *RemoveApplication )( + ID3DShaderCacheInstaller * This, + _In_ ID3DShaderCacheApplication *pApplication); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, GetApplicationCount) + UINT ( STDMETHODCALLTYPE *GetApplicationCount )( + ID3DShaderCacheInstaller * This); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, GetApplication) + HRESULT ( STDMETHODCALLTYPE *GetApplication )( + ID3DShaderCacheInstaller * This, + _In_ UINT index, + REFIID riid, + _COM_Outptr_ void **ppvApp); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, ClearAllState) + HRESULT ( STDMETHODCALLTYPE *ClearAllState )( + ID3DShaderCacheInstaller * This); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, GetMaxPrecompileTargetCount) + UINT ( STDMETHODCALLTYPE *GetMaxPrecompileTargetCount )( + ID3DShaderCacheInstaller * This); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, GetPrecompileTargets) + HRESULT ( STDMETHODCALLTYPE *GetPrecompileTargets )( + ID3DShaderCacheInstaller * This, + _In_opt_ const D3D_SHADER_CACHE_APPLICATION_DESC *pApplicationDesc, + _Inout_ UINT *pArraySize, + _Out_writes_(*pArraySize) D3D_SHADER_CACHE_COMPILER_PROPERTIES *pArray, + D3D_SHADER_CACHE_TARGET_FLAGS flags); + + END_INTERFACE + } ID3DShaderCacheInstallerVtbl; + + interface ID3DShaderCacheInstaller + { + CONST_VTBL struct ID3DShaderCacheInstallerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3DShaderCacheInstaller_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3DShaderCacheInstaller_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3DShaderCacheInstaller_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3DShaderCacheInstaller_RegisterDriverUpdateListener(This) \ + ( (This)->lpVtbl -> RegisterDriverUpdateListener(This) ) + +#define ID3DShaderCacheInstaller_UnregisterDriverUpdateListener(This) \ + ( (This)->lpVtbl -> UnregisterDriverUpdateListener(This) ) + +#define ID3DShaderCacheInstaller_RegisterServiceDriverUpdateTrigger(This,hServiceHandle) \ + ( (This)->lpVtbl -> RegisterServiceDriverUpdateTrigger(This,hServiceHandle) ) + +#define ID3DShaderCacheInstaller_UnregisterServiceDriverUpdateTrigger(This,hServiceHandle) \ + ( (This)->lpVtbl -> UnregisterServiceDriverUpdateTrigger(This,hServiceHandle) ) + +#define ID3DShaderCacheInstaller_RegisterApplication(This,pExePath,pApplicationDesc,riid,ppvApp) \ + ( (This)->lpVtbl -> RegisterApplication(This,pExePath,pApplicationDesc,riid,ppvApp) ) + +#define ID3DShaderCacheInstaller_RemoveApplication(This,pApplication) \ + ( (This)->lpVtbl -> RemoveApplication(This,pApplication) ) + +#define ID3DShaderCacheInstaller_GetApplicationCount(This) \ + ( (This)->lpVtbl -> GetApplicationCount(This) ) + +#define ID3DShaderCacheInstaller_GetApplication(This,index,riid,ppvApp) \ + ( (This)->lpVtbl -> GetApplication(This,index,riid,ppvApp) ) + +#define ID3DShaderCacheInstaller_ClearAllState(This) \ + ( (This)->lpVtbl -> ClearAllState(This) ) + +#define ID3DShaderCacheInstaller_GetMaxPrecompileTargetCount(This) \ + ( (This)->lpVtbl -> GetMaxPrecompileTargetCount(This) ) + +#define ID3DShaderCacheInstaller_GetPrecompileTargets(This,pApplicationDesc,pArraySize,pArray,flags) \ + ( (This)->lpVtbl -> GetPrecompileTargets(This,pApplicationDesc,pArraySize,pArray,flags) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3DShaderCacheInstaller_INTERFACE_DEFINED__ */ + + +#ifndef __ID3DShaderCacheExplorer_INTERFACE_DEFINED__ +#define __ID3DShaderCacheExplorer_INTERFACE_DEFINED__ + +/* interface ID3DShaderCacheExplorer */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3DShaderCacheExplorer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("90432322-32f5-487f-9264-e9390fa58b2a") + ID3DShaderCacheExplorer : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetApplicationFromExePath( + _In_ const wchar_t *pFullExePath, + REFIID riid, + _COM_Outptr_ void **ppvApp) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3DShaderCacheExplorerVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3DShaderCacheExplorer * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3DShaderCacheExplorer * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3DShaderCacheExplorer * This); + + DECLSPEC_XFGVIRT(ID3DShaderCacheExplorer, GetApplicationFromExePath) + HRESULT ( STDMETHODCALLTYPE *GetApplicationFromExePath )( + ID3DShaderCacheExplorer * This, + _In_ const wchar_t *pFullExePath, + REFIID riid, + _COM_Outptr_ void **ppvApp); + + END_INTERFACE + } ID3DShaderCacheExplorerVtbl; + + interface ID3DShaderCacheExplorer + { + CONST_VTBL struct ID3DShaderCacheExplorerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3DShaderCacheExplorer_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3DShaderCacheExplorer_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3DShaderCacheExplorer_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3DShaderCacheExplorer_GetApplicationFromExePath(This,pFullExePath,riid,ppvApp) \ + ( (This)->lpVtbl -> GetApplicationFromExePath(This,pFullExePath,riid,ppvApp) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3DShaderCacheExplorer_INTERFACE_DEFINED__ */ + + +#ifndef __ID3DShaderCacheInstallerFactory_INTERFACE_DEFINED__ +#define __ID3DShaderCacheInstallerFactory_INTERFACE_DEFINED__ + +/* interface ID3DShaderCacheInstallerFactory */ +/* [unique][local][object][uuid] */ + + +EXTERN_C const IID IID_ID3DShaderCacheInstallerFactory; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("09b2dfe4-840f-401a-804c-0dd8aadc9e9f") + ID3DShaderCacheInstallerFactory : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateInstaller( + _In_ ID3DShaderCacheInstallerClient *pClient, + REFIID riid, + _COM_Outptr_ void **ppvInstaller) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateExplorer( + IUnknown *pUnknown, + REFIID riid, + _COM_Outptr_ void **ppvExplorer) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ID3DShaderCacheInstallerFactoryVtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ID3DShaderCacheInstallerFactory * This, + REFIID riid, + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ID3DShaderCacheInstallerFactory * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ID3DShaderCacheInstallerFactory * This); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstallerFactory, CreateInstaller) + HRESULT ( STDMETHODCALLTYPE *CreateInstaller )( + ID3DShaderCacheInstallerFactory * This, + _In_ ID3DShaderCacheInstallerClient *pClient, + REFIID riid, + _COM_Outptr_ void **ppvInstaller); + + DECLSPEC_XFGVIRT(ID3DShaderCacheInstallerFactory, CreateExplorer) + HRESULT ( STDMETHODCALLTYPE *CreateExplorer )( + ID3DShaderCacheInstallerFactory * This, + IUnknown *pUnknown, + REFIID riid, + _COM_Outptr_ void **ppvExplorer); + + END_INTERFACE + } ID3DShaderCacheInstallerFactoryVtbl; + + interface ID3DShaderCacheInstallerFactory + { + CONST_VTBL struct ID3DShaderCacheInstallerFactoryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ID3DShaderCacheInstallerFactory_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ID3DShaderCacheInstallerFactory_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ID3DShaderCacheInstallerFactory_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ID3DShaderCacheInstallerFactory_CreateInstaller(This,pClient,riid,ppvInstaller) \ + ( (This)->lpVtbl -> CreateInstaller(This,pClient,riid,ppvInstaller) ) + +#define ID3DShaderCacheInstallerFactory_CreateExplorer(This,pUnknown,riid,ppvExplorer) \ + ( (This)->lpVtbl -> CreateExplorer(This,pUnknown,riid,ppvExplorer) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ID3DShaderCacheInstallerFactory_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_d3dshadercacheregistration_0000_0006 */ +/* [local] */ + +DEFINE_GUID(IID_ID3DShaderCacheInstallerClient,0xa16ee930,0xd9f6,0x4222,0xa5,0x14,0x24,0x44,0x73,0xe5,0xd2,0x66); +DEFINE_GUID(IID_ID3DShaderCacheComponent,0xeed1bf00,0xf5c7,0x4cf7,0x88,0x5c,0xd0,0xf9,0xc0,0xcb,0x48,0x28); +DEFINE_GUID(IID_ID3DShaderCacheApplication,0xfc688ee2,0x1b35,0x4913,0x93,0xbe,0x1c,0xa3,0xfa,0x7d,0xf3,0x9e); +DEFINE_GUID(IID_ID3DShaderCacheInstaller,0xbbe30de1,0x6318,0x4526,0xae,0x17,0x77,0x66,0x93,0x19,0x1b,0xb4); +DEFINE_GUID(IID_ID3DShaderCacheExplorer,0x90432322,0x32f5,0x487f,0x92,0x64,0xe9,0x39,0x0f,0xa5,0x8b,0x2a); +DEFINE_GUID(IID_ID3DShaderCacheInstallerFactory,0x09b2dfe4,0x840f,0x401a,0x80,0x4c,0x0d,0xd8,0xaa,0xdc,0x9e,0x9f); + + +extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0006_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0006_v0_0_s_ifspec; + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/dxcore_interface.h b/libs/bgfx/3rdparty/directx-headers/include/directx/dxcore_interface.h index b487fe1..318208e 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/dxcore_interface.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/dxcore_interface.h @@ -35,13 +35,25 @@ enum class DXCoreAdapterProperty : uint32_t IsHardware = 11, IsIntegrated = 12, IsDetachable = 13, - HardwareIDParts = 14 + HardwareIDParts = 14, + PhysicalAdapterCount = 15, + AdapterEngineCount = 16, + AdapterEngineName = 17, }; enum class DXCoreAdapterState : uint32_t { IsDriverUpdateInProgress = 0, - AdapterMemoryBudget = 1 + AdapterMemoryBudget = 1, + AdapterMemoryUsageBytes = 2, + AdapterMemoryUsageByProcessBytes = 3, + AdapterEngineRunningTimeMicroseconds = 4, + AdapterEngineRunningTimeByProcessMicroseconds = 5, + AdapterTemperatureCelsius = 6, + AdapterInUseProcessCount = 7, + AdapterInUseProcessSet = 8, + AdapterEngineFrequencyHertz = 9, + AdapterMemoryFrequencyHertz = 10 }; enum class DXCoreSegmentGroup : uint32_t @@ -65,6 +77,34 @@ enum class DXCoreAdapterPreference : uint32_t HighPerformance = 2 }; +enum class DXCoreWorkload : uint32_t +{ + Graphics = 0, + Compute = 1, + Media = 2, + MachineLearning = 3, +}; + +enum class DXCoreRuntimeFilterFlags : uint32_t +{ + None = 0x0, + D3D11 = 0x1, + D3D12 = 0x2 +}; + +DEFINE_ENUM_FLAG_OPERATORS(DXCoreRuntimeFilterFlags) + +enum class DXCoreHardwareTypeFilterFlags : uint32_t +{ + None = 0x0, + GPU = 0x1, + ComputeAccelerator = 0x2, + NPU = 0x4, + MediaAccelerator = 0x8 +}; + +DEFINE_ENUM_FLAG_OPERATORS(DXCoreHardwareTypeFilterFlags) + struct DXCoreHardwareID { uint32_t vendorID; @@ -96,6 +136,86 @@ struct DXCoreAdapterMemoryBudget uint64_t currentReservation; }; +struct DXCoreAdapterEngineIndex +{ + uint32_t physicalAdapterIndex; + uint32_t engineIndex; +}; + +struct DXCoreEngineQueryInput +{ + DXCoreAdapterEngineIndex adapterEngineIndex; + uint32_t processId; +}; + +struct DXCoreEngineQueryOutput +{ + uint64_t runningTime; + bool processQuerySucceeded; +}; + +enum class DXCoreMemoryType : uint32_t +{ + Dedicated = 0, + Shared = 1 +}; + +struct DXCoreMemoryUsage +{ + uint64_t committed; + uint64_t resident; +}; + +struct DXCoreMemoryQueryInput +{ + uint32_t physicalAdapterIndex; + DXCoreMemoryType memoryType; +}; + +struct DXCoreProcessMemoryQueryInput +{ + uint32_t physicalAdapterIndex; + DXCoreMemoryType memoryType; + uint32_t processId; +}; + +struct DXCoreProcessMemoryQueryOutput +{ + DXCoreMemoryUsage memoryUsage; + bool processQuerySucceeded; +}; + +struct DXCoreAdapterProcessSetQueryInput +{ + uint32_t arraySize; + _Field_size_(arraySize) uint32_t* processIds; +}; + +struct DXCoreAdapterProcessSetQueryOutput +{ + uint32_t processesWritten; + uint32_t processesTotal; +}; + +struct DXCoreEngineNamePropertyInput +{ + DXCoreAdapterEngineIndex adapterEngineIndex; + uint32_t engineNameLength; + _Field_size_(engineNameLength) wchar_t *engineName; +}; + +struct DXCoreEngineNamePropertyOutput +{ + uint32_t engineNameLength; +}; + +struct DXCoreFrequencyQueryOutput +{ + uint64_t frequency; + uint64_t maxFrequency; + uint64_t maxOverclockedFrequency; +}; + typedef void (STDMETHODCALLTYPE *PFN_DXCORE_NOTIFICATION_CALLBACK)( DXCoreNotificationType notificationType, _In_ IUnknown *object, @@ -104,11 +224,21 @@ typedef void (STDMETHODCALLTYPE *PFN_DXCORE_NOTIFICATION_CALLBACK)( static_assert(sizeof(bool) == 1, "bool assumed as one byte"); DEFINE_GUID(IID_IDXCoreAdapterFactory, 0x78ee5945, 0xc36e, 0x4b13, 0xa6, 0x69, 0x00, 0x5d, 0xd1, 0x1c, 0x0f, 0x06); +DEFINE_GUID(IID_IDXCoreAdapterFactory1, 0xd5682e19, 0x6d21, 0x401c, 0x82, 0x7a, 0x9a, 0x51, 0xa4, 0xea, 0x35, 0xd7); DEFINE_GUID(IID_IDXCoreAdapterList, 0x526c7776, 0x40e9, 0x459b, 0xb7, 0x11, 0xf3, 0x2a, 0xd7, 0x6d, 0xfc, 0x28); DEFINE_GUID(IID_IDXCoreAdapter, 0xf0db4c7f, 0xfe5a, 0x42a2, 0xbd, 0x62, 0xf2, 0xa6, 0xcf, 0x6f, 0xc8, 0x3e); +DEFINE_GUID(IID_IDXCoreAdapter1, 0xa0783366, 0xcfa3, 0x43be, 0x9d, 0x79, 0x55, 0xb2, 0xda, 0x97, 0xc6, 0x3c); + DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D11_GRAPHICS, 0x8c47866b, 0x7583, 0x450d, 0xf0, 0xf0, 0x6b, 0xad, 0xa8, 0x95, 0xaf, 0x4b); DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_GRAPHICS, 0x0c9ece4d, 0x2f6e, 0x4f01, 0x8c, 0x96, 0xe8, 0x9e, 0x33, 0x1b, 0x47, 0xb1); DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_CORE_COMPUTE, 0x248e2800, 0xa793, 0x4724, 0xab, 0xaa, 0x23, 0xa6, 0xde, 0x1b, 0xe0, 0x90); +DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_GENERIC_ML, 0xb71b0d41, 0x1088, 0x422f, 0xa2, 0x7c, 0x2, 0x50, 0xb7, 0xd3, 0xa9, 0x88); +DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_GENERIC_MEDIA, 0x8eb2c848, 0x82f6, 0x4b49, 0xaa, 0x87, 0xae, 0xcf, 0xcf, 0x1, 0x74, 0xc6); + +DEFINE_GUID(DXCORE_HARDWARE_TYPE_ATTRIBUTE_GPU, 0xb69eb219, 0x3ded, 0x4464, 0x97, 0x9f, 0xa0, 0xb, 0xd4, 0x68, 0x70, 0x6); +DEFINE_GUID(DXCORE_HARDWARE_TYPE_ATTRIBUTE_COMPUTE_ACCELERATOR, 0xe0b195da, 0x58ef, 0x4a22, 0x90, 0xf1, 0x1f, 0x28, 0x16, 0x9c, 0xab, 0x8d); +DEFINE_GUID(DXCORE_HARDWARE_TYPE_ATTRIBUTE_NPU, 0xd46140c4, 0xadd7, 0x451b, 0x9e, 0x56, 0x6, 0xfe, 0x8c, 0x3b, 0x58, 0xed); +DEFINE_GUID(DXCORE_HARDWARE_TYPE_ATTRIBUTE_MEDIA_ACCELERATOR, 0x66bdb96a, 0x50b, 0x44c7, 0xa4, 0xfd, 0xd1, 0x44, 0xce, 0xa, 0xb4, 0x43); /* interface IDXCoreAdapter */ MIDL_INTERFACE("f0db4c7f-fe5a-42a2-bd62-f2a6cf6fc83e") @@ -214,6 +344,32 @@ IDXCoreAdapter : public IUnknown } }; +/* interface IDXCoreAdapter1 */ +MIDL_INTERFACE("a0783366-cfa3-43be-9d79-55b2da97c63c") +IDXCoreAdapter1 : public IDXCoreAdapter +{ +public: + virtual HRESULT STDMETHODCALLTYPE GetPropertyWithInput( + DXCoreAdapterProperty property, + size_t inputPropertyDetailsSize, + _In_reads_bytes_opt_(inputPropertyDetailsSize) const void *inputPropertyDetails, + size_t outputBufferSize, + _Out_writes_bytes_(outputBufferSize) void *outputBuffer) = 0; + + template + HRESULT GetPropertyWithInput( + DXCoreAdapterProperty property, + _In_reads_bytes_opt_(sizeof(T1)) const T1 *inputPropertyDetails, + _Out_writes_bytes_(sizeof(T2)) T2 *outputBuffer) + { + return GetPropertyWithInput(property, + sizeof(T1), + (const void*)inputPropertyDetails, + sizeof(T2), + (void*)outputBuffer); + } +}; + /* interface IDXCoreAdapterList */ MIDL_INTERFACE("526c7776-40e9-459b-b711-f32ad76dfc28") IDXCoreAdapterList : public IUnknown @@ -309,8 +465,33 @@ IDXCoreAdapterFactory : public IUnknown uint32_t eventCookie) = 0; }; +/* interface IDXCoreAdapterFactory1 */ +MIDL_INTERFACE("d5682e19-6d21-401c-827a-9a51a4ea35d7") +IDXCoreAdapterFactory1 : public IDXCoreAdapterFactory +{ +public: + virtual HRESULT STDMETHODCALLTYPE CreateAdapterListByWorkload( + DXCoreWorkload workload, + DXCoreRuntimeFilterFlags runtimeFilter, + DXCoreHardwareTypeFilterFlags hardwareTypeFilter, + REFIID riid, + _COM_Outptr_ void **ppvAdapterList) = 0; + + template + HRESULT STDMETHODCALLTYPE CreateAdapterListByWorkload( + DXCoreWorkload workload, + DXCoreRuntimeFilterFlags runtimeFilter, + DXCoreHardwareTypeFilterFlags hardwareTypeFilter, + _COM_Outptr_ T **ppvAdapterList) + { + return CreateAdapterListByWorkload(workload, + runtimeFilter, + hardwareTypeFilter, + IID_PPV_ARGS(ppvAdapterList)); + } +}; + #endif // __cplusplus #endif // __dxcore_interface_h__ - diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi.h b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi.h index 39df331..a79f6b0 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi.h @@ -3,14 +3,14 @@ /* this ALWAYS GENERATED file contains the definitions for the interfaces */ - /* File created by MIDL compiler version 8.01.0622 */ + /* File created by MIDL compiler version 8.01.0628 */ /* @@MIDL_FILE_HEADING( ) */ /* verify that the version is high enough to compile this file*/ #ifndef __REQUIRED_RPCNDR_H_VERSION__ -#define __REQUIRED_RPCNDR_H_VERSION__ 475 +#define __REQUIRED_RPCNDR_H_VERSION__ 501 #endif /* verify that the version is high enough to compile this file*/ @@ -37,6 +37,14 @@ #pragma once #endif +#ifndef DECLSPEC_XFGVIRT +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func)) +#else +#define DECLSPEC_XFGVIRT(base, func) +#endif +#endif + /* Forward Declarations */ #ifndef __IDXGIObject_FWD_DEFINED__ @@ -151,6 +159,7 @@ extern "C"{ /* interface __MIDL_itf_dxgi_0000_0000 */ /* [local] */ +#include #define DXGI_CPU_ACCESS_NONE ( 0 ) #define DXGI_CPU_ACCESS_DYNAMIC ( 1 ) #define DXGI_CPU_ACCESS_READ_WRITE ( 2 ) @@ -349,18 +358,22 @@ EXTERN_C const IID IID_IDXGIObject; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIObject * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIObject * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIObject * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIObject * This, /* [annotation][in] */ @@ -369,6 +382,7 @@ EXTERN_C const IID IID_IDXGIObject; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIObject * This, /* [annotation][in] */ @@ -376,6 +390,7 @@ EXTERN_C const IID IID_IDXGIObject; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIObject * This, /* [annotation][in] */ @@ -385,6 +400,7 @@ EXTERN_C const IID IID_IDXGIObject; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIObject * This, /* [annotation][in] */ @@ -468,18 +484,22 @@ EXTERN_C const IID IID_IDXGIDeviceSubObject; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIDeviceSubObject * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIDeviceSubObject * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIDeviceSubObject * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIDeviceSubObject * This, /* [annotation][in] */ @@ -488,6 +508,7 @@ EXTERN_C const IID IID_IDXGIDeviceSubObject; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIDeviceSubObject * This, /* [annotation][in] */ @@ -495,6 +516,7 @@ EXTERN_C const IID IID_IDXGIDeviceSubObject; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIDeviceSubObject * This, /* [annotation][in] */ @@ -504,6 +526,7 @@ EXTERN_C const IID IID_IDXGIDeviceSubObject; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIDeviceSubObject * This, /* [annotation][in] */ @@ -511,6 +534,7 @@ EXTERN_C const IID IID_IDXGIDeviceSubObject; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( IDXGIDeviceSubObject * This, /* [annotation][in] */ @@ -606,18 +630,22 @@ EXTERN_C const IID IID_IDXGIResource; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIResource * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIResource * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIResource * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIResource * This, /* [annotation][in] */ @@ -626,6 +654,7 @@ EXTERN_C const IID IID_IDXGIResource; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIResource * This, /* [annotation][in] */ @@ -633,6 +662,7 @@ EXTERN_C const IID IID_IDXGIResource; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIResource * This, /* [annotation][in] */ @@ -642,6 +672,7 @@ EXTERN_C const IID IID_IDXGIResource; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIResource * This, /* [annotation][in] */ @@ -649,6 +680,7 @@ EXTERN_C const IID IID_IDXGIResource; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( IDXGIResource * This, /* [annotation][in] */ @@ -656,19 +688,23 @@ EXTERN_C const IID IID_IDXGIResource; /* [annotation][retval][out] */ _COM_Outptr_ void **ppDevice); + DECLSPEC_XFGVIRT(IDXGIResource, GetSharedHandle) HRESULT ( STDMETHODCALLTYPE *GetSharedHandle )( IDXGIResource * This, /* [annotation][out] */ _Out_ HANDLE *pSharedHandle); + DECLSPEC_XFGVIRT(IDXGIResource, GetUsage) HRESULT ( STDMETHODCALLTYPE *GetUsage )( IDXGIResource * This, /* [out] */ DXGI_USAGE *pUsage); + DECLSPEC_XFGVIRT(IDXGIResource, SetEvictionPriority) HRESULT ( STDMETHODCALLTYPE *SetEvictionPriority )( IDXGIResource * This, /* [in] */ UINT EvictionPriority); + DECLSPEC_XFGVIRT(IDXGIResource, GetEvictionPriority) HRESULT ( STDMETHODCALLTYPE *GetEvictionPriority )( IDXGIResource * This, /* [annotation][retval][out] */ @@ -768,18 +804,22 @@ EXTERN_C const IID IID_IDXGIKeyedMutex; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIKeyedMutex * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIKeyedMutex * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIKeyedMutex * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIKeyedMutex * This, /* [annotation][in] */ @@ -788,6 +828,7 @@ EXTERN_C const IID IID_IDXGIKeyedMutex; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIKeyedMutex * This, /* [annotation][in] */ @@ -795,6 +836,7 @@ EXTERN_C const IID IID_IDXGIKeyedMutex; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIKeyedMutex * This, /* [annotation][in] */ @@ -804,6 +846,7 @@ EXTERN_C const IID IID_IDXGIKeyedMutex; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIKeyedMutex * This, /* [annotation][in] */ @@ -811,6 +854,7 @@ EXTERN_C const IID IID_IDXGIKeyedMutex; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( IDXGIKeyedMutex * This, /* [annotation][in] */ @@ -818,11 +862,13 @@ EXTERN_C const IID IID_IDXGIKeyedMutex; /* [annotation][retval][out] */ _COM_Outptr_ void **ppDevice); + DECLSPEC_XFGVIRT(IDXGIKeyedMutex, AcquireSync) HRESULT ( STDMETHODCALLTYPE *AcquireSync )( IDXGIKeyedMutex * This, /* [in] */ UINT64 Key, /* [in] */ DWORD dwMilliseconds); + DECLSPEC_XFGVIRT(IDXGIKeyedMutex, ReleaseSync) HRESULT ( STDMETHODCALLTYPE *ReleaseSync )( IDXGIKeyedMutex * This, /* [in] */ UINT64 Key); @@ -933,18 +979,22 @@ EXTERN_C const IID IID_IDXGISurface; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGISurface * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGISurface * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGISurface * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGISurface * This, /* [annotation][in] */ @@ -953,6 +1003,7 @@ EXTERN_C const IID IID_IDXGISurface; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGISurface * This, /* [annotation][in] */ @@ -960,6 +1011,7 @@ EXTERN_C const IID IID_IDXGISurface; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGISurface * This, /* [annotation][in] */ @@ -969,6 +1021,7 @@ EXTERN_C const IID IID_IDXGISurface; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGISurface * This, /* [annotation][in] */ @@ -976,6 +1029,7 @@ EXTERN_C const IID IID_IDXGISurface; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( IDXGISurface * This, /* [annotation][in] */ @@ -983,17 +1037,20 @@ EXTERN_C const IID IID_IDXGISurface; /* [annotation][retval][out] */ _COM_Outptr_ void **ppDevice); + DECLSPEC_XFGVIRT(IDXGISurface, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGISurface * This, /* [annotation][out] */ _Out_ DXGI_SURFACE_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGISurface, Map) HRESULT ( STDMETHODCALLTYPE *Map )( IDXGISurface * This, /* [annotation][out] */ _Out_ DXGI_MAPPED_RECT *pLockedRect, /* [in] */ UINT MapFlags); + DECLSPEC_XFGVIRT(IDXGISurface, Unmap) HRESULT ( STDMETHODCALLTYPE *Unmap )( IDXGISurface * This); @@ -1090,18 +1147,22 @@ EXTERN_C const IID IID_IDXGISurface1; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGISurface1 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGISurface1 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGISurface1 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGISurface1 * This, /* [annotation][in] */ @@ -1110,6 +1171,7 @@ EXTERN_C const IID IID_IDXGISurface1; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGISurface1 * This, /* [annotation][in] */ @@ -1117,6 +1179,7 @@ EXTERN_C const IID IID_IDXGISurface1; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGISurface1 * This, /* [annotation][in] */ @@ -1126,6 +1189,7 @@ EXTERN_C const IID IID_IDXGISurface1; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGISurface1 * This, /* [annotation][in] */ @@ -1133,6 +1197,7 @@ EXTERN_C const IID IID_IDXGISurface1; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( IDXGISurface1 * This, /* [annotation][in] */ @@ -1140,26 +1205,31 @@ EXTERN_C const IID IID_IDXGISurface1; /* [annotation][retval][out] */ _COM_Outptr_ void **ppDevice); + DECLSPEC_XFGVIRT(IDXGISurface, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGISurface1 * This, /* [annotation][out] */ _Out_ DXGI_SURFACE_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGISurface, Map) HRESULT ( STDMETHODCALLTYPE *Map )( IDXGISurface1 * This, /* [annotation][out] */ _Out_ DXGI_MAPPED_RECT *pLockedRect, /* [in] */ UINT MapFlags); + DECLSPEC_XFGVIRT(IDXGISurface, Unmap) HRESULT ( STDMETHODCALLTYPE *Unmap )( IDXGISurface1 * This); + DECLSPEC_XFGVIRT(IDXGISurface1, GetDC) HRESULT ( STDMETHODCALLTYPE *GetDC )( IDXGISurface1 * This, /* [in] */ BOOL Discard, /* [annotation][out] */ _Out_ HDC *phdc); + DECLSPEC_XFGVIRT(IDXGISurface1, ReleaseDC) HRESULT ( STDMETHODCALLTYPE *ReleaseDC )( IDXGISurface1 * This, /* [annotation][in] */ @@ -1280,18 +1350,22 @@ EXTERN_C const IID IID_IDXGIAdapter; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIAdapter * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIAdapter * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIAdapter * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIAdapter * This, /* [annotation][in] */ @@ -1300,6 +1374,7 @@ EXTERN_C const IID IID_IDXGIAdapter; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIAdapter * This, /* [annotation][in] */ @@ -1307,6 +1382,7 @@ EXTERN_C const IID IID_IDXGIAdapter; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIAdapter * This, /* [annotation][in] */ @@ -1316,6 +1392,7 @@ EXTERN_C const IID IID_IDXGIAdapter; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIAdapter * This, /* [annotation][in] */ @@ -1323,17 +1400,20 @@ EXTERN_C const IID IID_IDXGIAdapter; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIAdapter, EnumOutputs) HRESULT ( STDMETHODCALLTYPE *EnumOutputs )( IDXGIAdapter * This, /* [in] */ UINT Output, /* [annotation][out][in] */ _COM_Outptr_ IDXGIOutput **ppOutput); + DECLSPEC_XFGVIRT(IDXGIAdapter, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGIAdapter * This, /* [annotation][out] */ _Out_ DXGI_ADAPTER_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIAdapter, CheckInterfaceSupport) HRESULT ( STDMETHODCALLTYPE *CheckInterfaceSupport )( IDXGIAdapter * This, /* [annotation][in] */ @@ -1486,18 +1566,22 @@ EXTERN_C const IID IID_IDXGIOutput; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIOutput * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIOutput * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIOutput * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIOutput * This, /* [annotation][in] */ @@ -1506,6 +1590,7 @@ EXTERN_C const IID IID_IDXGIOutput; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIOutput * This, /* [annotation][in] */ @@ -1513,6 +1598,7 @@ EXTERN_C const IID IID_IDXGIOutput; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIOutput * This, /* [annotation][in] */ @@ -1522,6 +1608,7 @@ EXTERN_C const IID IID_IDXGIOutput; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIOutput * This, /* [annotation][in] */ @@ -1529,11 +1616,13 @@ EXTERN_C const IID IID_IDXGIOutput; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGIOutput * This, /* [annotation][out] */ _Out_ DXGI_OUTPUT_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplayModeList) HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList )( IDXGIOutput * This, /* [in] */ DXGI_FORMAT EnumFormat, @@ -1543,6 +1632,7 @@ EXTERN_C const IID IID_IDXGIOutput; /* [annotation][out] */ _Out_writes_to_opt_(*pNumModes,*pNumModes) DXGI_MODE_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, FindClosestMatchingMode) HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode )( IDXGIOutput * This, /* [annotation][in] */ @@ -1552,43 +1642,52 @@ EXTERN_C const IID IID_IDXGIOutput; /* [annotation][in] */ _In_opt_ IUnknown *pConcernedDevice); + DECLSPEC_XFGVIRT(IDXGIOutput, WaitForVBlank) HRESULT ( STDMETHODCALLTYPE *WaitForVBlank )( IDXGIOutput * This); + DECLSPEC_XFGVIRT(IDXGIOutput, TakeOwnership) HRESULT ( STDMETHODCALLTYPE *TakeOwnership )( IDXGIOutput * This, /* [annotation][in] */ _In_ IUnknown *pDevice, BOOL Exclusive); + DECLSPEC_XFGVIRT(IDXGIOutput, ReleaseOwnership) void ( STDMETHODCALLTYPE *ReleaseOwnership )( IDXGIOutput * This); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControlCapabilities) HRESULT ( STDMETHODCALLTYPE *GetGammaControlCapabilities )( IDXGIOutput * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL_CAPABILITIES *pGammaCaps); + DECLSPEC_XFGVIRT(IDXGIOutput, SetGammaControl) HRESULT ( STDMETHODCALLTYPE *SetGammaControl )( IDXGIOutput * This, /* [annotation][in] */ _In_ const DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControl) HRESULT ( STDMETHODCALLTYPE *GetGammaControl )( IDXGIOutput * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, SetDisplaySurface) HRESULT ( STDMETHODCALLTYPE *SetDisplaySurface )( IDXGIOutput * This, /* [annotation][in] */ _In_ IDXGISurface *pScanoutSurface); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplaySurfaceData) HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData )( IDXGIOutput * This, /* [annotation][in] */ _In_ IDXGISurface *pDestination); + DECLSPEC_XFGVIRT(IDXGIOutput, GetFrameStatistics) HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( IDXGIOutput * This, /* [annotation][out] */ @@ -1768,18 +1867,22 @@ EXTERN_C const IID IID_IDXGISwapChain; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGISwapChain * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGISwapChain * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGISwapChain * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGISwapChain * This, /* [annotation][in] */ @@ -1788,6 +1891,7 @@ EXTERN_C const IID IID_IDXGISwapChain; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGISwapChain * This, /* [annotation][in] */ @@ -1795,6 +1899,7 @@ EXTERN_C const IID IID_IDXGISwapChain; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGISwapChain * This, /* [annotation][in] */ @@ -1804,6 +1909,7 @@ EXTERN_C const IID IID_IDXGISwapChain; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGISwapChain * This, /* [annotation][in] */ @@ -1811,6 +1917,7 @@ EXTERN_C const IID IID_IDXGISwapChain; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( IDXGISwapChain * This, /* [annotation][in] */ @@ -1818,11 +1925,13 @@ EXTERN_C const IID IID_IDXGISwapChain; /* [annotation][retval][out] */ _COM_Outptr_ void **ppDevice); + DECLSPEC_XFGVIRT(IDXGISwapChain, Present) HRESULT ( STDMETHODCALLTYPE *Present )( IDXGISwapChain * This, /* [in] */ UINT SyncInterval, /* [in] */ UINT Flags); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetBuffer) HRESULT ( STDMETHODCALLTYPE *GetBuffer )( IDXGISwapChain * This, /* [in] */ UINT Buffer, @@ -1831,12 +1940,14 @@ EXTERN_C const IID IID_IDXGISwapChain; /* [annotation][out][in] */ _COM_Outptr_ void **ppSurface); + DECLSPEC_XFGVIRT(IDXGISwapChain, SetFullscreenState) HRESULT ( STDMETHODCALLTYPE *SetFullscreenState )( IDXGISwapChain * This, /* [in] */ BOOL Fullscreen, /* [annotation][in] */ _In_opt_ IDXGIOutput *pTarget); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetFullscreenState) HRESULT ( STDMETHODCALLTYPE *GetFullscreenState )( IDXGISwapChain * This, /* [annotation][out] */ @@ -1844,11 +1955,13 @@ EXTERN_C const IID IID_IDXGISwapChain; /* [annotation][out] */ _COM_Outptr_opt_result_maybenull_ IDXGIOutput **ppTarget); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGISwapChain * This, /* [annotation][out] */ _Out_ DXGI_SWAP_CHAIN_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeBuffers) HRESULT ( STDMETHODCALLTYPE *ResizeBuffers )( IDXGISwapChain * This, /* [in] */ UINT BufferCount, @@ -1857,21 +1970,25 @@ EXTERN_C const IID IID_IDXGISwapChain; /* [in] */ DXGI_FORMAT NewFormat, /* [in] */ UINT SwapChainFlags); + DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeTarget) HRESULT ( STDMETHODCALLTYPE *ResizeTarget )( IDXGISwapChain * This, /* [annotation][in] */ _In_ const DXGI_MODE_DESC *pNewTargetParameters); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetContainingOutput) HRESULT ( STDMETHODCALLTYPE *GetContainingOutput )( IDXGISwapChain * This, /* [annotation][out] */ _COM_Outptr_ IDXGIOutput **ppOutput); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetFrameStatistics) HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( IDXGISwapChain * This, /* [annotation][out] */ _Out_ DXGI_FRAME_STATISTICS *pStats); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetLastPresentCount) HRESULT ( STDMETHODCALLTYPE *GetLastPresentCount )( IDXGISwapChain * This, /* [annotation][out] */ @@ -2020,18 +2137,22 @@ EXTERN_C const IID IID_IDXGIFactory; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIFactory * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIFactory * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIFactory * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIFactory * This, /* [annotation][in] */ @@ -2040,6 +2161,7 @@ EXTERN_C const IID IID_IDXGIFactory; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIFactory * This, /* [annotation][in] */ @@ -2047,6 +2169,7 @@ EXTERN_C const IID IID_IDXGIFactory; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIFactory * This, /* [annotation][in] */ @@ -2056,6 +2179,7 @@ EXTERN_C const IID IID_IDXGIFactory; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIFactory * This, /* [annotation][in] */ @@ -2063,22 +2187,26 @@ EXTERN_C const IID IID_IDXGIFactory; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIFactory, EnumAdapters) HRESULT ( STDMETHODCALLTYPE *EnumAdapters )( IDXGIFactory * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory, MakeWindowAssociation) HRESULT ( STDMETHODCALLTYPE *MakeWindowAssociation )( IDXGIFactory * This, HWND WindowHandle, UINT Flags); + DECLSPEC_XFGVIRT(IDXGIFactory, GetWindowAssociation) HRESULT ( STDMETHODCALLTYPE *GetWindowAssociation )( IDXGIFactory * This, /* [annotation][out] */ _Out_ HWND *pWindowHandle); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSwapChain) HRESULT ( STDMETHODCALLTYPE *CreateSwapChain )( IDXGIFactory * This, /* [annotation][in] */ @@ -2088,6 +2216,7 @@ EXTERN_C const IID IID_IDXGIFactory; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSoftwareAdapter) HRESULT ( STDMETHODCALLTYPE *CreateSoftwareAdapter )( IDXGIFactory * This, /* [in] */ HMODULE Module, @@ -2159,7 +2288,11 @@ EXTERN_C const IID IID_IDXGIFactory; /* interface __MIDL_itf_dxgi_0000_0010 */ /* [local] */ +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) HRESULT WINAPI CreateDXGIFactory(REFIID riid, _COM_Outptr_ void **ppFactory); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion HRESULT WINAPI CreateDXGIFactory1(REFIID riid, _COM_Outptr_ void **ppFactory); @@ -2192,8 +2325,8 @@ EXTERN_C const IID IID_IDXGIDevice; /* [in] */ DXGI_USAGE Usage, /* [annotation][in] */ _In_opt_ const DXGI_SHARED_RESOURCE *pSharedResource, - /* [annotation][out] */ - _COM_Outptr_ IDXGISurface **ppSurface) = 0; + /* [annotation][size_is][out] */ + _Out_writes_(NumSurfaces) IDXGISurface **ppSurface) = 0; virtual HRESULT STDMETHODCALLTYPE QueryResourceResidency( /* [annotation][size_is][in] */ @@ -2218,18 +2351,22 @@ EXTERN_C const IID IID_IDXGIDevice; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIDevice * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIDevice * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIDevice * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIDevice * This, /* [annotation][in] */ @@ -2238,6 +2375,7 @@ EXTERN_C const IID IID_IDXGIDevice; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIDevice * This, /* [annotation][in] */ @@ -2245,6 +2383,7 @@ EXTERN_C const IID IID_IDXGIDevice; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIDevice * This, /* [annotation][in] */ @@ -2254,6 +2393,7 @@ EXTERN_C const IID IID_IDXGIDevice; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIDevice * This, /* [annotation][in] */ @@ -2261,11 +2401,13 @@ EXTERN_C const IID IID_IDXGIDevice; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDevice, GetAdapter) HRESULT ( STDMETHODCALLTYPE *GetAdapter )( IDXGIDevice * This, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **pAdapter); + DECLSPEC_XFGVIRT(IDXGIDevice, CreateSurface) HRESULT ( STDMETHODCALLTYPE *CreateSurface )( IDXGIDevice * This, /* [annotation][in] */ @@ -2274,9 +2416,10 @@ EXTERN_C const IID IID_IDXGIDevice; /* [in] */ DXGI_USAGE Usage, /* [annotation][in] */ _In_opt_ const DXGI_SHARED_RESOURCE *pSharedResource, - /* [annotation][out] */ - _COM_Outptr_ IDXGISurface **ppSurface); + /* [annotation][size_is][out] */ + _Out_writes_(NumSurfaces) IDXGISurface **ppSurface); + DECLSPEC_XFGVIRT(IDXGIDevice, QueryResourceResidency) HRESULT ( STDMETHODCALLTYPE *QueryResourceResidency )( IDXGIDevice * This, /* [annotation][size_is][in] */ @@ -2285,10 +2428,12 @@ EXTERN_C const IID IID_IDXGIDevice; _Out_writes_(NumResources) DXGI_RESIDENCY *pResidencyStatus, /* [in] */ UINT NumResources); + DECLSPEC_XFGVIRT(IDXGIDevice, SetGPUThreadPriority) HRESULT ( STDMETHODCALLTYPE *SetGPUThreadPriority )( IDXGIDevice * This, /* [in] */ INT Priority); + DECLSPEC_XFGVIRT(IDXGIDevice, GetGPUThreadPriority) HRESULT ( STDMETHODCALLTYPE *GetGPUThreadPriority )( IDXGIDevice * This, /* [annotation][retval][out] */ @@ -2425,18 +2570,22 @@ EXTERN_C const IID IID_IDXGIFactory1; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIFactory1 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIFactory1 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIFactory1 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIFactory1 * This, /* [annotation][in] */ @@ -2445,6 +2594,7 @@ EXTERN_C const IID IID_IDXGIFactory1; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIFactory1 * This, /* [annotation][in] */ @@ -2452,6 +2602,7 @@ EXTERN_C const IID IID_IDXGIFactory1; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIFactory1 * This, /* [annotation][in] */ @@ -2461,6 +2612,7 @@ EXTERN_C const IID IID_IDXGIFactory1; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIFactory1 * This, /* [annotation][in] */ @@ -2468,22 +2620,26 @@ EXTERN_C const IID IID_IDXGIFactory1; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIFactory, EnumAdapters) HRESULT ( STDMETHODCALLTYPE *EnumAdapters )( IDXGIFactory1 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory, MakeWindowAssociation) HRESULT ( STDMETHODCALLTYPE *MakeWindowAssociation )( IDXGIFactory1 * This, HWND WindowHandle, UINT Flags); + DECLSPEC_XFGVIRT(IDXGIFactory, GetWindowAssociation) HRESULT ( STDMETHODCALLTYPE *GetWindowAssociation )( IDXGIFactory1 * This, /* [annotation][out] */ _Out_ HWND *pWindowHandle); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSwapChain) HRESULT ( STDMETHODCALLTYPE *CreateSwapChain )( IDXGIFactory1 * This, /* [annotation][in] */ @@ -2493,18 +2649,21 @@ EXTERN_C const IID IID_IDXGIFactory1; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSoftwareAdapter) HRESULT ( STDMETHODCALLTYPE *CreateSoftwareAdapter )( IDXGIFactory1 * This, /* [in] */ HMODULE Module, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, EnumAdapters1) HRESULT ( STDMETHODCALLTYPE *EnumAdapters1 )( IDXGIFactory1 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter1 **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, IsCurrent) BOOL ( STDMETHODCALLTYPE *IsCurrent )( IDXGIFactory1 * This); @@ -2605,18 +2764,22 @@ EXTERN_C const IID IID_IDXGIAdapter1; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIAdapter1 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIAdapter1 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIAdapter1 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIAdapter1 * This, /* [annotation][in] */ @@ -2625,6 +2788,7 @@ EXTERN_C const IID IID_IDXGIAdapter1; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIAdapter1 * This, /* [annotation][in] */ @@ -2632,6 +2796,7 @@ EXTERN_C const IID IID_IDXGIAdapter1; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIAdapter1 * This, /* [annotation][in] */ @@ -2641,6 +2806,7 @@ EXTERN_C const IID IID_IDXGIAdapter1; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIAdapter1 * This, /* [annotation][in] */ @@ -2648,17 +2814,20 @@ EXTERN_C const IID IID_IDXGIAdapter1; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIAdapter, EnumOutputs) HRESULT ( STDMETHODCALLTYPE *EnumOutputs )( IDXGIAdapter1 * This, /* [in] */ UINT Output, /* [annotation][out][in] */ _COM_Outptr_ IDXGIOutput **ppOutput); + DECLSPEC_XFGVIRT(IDXGIAdapter, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGIAdapter1 * This, /* [annotation][out] */ _Out_ DXGI_ADAPTER_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIAdapter, CheckInterfaceSupport) HRESULT ( STDMETHODCALLTYPE *CheckInterfaceSupport )( IDXGIAdapter1 * This, /* [annotation][in] */ @@ -2666,6 +2835,7 @@ EXTERN_C const IID IID_IDXGIAdapter1; /* [annotation][out] */ _Out_ LARGE_INTEGER *pUMDVersion); + DECLSPEC_XFGVIRT(IDXGIAdapter1, GetDesc1) HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( IDXGIAdapter1 * This, /* [annotation][out] */ @@ -2762,18 +2932,22 @@ EXTERN_C const IID IID_IDXGIDevice1; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIDevice1 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIDevice1 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIDevice1 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIDevice1 * This, /* [annotation][in] */ @@ -2782,6 +2956,7 @@ EXTERN_C const IID IID_IDXGIDevice1; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIDevice1 * This, /* [annotation][in] */ @@ -2789,6 +2964,7 @@ EXTERN_C const IID IID_IDXGIDevice1; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIDevice1 * This, /* [annotation][in] */ @@ -2798,6 +2974,7 @@ EXTERN_C const IID IID_IDXGIDevice1; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIDevice1 * This, /* [annotation][in] */ @@ -2805,11 +2982,13 @@ EXTERN_C const IID IID_IDXGIDevice1; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDevice, GetAdapter) HRESULT ( STDMETHODCALLTYPE *GetAdapter )( IDXGIDevice1 * This, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **pAdapter); + DECLSPEC_XFGVIRT(IDXGIDevice, CreateSurface) HRESULT ( STDMETHODCALLTYPE *CreateSurface )( IDXGIDevice1 * This, /* [annotation][in] */ @@ -2818,9 +2997,10 @@ EXTERN_C const IID IID_IDXGIDevice1; /* [in] */ DXGI_USAGE Usage, /* [annotation][in] */ _In_opt_ const DXGI_SHARED_RESOURCE *pSharedResource, - /* [annotation][out] */ - _COM_Outptr_ IDXGISurface **ppSurface); + /* [annotation][size_is][out] */ + _Out_writes_(NumSurfaces) IDXGISurface **ppSurface); + DECLSPEC_XFGVIRT(IDXGIDevice, QueryResourceResidency) HRESULT ( STDMETHODCALLTYPE *QueryResourceResidency )( IDXGIDevice1 * This, /* [annotation][size_is][in] */ @@ -2829,19 +3009,23 @@ EXTERN_C const IID IID_IDXGIDevice1; _Out_writes_(NumResources) DXGI_RESIDENCY *pResidencyStatus, /* [in] */ UINT NumResources); + DECLSPEC_XFGVIRT(IDXGIDevice, SetGPUThreadPriority) HRESULT ( STDMETHODCALLTYPE *SetGPUThreadPriority )( IDXGIDevice1 * This, /* [in] */ INT Priority); + DECLSPEC_XFGVIRT(IDXGIDevice, GetGPUThreadPriority) HRESULT ( STDMETHODCALLTYPE *GetGPUThreadPriority )( IDXGIDevice1 * This, /* [annotation][retval][out] */ _Out_ INT *pPriority); + DECLSPEC_XFGVIRT(IDXGIDevice1, SetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *SetMaximumFrameLatency )( IDXGIDevice1 * This, /* [in] */ UINT MaxLatency); + DECLSPEC_XFGVIRT(IDXGIDevice1, GetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *GetMaximumFrameLatency )( IDXGIDevice1 * This, /* [annotation][out] */ diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_2.h b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_2.h index a79d575..4ffb0ee 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_2.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_2.h @@ -3,14 +3,14 @@ /* this ALWAYS GENERATED file contains the definitions for the interfaces */ - /* File created by MIDL compiler version 8.01.0622 */ + /* File created by MIDL compiler version 8.01.0628 */ /* @@MIDL_FILE_HEADING( ) */ /* verify that the version is high enough to compile this file*/ #ifndef __REQUIRED_RPCNDR_H_VERSION__ -#define __REQUIRED_RPCNDR_H_VERSION__ 475 +#define __REQUIRED_RPCNDR_H_VERSION__ 501 #endif /* verify that the version is high enough to compile this file*/ @@ -37,6 +37,14 @@ #pragma once #endif +#ifndef DECLSPEC_XFGVIRT +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func)) +#else +#define DECLSPEC_XFGVIRT(base, func) +#endif +#endif + /* Forward Declarations */ #ifndef __IDXGIDisplayControl_FWD_DEFINED__ @@ -113,6 +121,9 @@ extern "C"{ /* interface __MIDL_itf_dxgi1_2_0000_0000 */ /* [local] */ +#include +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) extern RPC_IF_HANDLE __MIDL_itf_dxgi1_2_0000_0000_v0_0_c_ifspec; @@ -147,21 +158,26 @@ EXTERN_C const IID IID_IDXGIDisplayControl; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIDisplayControl * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIDisplayControl * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIDisplayControl * This); + DECLSPEC_XFGVIRT(IDXGIDisplayControl, IsStereoEnabled) BOOL ( STDMETHODCALLTYPE *IsStereoEnabled )( IDXGIDisplayControl * This); + DECLSPEC_XFGVIRT(IDXGIDisplayControl, SetStereoEnabled) void ( STDMETHODCALLTYPE *SetStereoEnabled )( IDXGIDisplayControl * This, BOOL enabled); @@ -332,18 +348,22 @@ EXTERN_C const IID IID_IDXGIOutputDuplication; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIOutputDuplication * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIOutputDuplication * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIOutputDuplication * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIOutputDuplication * This, /* [annotation][in] */ @@ -352,6 +372,7 @@ EXTERN_C const IID IID_IDXGIOutputDuplication; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIOutputDuplication * This, /* [annotation][in] */ @@ -359,6 +380,7 @@ EXTERN_C const IID IID_IDXGIOutputDuplication; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIOutputDuplication * This, /* [annotation][in] */ @@ -368,6 +390,7 @@ EXTERN_C const IID IID_IDXGIOutputDuplication; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIOutputDuplication * This, /* [annotation][in] */ @@ -375,11 +398,13 @@ EXTERN_C const IID IID_IDXGIOutputDuplication; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIOutputDuplication, GetDesc) void ( STDMETHODCALLTYPE *GetDesc )( IDXGIOutputDuplication * This, /* [annotation][out] */ _Out_ DXGI_OUTDUPL_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutputDuplication, AcquireNextFrame) HRESULT ( STDMETHODCALLTYPE *AcquireNextFrame )( IDXGIOutputDuplication * This, /* [annotation][in] */ @@ -389,6 +414,7 @@ EXTERN_C const IID IID_IDXGIOutputDuplication; /* [annotation][out] */ _COM_Outptr_ IDXGIResource **ppDesktopResource); + DECLSPEC_XFGVIRT(IDXGIOutputDuplication, GetFrameDirtyRects) HRESULT ( STDMETHODCALLTYPE *GetFrameDirtyRects )( IDXGIOutputDuplication * This, /* [annotation][in] */ @@ -398,6 +424,7 @@ EXTERN_C const IID IID_IDXGIOutputDuplication; /* [annotation][out] */ _Out_ UINT *pDirtyRectsBufferSizeRequired); + DECLSPEC_XFGVIRT(IDXGIOutputDuplication, GetFrameMoveRects) HRESULT ( STDMETHODCALLTYPE *GetFrameMoveRects )( IDXGIOutputDuplication * This, /* [annotation][in] */ @@ -407,6 +434,7 @@ EXTERN_C const IID IID_IDXGIOutputDuplication; /* [annotation][out] */ _Out_ UINT *pMoveRectsBufferSizeRequired); + DECLSPEC_XFGVIRT(IDXGIOutputDuplication, GetFramePointerShape) HRESULT ( STDMETHODCALLTYPE *GetFramePointerShape )( IDXGIOutputDuplication * This, /* [annotation][in] */ @@ -418,14 +446,17 @@ EXTERN_C const IID IID_IDXGIOutputDuplication; /* [annotation][out] */ _Out_ DXGI_OUTDUPL_POINTER_SHAPE_INFO *pPointerShapeInfo); + DECLSPEC_XFGVIRT(IDXGIOutputDuplication, MapDesktopSurface) HRESULT ( STDMETHODCALLTYPE *MapDesktopSurface )( IDXGIOutputDuplication * This, /* [annotation][out] */ _Out_ DXGI_MAPPED_RECT *pLockedRect); + DECLSPEC_XFGVIRT(IDXGIOutputDuplication, UnMapDesktopSurface) HRESULT ( STDMETHODCALLTYPE *UnMapDesktopSurface )( IDXGIOutputDuplication * This); + DECLSPEC_XFGVIRT(IDXGIOutputDuplication, ReleaseFrame) HRESULT ( STDMETHODCALLTYPE *ReleaseFrame )( IDXGIOutputDuplication * This); @@ -503,6 +534,10 @@ EXTERN_C const IID IID_IDXGIOutputDuplication; /* interface __MIDL_itf_dxgi1_2_0000_0002 */ /* [local] */ +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region App Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) typedef enum DXGI_ALPHA_MODE { @@ -550,18 +585,22 @@ EXTERN_C const IID IID_IDXGISurface2; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGISurface2 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGISurface2 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGISurface2 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGISurface2 * This, /* [annotation][in] */ @@ -570,6 +609,7 @@ EXTERN_C const IID IID_IDXGISurface2; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGISurface2 * This, /* [annotation][in] */ @@ -577,6 +617,7 @@ EXTERN_C const IID IID_IDXGISurface2; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGISurface2 * This, /* [annotation][in] */ @@ -586,6 +627,7 @@ EXTERN_C const IID IID_IDXGISurface2; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGISurface2 * This, /* [annotation][in] */ @@ -593,6 +635,7 @@ EXTERN_C const IID IID_IDXGISurface2; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( IDXGISurface2 * This, /* [annotation][in] */ @@ -600,31 +643,37 @@ EXTERN_C const IID IID_IDXGISurface2; /* [annotation][retval][out] */ _COM_Outptr_ void **ppDevice); + DECLSPEC_XFGVIRT(IDXGISurface, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGISurface2 * This, /* [annotation][out] */ _Out_ DXGI_SURFACE_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGISurface, Map) HRESULT ( STDMETHODCALLTYPE *Map )( IDXGISurface2 * This, /* [annotation][out] */ _Out_ DXGI_MAPPED_RECT *pLockedRect, /* [in] */ UINT MapFlags); + DECLSPEC_XFGVIRT(IDXGISurface, Unmap) HRESULT ( STDMETHODCALLTYPE *Unmap )( IDXGISurface2 * This); + DECLSPEC_XFGVIRT(IDXGISurface1, GetDC) HRESULT ( STDMETHODCALLTYPE *GetDC )( IDXGISurface2 * This, /* [in] */ BOOL Discard, /* [annotation][out] */ _Out_ HDC *phdc); + DECLSPEC_XFGVIRT(IDXGISurface1, ReleaseDC) HRESULT ( STDMETHODCALLTYPE *ReleaseDC )( IDXGISurface2 * This, /* [annotation][in] */ _In_opt_ RECT *pDirtyRect); + DECLSPEC_XFGVIRT(IDXGISurface2, GetResource) HRESULT ( STDMETHODCALLTYPE *GetResource )( IDXGISurface2 * This, /* [annotation][in] */ @@ -744,18 +793,22 @@ EXTERN_C const IID IID_IDXGIResource1; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIResource1 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIResource1 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIResource1 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIResource1 * This, /* [annotation][in] */ @@ -764,6 +817,7 @@ EXTERN_C const IID IID_IDXGIResource1; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIResource1 * This, /* [annotation][in] */ @@ -771,6 +825,7 @@ EXTERN_C const IID IID_IDXGIResource1; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIResource1 * This, /* [annotation][in] */ @@ -780,6 +835,7 @@ EXTERN_C const IID IID_IDXGIResource1; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIResource1 * This, /* [annotation][in] */ @@ -787,6 +843,7 @@ EXTERN_C const IID IID_IDXGIResource1; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( IDXGIResource1 * This, /* [annotation][in] */ @@ -794,30 +851,36 @@ EXTERN_C const IID IID_IDXGIResource1; /* [annotation][retval][out] */ _COM_Outptr_ void **ppDevice); + DECLSPEC_XFGVIRT(IDXGIResource, GetSharedHandle) HRESULT ( STDMETHODCALLTYPE *GetSharedHandle )( IDXGIResource1 * This, /* [annotation][out] */ _Out_ HANDLE *pSharedHandle); + DECLSPEC_XFGVIRT(IDXGIResource, GetUsage) HRESULT ( STDMETHODCALLTYPE *GetUsage )( IDXGIResource1 * This, /* [out] */ DXGI_USAGE *pUsage); + DECLSPEC_XFGVIRT(IDXGIResource, SetEvictionPriority) HRESULT ( STDMETHODCALLTYPE *SetEvictionPriority )( IDXGIResource1 * This, /* [in] */ UINT EvictionPriority); + DECLSPEC_XFGVIRT(IDXGIResource, GetEvictionPriority) HRESULT ( STDMETHODCALLTYPE *GetEvictionPriority )( IDXGIResource1 * This, /* [annotation][retval][out] */ _Out_ UINT *pEvictionPriority); + DECLSPEC_XFGVIRT(IDXGIResource1, CreateSubresourceSurface) HRESULT ( STDMETHODCALLTYPE *CreateSubresourceSurface )( IDXGIResource1 * This, UINT index, /* [annotation][out] */ _COM_Outptr_ IDXGISurface2 **ppSurface); + DECLSPEC_XFGVIRT(IDXGIResource1, CreateSharedHandle) HRESULT ( STDMETHODCALLTYPE *CreateSharedHandle )( IDXGIResource1 * This, /* [annotation][in] */ @@ -959,18 +1022,22 @@ EXTERN_C const IID IID_IDXGIDevice2; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIDevice2 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIDevice2 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIDevice2 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIDevice2 * This, /* [annotation][in] */ @@ -979,6 +1046,7 @@ EXTERN_C const IID IID_IDXGIDevice2; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIDevice2 * This, /* [annotation][in] */ @@ -986,6 +1054,7 @@ EXTERN_C const IID IID_IDXGIDevice2; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIDevice2 * This, /* [annotation][in] */ @@ -995,6 +1064,7 @@ EXTERN_C const IID IID_IDXGIDevice2; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIDevice2 * This, /* [annotation][in] */ @@ -1002,11 +1072,13 @@ EXTERN_C const IID IID_IDXGIDevice2; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDevice, GetAdapter) HRESULT ( STDMETHODCALLTYPE *GetAdapter )( IDXGIDevice2 * This, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **pAdapter); + DECLSPEC_XFGVIRT(IDXGIDevice, CreateSurface) HRESULT ( STDMETHODCALLTYPE *CreateSurface )( IDXGIDevice2 * This, /* [annotation][in] */ @@ -1015,9 +1087,10 @@ EXTERN_C const IID IID_IDXGIDevice2; /* [in] */ DXGI_USAGE Usage, /* [annotation][in] */ _In_opt_ const DXGI_SHARED_RESOURCE *pSharedResource, - /* [annotation][out] */ - _COM_Outptr_ IDXGISurface **ppSurface); + /* [annotation][size_is][out] */ + _Out_writes_(NumSurfaces) IDXGISurface **ppSurface); + DECLSPEC_XFGVIRT(IDXGIDevice, QueryResourceResidency) HRESULT ( STDMETHODCALLTYPE *QueryResourceResidency )( IDXGIDevice2 * This, /* [annotation][size_is][in] */ @@ -1026,24 +1099,29 @@ EXTERN_C const IID IID_IDXGIDevice2; _Out_writes_(NumResources) DXGI_RESIDENCY *pResidencyStatus, /* [in] */ UINT NumResources); + DECLSPEC_XFGVIRT(IDXGIDevice, SetGPUThreadPriority) HRESULT ( STDMETHODCALLTYPE *SetGPUThreadPriority )( IDXGIDevice2 * This, /* [in] */ INT Priority); + DECLSPEC_XFGVIRT(IDXGIDevice, GetGPUThreadPriority) HRESULT ( STDMETHODCALLTYPE *GetGPUThreadPriority )( IDXGIDevice2 * This, /* [annotation][retval][out] */ _Out_ INT *pPriority); + DECLSPEC_XFGVIRT(IDXGIDevice1, SetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *SetMaximumFrameLatency )( IDXGIDevice2 * This, /* [in] */ UINT MaxLatency); + DECLSPEC_XFGVIRT(IDXGIDevice1, GetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *GetMaximumFrameLatency )( IDXGIDevice2 * This, /* [annotation][out] */ _Out_ UINT *pMaxLatency); + DECLSPEC_XFGVIRT(IDXGIDevice2, OfferResources) HRESULT ( STDMETHODCALLTYPE *OfferResources )( IDXGIDevice2 * This, /* [annotation][in] */ @@ -1053,6 +1131,7 @@ EXTERN_C const IID IID_IDXGIDevice2; /* [annotation][in] */ _In_ DXGI_OFFER_RESOURCE_PRIORITY Priority); + DECLSPEC_XFGVIRT(IDXGIDevice2, ReclaimResources) HRESULT ( STDMETHODCALLTYPE *ReclaimResources )( IDXGIDevice2 * This, /* [annotation][in] */ @@ -1062,6 +1141,7 @@ EXTERN_C const IID IID_IDXGIDevice2; /* [annotation][size_is][out] */ _Out_writes_all_opt_(NumResources) BOOL *pDiscarded); + DECLSPEC_XFGVIRT(IDXGIDevice2, EnqueueSetEvent) HRESULT ( STDMETHODCALLTYPE *EnqueueSetEvent )( IDXGIDevice2 * This, /* [annotation][in] */ @@ -1283,18 +1363,22 @@ EXTERN_C const IID IID_IDXGISwapChain1; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGISwapChain1 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGISwapChain1 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGISwapChain1 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGISwapChain1 * This, /* [annotation][in] */ @@ -1303,6 +1387,7 @@ EXTERN_C const IID IID_IDXGISwapChain1; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGISwapChain1 * This, /* [annotation][in] */ @@ -1310,6 +1395,7 @@ EXTERN_C const IID IID_IDXGISwapChain1; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGISwapChain1 * This, /* [annotation][in] */ @@ -1319,6 +1405,7 @@ EXTERN_C const IID IID_IDXGISwapChain1; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGISwapChain1 * This, /* [annotation][in] */ @@ -1326,6 +1413,7 @@ EXTERN_C const IID IID_IDXGISwapChain1; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( IDXGISwapChain1 * This, /* [annotation][in] */ @@ -1333,11 +1421,13 @@ EXTERN_C const IID IID_IDXGISwapChain1; /* [annotation][retval][out] */ _COM_Outptr_ void **ppDevice); + DECLSPEC_XFGVIRT(IDXGISwapChain, Present) HRESULT ( STDMETHODCALLTYPE *Present )( IDXGISwapChain1 * This, /* [in] */ UINT SyncInterval, /* [in] */ UINT Flags); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetBuffer) HRESULT ( STDMETHODCALLTYPE *GetBuffer )( IDXGISwapChain1 * This, /* [in] */ UINT Buffer, @@ -1346,12 +1436,14 @@ EXTERN_C const IID IID_IDXGISwapChain1; /* [annotation][out][in] */ _COM_Outptr_ void **ppSurface); + DECLSPEC_XFGVIRT(IDXGISwapChain, SetFullscreenState) HRESULT ( STDMETHODCALLTYPE *SetFullscreenState )( IDXGISwapChain1 * This, /* [in] */ BOOL Fullscreen, /* [annotation][in] */ _In_opt_ IDXGIOutput *pTarget); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetFullscreenState) HRESULT ( STDMETHODCALLTYPE *GetFullscreenState )( IDXGISwapChain1 * This, /* [annotation][out] */ @@ -1359,11 +1451,13 @@ EXTERN_C const IID IID_IDXGISwapChain1; /* [annotation][out] */ _COM_Outptr_opt_result_maybenull_ IDXGIOutput **ppTarget); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGISwapChain1 * This, /* [annotation][out] */ _Out_ DXGI_SWAP_CHAIN_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeBuffers) HRESULT ( STDMETHODCALLTYPE *ResizeBuffers )( IDXGISwapChain1 * This, /* [in] */ UINT BufferCount, @@ -1372,41 +1466,49 @@ EXTERN_C const IID IID_IDXGISwapChain1; /* [in] */ DXGI_FORMAT NewFormat, /* [in] */ UINT SwapChainFlags); + DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeTarget) HRESULT ( STDMETHODCALLTYPE *ResizeTarget )( IDXGISwapChain1 * This, /* [annotation][in] */ _In_ const DXGI_MODE_DESC *pNewTargetParameters); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetContainingOutput) HRESULT ( STDMETHODCALLTYPE *GetContainingOutput )( IDXGISwapChain1 * This, /* [annotation][out] */ _COM_Outptr_ IDXGIOutput **ppOutput); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetFrameStatistics) HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( IDXGISwapChain1 * This, /* [annotation][out] */ _Out_ DXGI_FRAME_STATISTICS *pStats); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetLastPresentCount) HRESULT ( STDMETHODCALLTYPE *GetLastPresentCount )( IDXGISwapChain1 * This, /* [annotation][out] */ _Out_ UINT *pLastPresentCount); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetDesc1) HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( IDXGISwapChain1 * This, /* [annotation][out] */ _Out_ DXGI_SWAP_CHAIN_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetFullscreenDesc) HRESULT ( STDMETHODCALLTYPE *GetFullscreenDesc )( IDXGISwapChain1 * This, /* [annotation][out] */ _Out_ DXGI_SWAP_CHAIN_FULLSCREEN_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetHwnd) HRESULT ( STDMETHODCALLTYPE *GetHwnd )( IDXGISwapChain1 * This, /* [annotation][out] */ _Out_ HWND *pHwnd); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetCoreWindow) HRESULT ( STDMETHODCALLTYPE *GetCoreWindow )( IDXGISwapChain1 * This, /* [annotation][in] */ @@ -1414,6 +1516,7 @@ EXTERN_C const IID IID_IDXGISwapChain1; /* [annotation][out] */ _COM_Outptr_ void **ppUnk); + DECLSPEC_XFGVIRT(IDXGISwapChain1, Present1) HRESULT ( STDMETHODCALLTYPE *Present1 )( IDXGISwapChain1 * This, /* [in] */ UINT SyncInterval, @@ -1421,29 +1524,35 @@ EXTERN_C const IID IID_IDXGISwapChain1; /* [annotation][in] */ _In_ const DXGI_PRESENT_PARAMETERS *pPresentParameters); + DECLSPEC_XFGVIRT(IDXGISwapChain1, IsTemporaryMonoSupported) BOOL ( STDMETHODCALLTYPE *IsTemporaryMonoSupported )( IDXGISwapChain1 * This); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetRestrictToOutput) HRESULT ( STDMETHODCALLTYPE *GetRestrictToOutput )( IDXGISwapChain1 * This, /* [annotation][out] */ _Out_ IDXGIOutput **ppRestrictToOutput); + DECLSPEC_XFGVIRT(IDXGISwapChain1, SetBackgroundColor) HRESULT ( STDMETHODCALLTYPE *SetBackgroundColor )( IDXGISwapChain1 * This, /* [annotation][in] */ _In_ const DXGI_RGBA *pColor); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetBackgroundColor) HRESULT ( STDMETHODCALLTYPE *GetBackgroundColor )( IDXGISwapChain1 * This, /* [annotation][out] */ _Out_ DXGI_RGBA *pColor); + DECLSPEC_XFGVIRT(IDXGISwapChain1, SetRotation) HRESULT ( STDMETHODCALLTYPE *SetRotation )( IDXGISwapChain1 * This, /* [annotation][in] */ _In_ DXGI_MODE_ROTATION Rotation); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetRotation) HRESULT ( STDMETHODCALLTYPE *GetRotation )( IDXGISwapChain1 * This, /* [annotation][out] */ @@ -1668,18 +1777,22 @@ EXTERN_C const IID IID_IDXGIFactory2; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIFactory2 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIFactory2 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIFactory2 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIFactory2 * This, /* [annotation][in] */ @@ -1688,6 +1801,7 @@ EXTERN_C const IID IID_IDXGIFactory2; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIFactory2 * This, /* [annotation][in] */ @@ -1695,6 +1809,7 @@ EXTERN_C const IID IID_IDXGIFactory2; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIFactory2 * This, /* [annotation][in] */ @@ -1704,6 +1819,7 @@ EXTERN_C const IID IID_IDXGIFactory2; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIFactory2 * This, /* [annotation][in] */ @@ -1711,22 +1827,26 @@ EXTERN_C const IID IID_IDXGIFactory2; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIFactory, EnumAdapters) HRESULT ( STDMETHODCALLTYPE *EnumAdapters )( IDXGIFactory2 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory, MakeWindowAssociation) HRESULT ( STDMETHODCALLTYPE *MakeWindowAssociation )( IDXGIFactory2 * This, HWND WindowHandle, UINT Flags); + DECLSPEC_XFGVIRT(IDXGIFactory, GetWindowAssociation) HRESULT ( STDMETHODCALLTYPE *GetWindowAssociation )( IDXGIFactory2 * This, /* [annotation][out] */ _Out_ HWND *pWindowHandle); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSwapChain) HRESULT ( STDMETHODCALLTYPE *CreateSwapChain )( IDXGIFactory2 * This, /* [annotation][in] */ @@ -1736,24 +1856,29 @@ EXTERN_C const IID IID_IDXGIFactory2; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSoftwareAdapter) HRESULT ( STDMETHODCALLTYPE *CreateSoftwareAdapter )( IDXGIFactory2 * This, /* [in] */ HMODULE Module, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, EnumAdapters1) HRESULT ( STDMETHODCALLTYPE *EnumAdapters1 )( IDXGIFactory2 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter1 **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, IsCurrent) BOOL ( STDMETHODCALLTYPE *IsCurrent )( IDXGIFactory2 * This); + DECLSPEC_XFGVIRT(IDXGIFactory2, IsWindowedStereoEnabled) BOOL ( STDMETHODCALLTYPE *IsWindowedStereoEnabled )( IDXGIFactory2 * This); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForHwnd) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForHwnd )( IDXGIFactory2 * This, /* [annotation][in] */ @@ -1769,6 +1894,7 @@ EXTERN_C const IID IID_IDXGIFactory2; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForCoreWindow) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForCoreWindow )( IDXGIFactory2 * This, /* [annotation][in] */ @@ -1782,6 +1908,7 @@ EXTERN_C const IID IID_IDXGIFactory2; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory2, GetSharedResourceAdapterLuid) HRESULT ( STDMETHODCALLTYPE *GetSharedResourceAdapterLuid )( IDXGIFactory2 * This, /* [annotation] */ @@ -1789,6 +1916,7 @@ EXTERN_C const IID IID_IDXGIFactory2; /* [annotation] */ _Out_ LUID *pLuid); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusWindow) HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusWindow )( IDXGIFactory2 * This, /* [annotation][in] */ @@ -1798,6 +1926,7 @@ EXTERN_C const IID IID_IDXGIFactory2; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusEvent )( IDXGIFactory2 * This, /* [annotation][in] */ @@ -1805,11 +1934,13 @@ EXTERN_C const IID IID_IDXGIFactory2; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterStereoStatus) void ( STDMETHODCALLTYPE *UnregisterStereoStatus )( IDXGIFactory2 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusWindow) HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusWindow )( IDXGIFactory2 * This, /* [annotation][in] */ @@ -1819,6 +1950,7 @@ EXTERN_C const IID IID_IDXGIFactory2; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusEvent )( IDXGIFactory2 * This, /* [annotation][in] */ @@ -1826,11 +1958,13 @@ EXTERN_C const IID IID_IDXGIFactory2; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterOcclusionStatus) void ( STDMETHODCALLTYPE *UnregisterOcclusionStatus )( IDXGIFactory2 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForComposition) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForComposition )( IDXGIFactory2 * This, /* [annotation][in] */ @@ -2017,18 +2151,22 @@ EXTERN_C const IID IID_IDXGIAdapter2; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIAdapter2 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIAdapter2 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIAdapter2 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIAdapter2 * This, /* [annotation][in] */ @@ -2037,6 +2175,7 @@ EXTERN_C const IID IID_IDXGIAdapter2; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIAdapter2 * This, /* [annotation][in] */ @@ -2044,6 +2183,7 @@ EXTERN_C const IID IID_IDXGIAdapter2; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIAdapter2 * This, /* [annotation][in] */ @@ -2053,6 +2193,7 @@ EXTERN_C const IID IID_IDXGIAdapter2; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIAdapter2 * This, /* [annotation][in] */ @@ -2060,17 +2201,20 @@ EXTERN_C const IID IID_IDXGIAdapter2; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIAdapter, EnumOutputs) HRESULT ( STDMETHODCALLTYPE *EnumOutputs )( IDXGIAdapter2 * This, /* [in] */ UINT Output, /* [annotation][out][in] */ _COM_Outptr_ IDXGIOutput **ppOutput); + DECLSPEC_XFGVIRT(IDXGIAdapter, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGIAdapter2 * This, /* [annotation][out] */ _Out_ DXGI_ADAPTER_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIAdapter, CheckInterfaceSupport) HRESULT ( STDMETHODCALLTYPE *CheckInterfaceSupport )( IDXGIAdapter2 * This, /* [annotation][in] */ @@ -2078,11 +2222,13 @@ EXTERN_C const IID IID_IDXGIAdapter2; /* [annotation][out] */ _Out_ LARGE_INTEGER *pUMDVersion); + DECLSPEC_XFGVIRT(IDXGIAdapter1, GetDesc1) HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( IDXGIAdapter2 * This, /* [annotation][out] */ _Out_ DXGI_ADAPTER_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGIAdapter2, GetDesc2) HRESULT ( STDMETHODCALLTYPE *GetDesc2 )( IDXGIAdapter2 * This, /* [annotation][out] */ @@ -2202,18 +2348,22 @@ EXTERN_C const IID IID_IDXGIOutput1; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIOutput1 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIOutput1 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIOutput1 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIOutput1 * This, /* [annotation][in] */ @@ -2222,6 +2372,7 @@ EXTERN_C const IID IID_IDXGIOutput1; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIOutput1 * This, /* [annotation][in] */ @@ -2229,6 +2380,7 @@ EXTERN_C const IID IID_IDXGIOutput1; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIOutput1 * This, /* [annotation][in] */ @@ -2238,6 +2390,7 @@ EXTERN_C const IID IID_IDXGIOutput1; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIOutput1 * This, /* [annotation][in] */ @@ -2245,11 +2398,13 @@ EXTERN_C const IID IID_IDXGIOutput1; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGIOutput1 * This, /* [annotation][out] */ _Out_ DXGI_OUTPUT_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplayModeList) HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList )( IDXGIOutput1 * This, /* [in] */ DXGI_FORMAT EnumFormat, @@ -2259,6 +2414,7 @@ EXTERN_C const IID IID_IDXGIOutput1; /* [annotation][out] */ _Out_writes_to_opt_(*pNumModes,*pNumModes) DXGI_MODE_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, FindClosestMatchingMode) HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode )( IDXGIOutput1 * This, /* [annotation][in] */ @@ -2268,48 +2424,58 @@ EXTERN_C const IID IID_IDXGIOutput1; /* [annotation][in] */ _In_opt_ IUnknown *pConcernedDevice); + DECLSPEC_XFGVIRT(IDXGIOutput, WaitForVBlank) HRESULT ( STDMETHODCALLTYPE *WaitForVBlank )( IDXGIOutput1 * This); + DECLSPEC_XFGVIRT(IDXGIOutput, TakeOwnership) HRESULT ( STDMETHODCALLTYPE *TakeOwnership )( IDXGIOutput1 * This, /* [annotation][in] */ _In_ IUnknown *pDevice, BOOL Exclusive); + DECLSPEC_XFGVIRT(IDXGIOutput, ReleaseOwnership) void ( STDMETHODCALLTYPE *ReleaseOwnership )( IDXGIOutput1 * This); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControlCapabilities) HRESULT ( STDMETHODCALLTYPE *GetGammaControlCapabilities )( IDXGIOutput1 * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL_CAPABILITIES *pGammaCaps); + DECLSPEC_XFGVIRT(IDXGIOutput, SetGammaControl) HRESULT ( STDMETHODCALLTYPE *SetGammaControl )( IDXGIOutput1 * This, /* [annotation][in] */ _In_ const DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControl) HRESULT ( STDMETHODCALLTYPE *GetGammaControl )( IDXGIOutput1 * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, SetDisplaySurface) HRESULT ( STDMETHODCALLTYPE *SetDisplaySurface )( IDXGIOutput1 * This, /* [annotation][in] */ _In_ IDXGISurface *pScanoutSurface); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplaySurfaceData) HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData )( IDXGIOutput1 * This, /* [annotation][in] */ _In_ IDXGISurface *pDestination); + DECLSPEC_XFGVIRT(IDXGIOutput, GetFrameStatistics) HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( IDXGIOutput1 * This, /* [annotation][out] */ _Out_ DXGI_FRAME_STATISTICS *pStats); + DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplayModeList1) HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList1 )( IDXGIOutput1 * This, /* [in] */ DXGI_FORMAT EnumFormat, @@ -2319,6 +2485,7 @@ EXTERN_C const IID IID_IDXGIOutput1; /* [annotation][out] */ _Out_writes_to_opt_(*pNumModes,*pNumModes) DXGI_MODE_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput1, FindClosestMatchingMode1) HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode1 )( IDXGIOutput1 * This, /* [annotation][in] */ @@ -2328,11 +2495,13 @@ EXTERN_C const IID IID_IDXGIOutput1; /* [annotation][in] */ _In_opt_ IUnknown *pConcernedDevice); + DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplaySurfaceData1) HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData1 )( IDXGIOutput1 * This, /* [annotation][in] */ _In_ IDXGIResource *pDestination); + DECLSPEC_XFGVIRT(IDXGIOutput1, DuplicateOutput) HRESULT ( STDMETHODCALLTYPE *DuplicateOutput )( IDXGIOutput1 * This, /* [annotation][in] */ @@ -2439,6 +2608,8 @@ EXTERN_C const IID IID_IDXGIOutput1; /* interface __MIDL_itf_dxgi1_2_0000_0009 */ /* [local] */ +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ +#pragma endregion DEFINE_GUID(IID_IDXGIDisplayControl,0xea9dbf1a,0xc88e,0x4486,0x85,0x4a,0x98,0xaa,0x01,0x38,0xf3,0x0c); DEFINE_GUID(IID_IDXGIOutputDuplication,0x191cfac3,0xa341,0x470d,0xb2,0x6e,0xa8,0x64,0xf4,0x28,0x31,0x9c); DEFINE_GUID(IID_IDXGISurface2,0xaba496dd,0xb617,0x4cb8,0xa8,0x66,0xbc,0x44,0xd7,0xeb,0x1f,0xa2); diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_3.h b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_3.h index 40826ef..4b04666 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_3.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_3.h @@ -3,14 +3,14 @@ /* this ALWAYS GENERATED file contains the definitions for the interfaces */ - /* File created by MIDL compiler version 8.01.0622 */ + /* File created by MIDL compiler version 8.01.0628 */ /* @@MIDL_FILE_HEADING( ) */ /* verify that the version is high enough to compile this file*/ #ifndef __REQUIRED_RPCNDR_H_VERSION__ -#define __REQUIRED_RPCNDR_H_VERSION__ 475 +#define __REQUIRED_RPCNDR_H_VERSION__ 501 #endif /* verify that the version is high enough to compile this file*/ @@ -37,6 +37,14 @@ #pragma once #endif +#ifndef DECLSPEC_XFGVIRT +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func)) +#else +#define DECLSPEC_XFGVIRT(base, func) +#endif +#endif + /* Forward Declarations */ #ifndef __IDXGIDevice3_FWD_DEFINED__ @@ -106,6 +114,9 @@ extern "C"{ /* interface __MIDL_itf_dxgi1_3_0000_0000 */ /* [local] */ +#include +#pragma region App Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) #define DXGI_CREATE_FACTORY_DEBUG 0x1 HRESULT WINAPI CreateDXGIFactory2(UINT Flags, REFIID riid, _COM_Outptr_ void **ppFactory); HRESULT WINAPI DXGIGetDebugInterface1(UINT Flags, REFIID riid, _COM_Outptr_ void **pDebug); @@ -140,18 +151,22 @@ EXTERN_C const IID IID_IDXGIDevice3; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIDevice3 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIDevice3 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIDevice3 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIDevice3 * This, /* [annotation][in] */ @@ -160,6 +175,7 @@ EXTERN_C const IID IID_IDXGIDevice3; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIDevice3 * This, /* [annotation][in] */ @@ -167,6 +183,7 @@ EXTERN_C const IID IID_IDXGIDevice3; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIDevice3 * This, /* [annotation][in] */ @@ -176,6 +193,7 @@ EXTERN_C const IID IID_IDXGIDevice3; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIDevice3 * This, /* [annotation][in] */ @@ -183,11 +201,13 @@ EXTERN_C const IID IID_IDXGIDevice3; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDevice, GetAdapter) HRESULT ( STDMETHODCALLTYPE *GetAdapter )( IDXGIDevice3 * This, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **pAdapter); + DECLSPEC_XFGVIRT(IDXGIDevice, CreateSurface) HRESULT ( STDMETHODCALLTYPE *CreateSurface )( IDXGIDevice3 * This, /* [annotation][in] */ @@ -196,9 +216,10 @@ EXTERN_C const IID IID_IDXGIDevice3; /* [in] */ DXGI_USAGE Usage, /* [annotation][in] */ _In_opt_ const DXGI_SHARED_RESOURCE *pSharedResource, - /* [annotation][out] */ - _COM_Outptr_ IDXGISurface **ppSurface); + /* [annotation][size_is][out] */ + _Out_writes_(NumSurfaces) IDXGISurface **ppSurface); + DECLSPEC_XFGVIRT(IDXGIDevice, QueryResourceResidency) HRESULT ( STDMETHODCALLTYPE *QueryResourceResidency )( IDXGIDevice3 * This, /* [annotation][size_is][in] */ @@ -207,24 +228,29 @@ EXTERN_C const IID IID_IDXGIDevice3; _Out_writes_(NumResources) DXGI_RESIDENCY *pResidencyStatus, /* [in] */ UINT NumResources); + DECLSPEC_XFGVIRT(IDXGIDevice, SetGPUThreadPriority) HRESULT ( STDMETHODCALLTYPE *SetGPUThreadPriority )( IDXGIDevice3 * This, /* [in] */ INT Priority); + DECLSPEC_XFGVIRT(IDXGIDevice, GetGPUThreadPriority) HRESULT ( STDMETHODCALLTYPE *GetGPUThreadPriority )( IDXGIDevice3 * This, /* [annotation][retval][out] */ _Out_ INT *pPriority); + DECLSPEC_XFGVIRT(IDXGIDevice1, SetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *SetMaximumFrameLatency )( IDXGIDevice3 * This, /* [in] */ UINT MaxLatency); + DECLSPEC_XFGVIRT(IDXGIDevice1, GetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *GetMaximumFrameLatency )( IDXGIDevice3 * This, /* [annotation][out] */ _Out_ UINT *pMaxLatency); + DECLSPEC_XFGVIRT(IDXGIDevice2, OfferResources) HRESULT ( STDMETHODCALLTYPE *OfferResources )( IDXGIDevice3 * This, /* [annotation][in] */ @@ -234,6 +260,7 @@ EXTERN_C const IID IID_IDXGIDevice3; /* [annotation][in] */ _In_ DXGI_OFFER_RESOURCE_PRIORITY Priority); + DECLSPEC_XFGVIRT(IDXGIDevice2, ReclaimResources) HRESULT ( STDMETHODCALLTYPE *ReclaimResources )( IDXGIDevice3 * This, /* [annotation][in] */ @@ -243,11 +270,13 @@ EXTERN_C const IID IID_IDXGIDevice3; /* [annotation][size_is][out] */ _Out_writes_all_opt_(NumResources) BOOL *pDiscarded); + DECLSPEC_XFGVIRT(IDXGIDevice2, EnqueueSetEvent) HRESULT ( STDMETHODCALLTYPE *EnqueueSetEvent )( IDXGIDevice3 * This, /* [annotation][in] */ _In_ HANDLE hEvent); + DECLSPEC_XFGVIRT(IDXGIDevice3, Trim) void ( STDMETHODCALLTYPE *Trim )( IDXGIDevice3 * This); @@ -402,18 +431,22 @@ EXTERN_C const IID IID_IDXGISwapChain2; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGISwapChain2 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGISwapChain2 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGISwapChain2 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGISwapChain2 * This, /* [annotation][in] */ @@ -422,6 +455,7 @@ EXTERN_C const IID IID_IDXGISwapChain2; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGISwapChain2 * This, /* [annotation][in] */ @@ -429,6 +463,7 @@ EXTERN_C const IID IID_IDXGISwapChain2; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGISwapChain2 * This, /* [annotation][in] */ @@ -438,6 +473,7 @@ EXTERN_C const IID IID_IDXGISwapChain2; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGISwapChain2 * This, /* [annotation][in] */ @@ -445,6 +481,7 @@ EXTERN_C const IID IID_IDXGISwapChain2; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( IDXGISwapChain2 * This, /* [annotation][in] */ @@ -452,11 +489,13 @@ EXTERN_C const IID IID_IDXGISwapChain2; /* [annotation][retval][out] */ _COM_Outptr_ void **ppDevice); + DECLSPEC_XFGVIRT(IDXGISwapChain, Present) HRESULT ( STDMETHODCALLTYPE *Present )( IDXGISwapChain2 * This, /* [in] */ UINT SyncInterval, /* [in] */ UINT Flags); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetBuffer) HRESULT ( STDMETHODCALLTYPE *GetBuffer )( IDXGISwapChain2 * This, /* [in] */ UINT Buffer, @@ -465,12 +504,14 @@ EXTERN_C const IID IID_IDXGISwapChain2; /* [annotation][out][in] */ _COM_Outptr_ void **ppSurface); + DECLSPEC_XFGVIRT(IDXGISwapChain, SetFullscreenState) HRESULT ( STDMETHODCALLTYPE *SetFullscreenState )( IDXGISwapChain2 * This, /* [in] */ BOOL Fullscreen, /* [annotation][in] */ _In_opt_ IDXGIOutput *pTarget); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetFullscreenState) HRESULT ( STDMETHODCALLTYPE *GetFullscreenState )( IDXGISwapChain2 * This, /* [annotation][out] */ @@ -478,11 +519,13 @@ EXTERN_C const IID IID_IDXGISwapChain2; /* [annotation][out] */ _COM_Outptr_opt_result_maybenull_ IDXGIOutput **ppTarget); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGISwapChain2 * This, /* [annotation][out] */ _Out_ DXGI_SWAP_CHAIN_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeBuffers) HRESULT ( STDMETHODCALLTYPE *ResizeBuffers )( IDXGISwapChain2 * This, /* [in] */ UINT BufferCount, @@ -491,41 +534,49 @@ EXTERN_C const IID IID_IDXGISwapChain2; /* [in] */ DXGI_FORMAT NewFormat, /* [in] */ UINT SwapChainFlags); + DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeTarget) HRESULT ( STDMETHODCALLTYPE *ResizeTarget )( IDXGISwapChain2 * This, /* [annotation][in] */ _In_ const DXGI_MODE_DESC *pNewTargetParameters); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetContainingOutput) HRESULT ( STDMETHODCALLTYPE *GetContainingOutput )( IDXGISwapChain2 * This, /* [annotation][out] */ _COM_Outptr_ IDXGIOutput **ppOutput); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetFrameStatistics) HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( IDXGISwapChain2 * This, /* [annotation][out] */ _Out_ DXGI_FRAME_STATISTICS *pStats); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetLastPresentCount) HRESULT ( STDMETHODCALLTYPE *GetLastPresentCount )( IDXGISwapChain2 * This, /* [annotation][out] */ _Out_ UINT *pLastPresentCount); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetDesc1) HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( IDXGISwapChain2 * This, /* [annotation][out] */ _Out_ DXGI_SWAP_CHAIN_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetFullscreenDesc) HRESULT ( STDMETHODCALLTYPE *GetFullscreenDesc )( IDXGISwapChain2 * This, /* [annotation][out] */ _Out_ DXGI_SWAP_CHAIN_FULLSCREEN_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetHwnd) HRESULT ( STDMETHODCALLTYPE *GetHwnd )( IDXGISwapChain2 * This, /* [annotation][out] */ _Out_ HWND *pHwnd); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetCoreWindow) HRESULT ( STDMETHODCALLTYPE *GetCoreWindow )( IDXGISwapChain2 * This, /* [annotation][in] */ @@ -533,6 +584,7 @@ EXTERN_C const IID IID_IDXGISwapChain2; /* [annotation][out] */ _COM_Outptr_ void **ppUnk); + DECLSPEC_XFGVIRT(IDXGISwapChain1, Present1) HRESULT ( STDMETHODCALLTYPE *Present1 )( IDXGISwapChain2 * This, /* [in] */ UINT SyncInterval, @@ -540,39 +592,47 @@ EXTERN_C const IID IID_IDXGISwapChain2; /* [annotation][in] */ _In_ const DXGI_PRESENT_PARAMETERS *pPresentParameters); + DECLSPEC_XFGVIRT(IDXGISwapChain1, IsTemporaryMonoSupported) BOOL ( STDMETHODCALLTYPE *IsTemporaryMonoSupported )( IDXGISwapChain2 * This); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetRestrictToOutput) HRESULT ( STDMETHODCALLTYPE *GetRestrictToOutput )( IDXGISwapChain2 * This, /* [annotation][out] */ _Out_ IDXGIOutput **ppRestrictToOutput); + DECLSPEC_XFGVIRT(IDXGISwapChain1, SetBackgroundColor) HRESULT ( STDMETHODCALLTYPE *SetBackgroundColor )( IDXGISwapChain2 * This, /* [annotation][in] */ _In_ const DXGI_RGBA *pColor); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetBackgroundColor) HRESULT ( STDMETHODCALLTYPE *GetBackgroundColor )( IDXGISwapChain2 * This, /* [annotation][out] */ _Out_ DXGI_RGBA *pColor); + DECLSPEC_XFGVIRT(IDXGISwapChain1, SetRotation) HRESULT ( STDMETHODCALLTYPE *SetRotation )( IDXGISwapChain2 * This, /* [annotation][in] */ _In_ DXGI_MODE_ROTATION Rotation); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetRotation) HRESULT ( STDMETHODCALLTYPE *GetRotation )( IDXGISwapChain2 * This, /* [annotation][out] */ _Out_ DXGI_MODE_ROTATION *pRotation); + DECLSPEC_XFGVIRT(IDXGISwapChain2, SetSourceSize) HRESULT ( STDMETHODCALLTYPE *SetSourceSize )( IDXGISwapChain2 * This, UINT Width, UINT Height); + DECLSPEC_XFGVIRT(IDXGISwapChain2, GetSourceSize) HRESULT ( STDMETHODCALLTYPE *GetSourceSize )( IDXGISwapChain2 * This, /* [annotation][out] */ @@ -580,22 +640,27 @@ EXTERN_C const IID IID_IDXGISwapChain2; /* [annotation][out] */ _Out_ UINT *pHeight); + DECLSPEC_XFGVIRT(IDXGISwapChain2, SetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *SetMaximumFrameLatency )( IDXGISwapChain2 * This, UINT MaxLatency); + DECLSPEC_XFGVIRT(IDXGISwapChain2, GetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *GetMaximumFrameLatency )( IDXGISwapChain2 * This, /* [annotation][out] */ _Out_ UINT *pMaxLatency); + DECLSPEC_XFGVIRT(IDXGISwapChain2, GetFrameLatencyWaitableObject) HANDLE ( STDMETHODCALLTYPE *GetFrameLatencyWaitableObject )( IDXGISwapChain2 * This); + DECLSPEC_XFGVIRT(IDXGISwapChain2, SetMatrixTransform) HRESULT ( STDMETHODCALLTYPE *SetMatrixTransform )( IDXGISwapChain2 * This, const DXGI_MATRIX_3X2_F *pMatrix); + DECLSPEC_XFGVIRT(IDXGISwapChain2, GetMatrixTransform) HRESULT ( STDMETHODCALLTYPE *GetMatrixTransform )( IDXGISwapChain2 * This, /* [annotation][out] */ @@ -764,18 +829,22 @@ EXTERN_C const IID IID_IDXGIOutput2; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIOutput2 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIOutput2 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIOutput2 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIOutput2 * This, /* [annotation][in] */ @@ -784,6 +853,7 @@ EXTERN_C const IID IID_IDXGIOutput2; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIOutput2 * This, /* [annotation][in] */ @@ -791,6 +861,7 @@ EXTERN_C const IID IID_IDXGIOutput2; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIOutput2 * This, /* [annotation][in] */ @@ -800,6 +871,7 @@ EXTERN_C const IID IID_IDXGIOutput2; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIOutput2 * This, /* [annotation][in] */ @@ -807,11 +879,13 @@ EXTERN_C const IID IID_IDXGIOutput2; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGIOutput2 * This, /* [annotation][out] */ _Out_ DXGI_OUTPUT_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplayModeList) HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList )( IDXGIOutput2 * This, /* [in] */ DXGI_FORMAT EnumFormat, @@ -821,6 +895,7 @@ EXTERN_C const IID IID_IDXGIOutput2; /* [annotation][out] */ _Out_writes_to_opt_(*pNumModes,*pNumModes) DXGI_MODE_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, FindClosestMatchingMode) HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode )( IDXGIOutput2 * This, /* [annotation][in] */ @@ -830,48 +905,58 @@ EXTERN_C const IID IID_IDXGIOutput2; /* [annotation][in] */ _In_opt_ IUnknown *pConcernedDevice); + DECLSPEC_XFGVIRT(IDXGIOutput, WaitForVBlank) HRESULT ( STDMETHODCALLTYPE *WaitForVBlank )( IDXGIOutput2 * This); + DECLSPEC_XFGVIRT(IDXGIOutput, TakeOwnership) HRESULT ( STDMETHODCALLTYPE *TakeOwnership )( IDXGIOutput2 * This, /* [annotation][in] */ _In_ IUnknown *pDevice, BOOL Exclusive); + DECLSPEC_XFGVIRT(IDXGIOutput, ReleaseOwnership) void ( STDMETHODCALLTYPE *ReleaseOwnership )( IDXGIOutput2 * This); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControlCapabilities) HRESULT ( STDMETHODCALLTYPE *GetGammaControlCapabilities )( IDXGIOutput2 * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL_CAPABILITIES *pGammaCaps); + DECLSPEC_XFGVIRT(IDXGIOutput, SetGammaControl) HRESULT ( STDMETHODCALLTYPE *SetGammaControl )( IDXGIOutput2 * This, /* [annotation][in] */ _In_ const DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControl) HRESULT ( STDMETHODCALLTYPE *GetGammaControl )( IDXGIOutput2 * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, SetDisplaySurface) HRESULT ( STDMETHODCALLTYPE *SetDisplaySurface )( IDXGIOutput2 * This, /* [annotation][in] */ _In_ IDXGISurface *pScanoutSurface); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplaySurfaceData) HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData )( IDXGIOutput2 * This, /* [annotation][in] */ _In_ IDXGISurface *pDestination); + DECLSPEC_XFGVIRT(IDXGIOutput, GetFrameStatistics) HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( IDXGIOutput2 * This, /* [annotation][out] */ _Out_ DXGI_FRAME_STATISTICS *pStats); + DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplayModeList1) HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList1 )( IDXGIOutput2 * This, /* [in] */ DXGI_FORMAT EnumFormat, @@ -881,6 +966,7 @@ EXTERN_C const IID IID_IDXGIOutput2; /* [annotation][out] */ _Out_writes_to_opt_(*pNumModes,*pNumModes) DXGI_MODE_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput1, FindClosestMatchingMode1) HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode1 )( IDXGIOutput2 * This, /* [annotation][in] */ @@ -890,11 +976,13 @@ EXTERN_C const IID IID_IDXGIOutput2; /* [annotation][in] */ _In_opt_ IUnknown *pConcernedDevice); + DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplaySurfaceData1) HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData1 )( IDXGIOutput2 * This, /* [annotation][in] */ _In_ IDXGIResource *pDestination); + DECLSPEC_XFGVIRT(IDXGIOutput1, DuplicateOutput) HRESULT ( STDMETHODCALLTYPE *DuplicateOutput )( IDXGIOutput2 * This, /* [annotation][in] */ @@ -902,6 +990,7 @@ EXTERN_C const IID IID_IDXGIOutput2; /* [annotation][out] */ _COM_Outptr_ IDXGIOutputDuplication **ppOutputDuplication); + DECLSPEC_XFGVIRT(IDXGIOutput2, SupportsOverlays) BOOL ( STDMETHODCALLTYPE *SupportsOverlays )( IDXGIOutput2 * This); @@ -1031,18 +1120,22 @@ EXTERN_C const IID IID_IDXGIFactory3; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIFactory3 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIFactory3 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIFactory3 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIFactory3 * This, /* [annotation][in] */ @@ -1051,6 +1144,7 @@ EXTERN_C const IID IID_IDXGIFactory3; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIFactory3 * This, /* [annotation][in] */ @@ -1058,6 +1152,7 @@ EXTERN_C const IID IID_IDXGIFactory3; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIFactory3 * This, /* [annotation][in] */ @@ -1067,6 +1162,7 @@ EXTERN_C const IID IID_IDXGIFactory3; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIFactory3 * This, /* [annotation][in] */ @@ -1074,22 +1170,26 @@ EXTERN_C const IID IID_IDXGIFactory3; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIFactory, EnumAdapters) HRESULT ( STDMETHODCALLTYPE *EnumAdapters )( IDXGIFactory3 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory, MakeWindowAssociation) HRESULT ( STDMETHODCALLTYPE *MakeWindowAssociation )( IDXGIFactory3 * This, HWND WindowHandle, UINT Flags); + DECLSPEC_XFGVIRT(IDXGIFactory, GetWindowAssociation) HRESULT ( STDMETHODCALLTYPE *GetWindowAssociation )( IDXGIFactory3 * This, /* [annotation][out] */ _Out_ HWND *pWindowHandle); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSwapChain) HRESULT ( STDMETHODCALLTYPE *CreateSwapChain )( IDXGIFactory3 * This, /* [annotation][in] */ @@ -1099,24 +1199,29 @@ EXTERN_C const IID IID_IDXGIFactory3; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSoftwareAdapter) HRESULT ( STDMETHODCALLTYPE *CreateSoftwareAdapter )( IDXGIFactory3 * This, /* [in] */ HMODULE Module, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, EnumAdapters1) HRESULT ( STDMETHODCALLTYPE *EnumAdapters1 )( IDXGIFactory3 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter1 **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, IsCurrent) BOOL ( STDMETHODCALLTYPE *IsCurrent )( IDXGIFactory3 * This); + DECLSPEC_XFGVIRT(IDXGIFactory2, IsWindowedStereoEnabled) BOOL ( STDMETHODCALLTYPE *IsWindowedStereoEnabled )( IDXGIFactory3 * This); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForHwnd) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForHwnd )( IDXGIFactory3 * This, /* [annotation][in] */ @@ -1132,6 +1237,7 @@ EXTERN_C const IID IID_IDXGIFactory3; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForCoreWindow) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForCoreWindow )( IDXGIFactory3 * This, /* [annotation][in] */ @@ -1145,6 +1251,7 @@ EXTERN_C const IID IID_IDXGIFactory3; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory2, GetSharedResourceAdapterLuid) HRESULT ( STDMETHODCALLTYPE *GetSharedResourceAdapterLuid )( IDXGIFactory3 * This, /* [annotation] */ @@ -1152,6 +1259,7 @@ EXTERN_C const IID IID_IDXGIFactory3; /* [annotation] */ _Out_ LUID *pLuid); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusWindow) HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusWindow )( IDXGIFactory3 * This, /* [annotation][in] */ @@ -1161,6 +1269,7 @@ EXTERN_C const IID IID_IDXGIFactory3; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusEvent )( IDXGIFactory3 * This, /* [annotation][in] */ @@ -1168,11 +1277,13 @@ EXTERN_C const IID IID_IDXGIFactory3; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterStereoStatus) void ( STDMETHODCALLTYPE *UnregisterStereoStatus )( IDXGIFactory3 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusWindow) HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusWindow )( IDXGIFactory3 * This, /* [annotation][in] */ @@ -1182,6 +1293,7 @@ EXTERN_C const IID IID_IDXGIFactory3; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusEvent )( IDXGIFactory3 * This, /* [annotation][in] */ @@ -1189,11 +1301,13 @@ EXTERN_C const IID IID_IDXGIFactory3; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterOcclusionStatus) void ( STDMETHODCALLTYPE *UnregisterOcclusionStatus )( IDXGIFactory3 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForComposition) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForComposition )( IDXGIFactory3 * This, /* [annotation][in] */ @@ -1205,6 +1319,7 @@ EXTERN_C const IID IID_IDXGIFactory3; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory3, GetCreationFlags) UINT ( STDMETHODCALLTYPE *GetCreationFlags )( IDXGIFactory3 * This); @@ -1318,6 +1433,10 @@ EXTERN_C const IID IID_IDXGIFactory3; /* interface __MIDL_itf_dxgi1_3_0000_0004 */ /* [local] */ +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ +#pragma endregion +#pragma region App Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) typedef struct DXGI_DECODE_SWAP_CHAIN_DESC { UINT Flags; @@ -1394,47 +1513,57 @@ EXTERN_C const IID IID_IDXGIDecodeSwapChain; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIDecodeSwapChain * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIDecodeSwapChain * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIDecodeSwapChain * This); + DECLSPEC_XFGVIRT(IDXGIDecodeSwapChain, PresentBuffer) HRESULT ( STDMETHODCALLTYPE *PresentBuffer )( IDXGIDecodeSwapChain * This, UINT BufferToPresent, UINT SyncInterval, UINT Flags); + DECLSPEC_XFGVIRT(IDXGIDecodeSwapChain, SetSourceRect) HRESULT ( STDMETHODCALLTYPE *SetSourceRect )( IDXGIDecodeSwapChain * This, const RECT *pRect); + DECLSPEC_XFGVIRT(IDXGIDecodeSwapChain, SetTargetRect) HRESULT ( STDMETHODCALLTYPE *SetTargetRect )( IDXGIDecodeSwapChain * This, const RECT *pRect); + DECLSPEC_XFGVIRT(IDXGIDecodeSwapChain, SetDestSize) HRESULT ( STDMETHODCALLTYPE *SetDestSize )( IDXGIDecodeSwapChain * This, UINT Width, UINT Height); + DECLSPEC_XFGVIRT(IDXGIDecodeSwapChain, GetSourceRect) HRESULT ( STDMETHODCALLTYPE *GetSourceRect )( IDXGIDecodeSwapChain * This, /* [annotation][out] */ _Out_ RECT *pRect); + DECLSPEC_XFGVIRT(IDXGIDecodeSwapChain, GetTargetRect) HRESULT ( STDMETHODCALLTYPE *GetTargetRect )( IDXGIDecodeSwapChain * This, /* [annotation][out] */ _Out_ RECT *pRect); + DECLSPEC_XFGVIRT(IDXGIDecodeSwapChain, GetDestSize) HRESULT ( STDMETHODCALLTYPE *GetDestSize )( IDXGIDecodeSwapChain * This, /* [annotation][out] */ @@ -1442,10 +1571,12 @@ EXTERN_C const IID IID_IDXGIDecodeSwapChain; /* [annotation][out] */ _Out_ UINT *pHeight); + DECLSPEC_XFGVIRT(IDXGIDecodeSwapChain, SetColorSpace) HRESULT ( STDMETHODCALLTYPE *SetColorSpace )( IDXGIDecodeSwapChain * This, DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAGS ColorSpace); + DECLSPEC_XFGVIRT(IDXGIDecodeSwapChain, GetColorSpace) DXGI_MULTIPLANE_OVERLAY_YCbCr_FLAGS ( STDMETHODCALLTYPE *GetColorSpace )( IDXGIDecodeSwapChain * This); @@ -1560,18 +1691,22 @@ EXTERN_C const IID IID_IDXGIFactoryMedia; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIFactoryMedia * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIFactoryMedia * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIFactoryMedia * This); + DECLSPEC_XFGVIRT(IDXGIFactoryMedia, CreateSwapChainForCompositionSurfaceHandle) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForCompositionSurfaceHandle )( IDXGIFactoryMedia * This, /* [annotation][in] */ @@ -1585,6 +1720,7 @@ EXTERN_C const IID IID_IDXGIFactoryMedia; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactoryMedia, CreateDecodeSwapChainForCompositionSurfaceHandle) HRESULT ( STDMETHODCALLTYPE *CreateDecodeSwapChainForCompositionSurfaceHandle )( IDXGIFactoryMedia * This, /* [annotation][in] */ @@ -1706,27 +1842,33 @@ EXTERN_C const IID IID_IDXGISwapChainMedia; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGISwapChainMedia * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGISwapChainMedia * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGISwapChainMedia * This); + DECLSPEC_XFGVIRT(IDXGISwapChainMedia, GetFrameStatisticsMedia) HRESULT ( STDMETHODCALLTYPE *GetFrameStatisticsMedia )( IDXGISwapChainMedia * This, /* [annotation][out] */ _Out_ DXGI_FRAME_STATISTICS_MEDIA *pStats); + DECLSPEC_XFGVIRT(IDXGISwapChainMedia, SetPresentDuration) HRESULT ( STDMETHODCALLTYPE *SetPresentDuration )( IDXGISwapChainMedia * This, UINT Duration); + DECLSPEC_XFGVIRT(IDXGISwapChainMedia, CheckPresentDurationSupport) HRESULT ( STDMETHODCALLTYPE *CheckPresentDurationSupport )( IDXGISwapChainMedia * This, UINT DesiredPresentDuration, @@ -1788,6 +1930,10 @@ enum DXGI_OVERLAY_SUPPORT_FLAG DXGI_OVERLAY_SUPPORT_FLAG_SCALING = 0x2 } DXGI_OVERLAY_SUPPORT_FLAG; +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region App Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) extern RPC_IF_HANDLE __MIDL_itf_dxgi1_3_0000_0007_v0_0_c_ifspec; @@ -1825,18 +1971,22 @@ EXTERN_C const IID IID_IDXGIOutput3; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIOutput3 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIOutput3 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIOutput3 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIOutput3 * This, /* [annotation][in] */ @@ -1845,6 +1995,7 @@ EXTERN_C const IID IID_IDXGIOutput3; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIOutput3 * This, /* [annotation][in] */ @@ -1852,6 +2003,7 @@ EXTERN_C const IID IID_IDXGIOutput3; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIOutput3 * This, /* [annotation][in] */ @@ -1861,6 +2013,7 @@ EXTERN_C const IID IID_IDXGIOutput3; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIOutput3 * This, /* [annotation][in] */ @@ -1868,11 +2021,13 @@ EXTERN_C const IID IID_IDXGIOutput3; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGIOutput3 * This, /* [annotation][out] */ _Out_ DXGI_OUTPUT_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplayModeList) HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList )( IDXGIOutput3 * This, /* [in] */ DXGI_FORMAT EnumFormat, @@ -1882,6 +2037,7 @@ EXTERN_C const IID IID_IDXGIOutput3; /* [annotation][out] */ _Out_writes_to_opt_(*pNumModes,*pNumModes) DXGI_MODE_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, FindClosestMatchingMode) HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode )( IDXGIOutput3 * This, /* [annotation][in] */ @@ -1891,48 +2047,58 @@ EXTERN_C const IID IID_IDXGIOutput3; /* [annotation][in] */ _In_opt_ IUnknown *pConcernedDevice); + DECLSPEC_XFGVIRT(IDXGIOutput, WaitForVBlank) HRESULT ( STDMETHODCALLTYPE *WaitForVBlank )( IDXGIOutput3 * This); + DECLSPEC_XFGVIRT(IDXGIOutput, TakeOwnership) HRESULT ( STDMETHODCALLTYPE *TakeOwnership )( IDXGIOutput3 * This, /* [annotation][in] */ _In_ IUnknown *pDevice, BOOL Exclusive); + DECLSPEC_XFGVIRT(IDXGIOutput, ReleaseOwnership) void ( STDMETHODCALLTYPE *ReleaseOwnership )( IDXGIOutput3 * This); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControlCapabilities) HRESULT ( STDMETHODCALLTYPE *GetGammaControlCapabilities )( IDXGIOutput3 * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL_CAPABILITIES *pGammaCaps); + DECLSPEC_XFGVIRT(IDXGIOutput, SetGammaControl) HRESULT ( STDMETHODCALLTYPE *SetGammaControl )( IDXGIOutput3 * This, /* [annotation][in] */ _In_ const DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControl) HRESULT ( STDMETHODCALLTYPE *GetGammaControl )( IDXGIOutput3 * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, SetDisplaySurface) HRESULT ( STDMETHODCALLTYPE *SetDisplaySurface )( IDXGIOutput3 * This, /* [annotation][in] */ _In_ IDXGISurface *pScanoutSurface); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplaySurfaceData) HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData )( IDXGIOutput3 * This, /* [annotation][in] */ _In_ IDXGISurface *pDestination); + DECLSPEC_XFGVIRT(IDXGIOutput, GetFrameStatistics) HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( IDXGIOutput3 * This, /* [annotation][out] */ _Out_ DXGI_FRAME_STATISTICS *pStats); + DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplayModeList1) HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList1 )( IDXGIOutput3 * This, /* [in] */ DXGI_FORMAT EnumFormat, @@ -1942,6 +2108,7 @@ EXTERN_C const IID IID_IDXGIOutput3; /* [annotation][out] */ _Out_writes_to_opt_(*pNumModes,*pNumModes) DXGI_MODE_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput1, FindClosestMatchingMode1) HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode1 )( IDXGIOutput3 * This, /* [annotation][in] */ @@ -1951,11 +2118,13 @@ EXTERN_C const IID IID_IDXGIOutput3; /* [annotation][in] */ _In_opt_ IUnknown *pConcernedDevice); + DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplaySurfaceData1) HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData1 )( IDXGIOutput3 * This, /* [annotation][in] */ _In_ IDXGIResource *pDestination); + DECLSPEC_XFGVIRT(IDXGIOutput1, DuplicateOutput) HRESULT ( STDMETHODCALLTYPE *DuplicateOutput )( IDXGIOutput3 * This, /* [annotation][in] */ @@ -1963,9 +2132,11 @@ EXTERN_C const IID IID_IDXGIOutput3; /* [annotation][out] */ _COM_Outptr_ IDXGIOutputDuplication **ppOutputDuplication); + DECLSPEC_XFGVIRT(IDXGIOutput2, SupportsOverlays) BOOL ( STDMETHODCALLTYPE *SupportsOverlays )( IDXGIOutput3 * This); + DECLSPEC_XFGVIRT(IDXGIOutput3, CheckOverlaySupport) HRESULT ( STDMETHODCALLTYPE *CheckOverlaySupport )( IDXGIOutput3 * This, /* [annotation][in] */ @@ -2082,6 +2253,8 @@ EXTERN_C const IID IID_IDXGIOutput3; /* interface __MIDL_itf_dxgi1_3_0000_0008 */ /* [local] */ +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ +#pragma endregion DEFINE_GUID(IID_IDXGIDevice3,0x6007896c,0x3244,0x4afd,0xbf,0x18,0xa6,0xd3,0xbe,0xda,0x50,0x23); DEFINE_GUID(IID_IDXGISwapChain2,0xa8be2ac4,0x199f,0x4946,0xb3,0x31,0x79,0x59,0x9f,0xb9,0x8d,0xe7); DEFINE_GUID(IID_IDXGIOutput2,0x595e39d1,0x2724,0x4663,0x99,0xb1,0xda,0x96,0x9d,0xe2,0x83,0x64); diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_4.h b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_4.h index 0ac2957..197dd7e 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_4.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_4.h @@ -3,14 +3,14 @@ /* this ALWAYS GENERATED file contains the definitions for the interfaces */ - /* File created by MIDL compiler version 8.01.0622 */ + /* File created by MIDL compiler version 8.01.0628 */ /* @@MIDL_FILE_HEADING( ) */ /* verify that the version is high enough to compile this file*/ #ifndef __REQUIRED_RPCNDR_H_VERSION__ -#define __REQUIRED_RPCNDR_H_VERSION__ 475 +#define __REQUIRED_RPCNDR_H_VERSION__ 501 #endif /* verify that the version is high enough to compile this file*/ @@ -37,6 +37,14 @@ #pragma once #endif +#ifndef DECLSPEC_XFGVIRT +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func)) +#else +#define DECLSPEC_XFGVIRT(base, func) +#endif +#endif + /* Forward Declarations */ #ifndef __IDXGISwapChain3_FWD_DEFINED__ @@ -78,6 +86,9 @@ extern "C"{ /* interface __MIDL_itf_dxgi1_4_0000_0000 */ /* [local] */ +#include +#pragma region App Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) typedef enum DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG { @@ -142,18 +153,22 @@ EXTERN_C const IID IID_IDXGISwapChain3; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGISwapChain3 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGISwapChain3 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGISwapChain3 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGISwapChain3 * This, /* [annotation][in] */ @@ -162,6 +177,7 @@ EXTERN_C const IID IID_IDXGISwapChain3; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGISwapChain3 * This, /* [annotation][in] */ @@ -169,6 +185,7 @@ EXTERN_C const IID IID_IDXGISwapChain3; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGISwapChain3 * This, /* [annotation][in] */ @@ -178,6 +195,7 @@ EXTERN_C const IID IID_IDXGISwapChain3; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGISwapChain3 * This, /* [annotation][in] */ @@ -185,6 +203,7 @@ EXTERN_C const IID IID_IDXGISwapChain3; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( IDXGISwapChain3 * This, /* [annotation][in] */ @@ -192,11 +211,13 @@ EXTERN_C const IID IID_IDXGISwapChain3; /* [annotation][retval][out] */ _COM_Outptr_ void **ppDevice); + DECLSPEC_XFGVIRT(IDXGISwapChain, Present) HRESULT ( STDMETHODCALLTYPE *Present )( IDXGISwapChain3 * This, /* [in] */ UINT SyncInterval, /* [in] */ UINT Flags); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetBuffer) HRESULT ( STDMETHODCALLTYPE *GetBuffer )( IDXGISwapChain3 * This, /* [in] */ UINT Buffer, @@ -205,12 +226,14 @@ EXTERN_C const IID IID_IDXGISwapChain3; /* [annotation][out][in] */ _COM_Outptr_ void **ppSurface); + DECLSPEC_XFGVIRT(IDXGISwapChain, SetFullscreenState) HRESULT ( STDMETHODCALLTYPE *SetFullscreenState )( IDXGISwapChain3 * This, /* [in] */ BOOL Fullscreen, /* [annotation][in] */ _In_opt_ IDXGIOutput *pTarget); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetFullscreenState) HRESULT ( STDMETHODCALLTYPE *GetFullscreenState )( IDXGISwapChain3 * This, /* [annotation][out] */ @@ -218,11 +241,13 @@ EXTERN_C const IID IID_IDXGISwapChain3; /* [annotation][out] */ _COM_Outptr_opt_result_maybenull_ IDXGIOutput **ppTarget); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGISwapChain3 * This, /* [annotation][out] */ _Out_ DXGI_SWAP_CHAIN_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeBuffers) HRESULT ( STDMETHODCALLTYPE *ResizeBuffers )( IDXGISwapChain3 * This, /* [in] */ UINT BufferCount, @@ -231,41 +256,49 @@ EXTERN_C const IID IID_IDXGISwapChain3; /* [in] */ DXGI_FORMAT NewFormat, /* [in] */ UINT SwapChainFlags); + DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeTarget) HRESULT ( STDMETHODCALLTYPE *ResizeTarget )( IDXGISwapChain3 * This, /* [annotation][in] */ _In_ const DXGI_MODE_DESC *pNewTargetParameters); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetContainingOutput) HRESULT ( STDMETHODCALLTYPE *GetContainingOutput )( IDXGISwapChain3 * This, /* [annotation][out] */ _COM_Outptr_ IDXGIOutput **ppOutput); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetFrameStatistics) HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( IDXGISwapChain3 * This, /* [annotation][out] */ _Out_ DXGI_FRAME_STATISTICS *pStats); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetLastPresentCount) HRESULT ( STDMETHODCALLTYPE *GetLastPresentCount )( IDXGISwapChain3 * This, /* [annotation][out] */ _Out_ UINT *pLastPresentCount); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetDesc1) HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( IDXGISwapChain3 * This, /* [annotation][out] */ _Out_ DXGI_SWAP_CHAIN_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetFullscreenDesc) HRESULT ( STDMETHODCALLTYPE *GetFullscreenDesc )( IDXGISwapChain3 * This, /* [annotation][out] */ _Out_ DXGI_SWAP_CHAIN_FULLSCREEN_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetHwnd) HRESULT ( STDMETHODCALLTYPE *GetHwnd )( IDXGISwapChain3 * This, /* [annotation][out] */ _Out_ HWND *pHwnd); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetCoreWindow) HRESULT ( STDMETHODCALLTYPE *GetCoreWindow )( IDXGISwapChain3 * This, /* [annotation][in] */ @@ -273,6 +306,7 @@ EXTERN_C const IID IID_IDXGISwapChain3; /* [annotation][out] */ _COM_Outptr_ void **ppUnk); + DECLSPEC_XFGVIRT(IDXGISwapChain1, Present1) HRESULT ( STDMETHODCALLTYPE *Present1 )( IDXGISwapChain3 * This, /* [in] */ UINT SyncInterval, @@ -280,39 +314,47 @@ EXTERN_C const IID IID_IDXGISwapChain3; /* [annotation][in] */ _In_ const DXGI_PRESENT_PARAMETERS *pPresentParameters); + DECLSPEC_XFGVIRT(IDXGISwapChain1, IsTemporaryMonoSupported) BOOL ( STDMETHODCALLTYPE *IsTemporaryMonoSupported )( IDXGISwapChain3 * This); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetRestrictToOutput) HRESULT ( STDMETHODCALLTYPE *GetRestrictToOutput )( IDXGISwapChain3 * This, /* [annotation][out] */ _Out_ IDXGIOutput **ppRestrictToOutput); + DECLSPEC_XFGVIRT(IDXGISwapChain1, SetBackgroundColor) HRESULT ( STDMETHODCALLTYPE *SetBackgroundColor )( IDXGISwapChain3 * This, /* [annotation][in] */ _In_ const DXGI_RGBA *pColor); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetBackgroundColor) HRESULT ( STDMETHODCALLTYPE *GetBackgroundColor )( IDXGISwapChain3 * This, /* [annotation][out] */ _Out_ DXGI_RGBA *pColor); + DECLSPEC_XFGVIRT(IDXGISwapChain1, SetRotation) HRESULT ( STDMETHODCALLTYPE *SetRotation )( IDXGISwapChain3 * This, /* [annotation][in] */ _In_ DXGI_MODE_ROTATION Rotation); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetRotation) HRESULT ( STDMETHODCALLTYPE *GetRotation )( IDXGISwapChain3 * This, /* [annotation][out] */ _Out_ DXGI_MODE_ROTATION *pRotation); + DECLSPEC_XFGVIRT(IDXGISwapChain2, SetSourceSize) HRESULT ( STDMETHODCALLTYPE *SetSourceSize )( IDXGISwapChain3 * This, UINT Width, UINT Height); + DECLSPEC_XFGVIRT(IDXGISwapChain2, GetSourceSize) HRESULT ( STDMETHODCALLTYPE *GetSourceSize )( IDXGISwapChain3 * This, /* [annotation][out] */ @@ -320,30 +362,37 @@ EXTERN_C const IID IID_IDXGISwapChain3; /* [annotation][out] */ _Out_ UINT *pHeight); + DECLSPEC_XFGVIRT(IDXGISwapChain2, SetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *SetMaximumFrameLatency )( IDXGISwapChain3 * This, UINT MaxLatency); + DECLSPEC_XFGVIRT(IDXGISwapChain2, GetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *GetMaximumFrameLatency )( IDXGISwapChain3 * This, /* [annotation][out] */ _Out_ UINT *pMaxLatency); + DECLSPEC_XFGVIRT(IDXGISwapChain2, GetFrameLatencyWaitableObject) HANDLE ( STDMETHODCALLTYPE *GetFrameLatencyWaitableObject )( IDXGISwapChain3 * This); + DECLSPEC_XFGVIRT(IDXGISwapChain2, SetMatrixTransform) HRESULT ( STDMETHODCALLTYPE *SetMatrixTransform )( IDXGISwapChain3 * This, const DXGI_MATRIX_3X2_F *pMatrix); + DECLSPEC_XFGVIRT(IDXGISwapChain2, GetMatrixTransform) HRESULT ( STDMETHODCALLTYPE *GetMatrixTransform )( IDXGISwapChain3 * This, /* [annotation][out] */ _Out_ DXGI_MATRIX_3X2_F *pMatrix); + DECLSPEC_XFGVIRT(IDXGISwapChain3, GetCurrentBackBufferIndex) UINT ( STDMETHODCALLTYPE *GetCurrentBackBufferIndex )( IDXGISwapChain3 * This); + DECLSPEC_XFGVIRT(IDXGISwapChain3, CheckColorSpaceSupport) HRESULT ( STDMETHODCALLTYPE *CheckColorSpaceSupport )( IDXGISwapChain3 * This, /* [annotation][in] */ @@ -351,11 +400,13 @@ EXTERN_C const IID IID_IDXGISwapChain3; /* [annotation][out] */ _Out_ UINT *pColorSpaceSupport); + DECLSPEC_XFGVIRT(IDXGISwapChain3, SetColorSpace1) HRESULT ( STDMETHODCALLTYPE *SetColorSpace1 )( IDXGISwapChain3 * This, /* [annotation][in] */ _In_ DXGI_COLOR_SPACE_TYPE ColorSpace); + DECLSPEC_XFGVIRT(IDXGISwapChain3, ResizeBuffers1) HRESULT ( STDMETHODCALLTYPE *ResizeBuffers1 )( IDXGISwapChain3 * This, /* [annotation][in] */ @@ -571,18 +622,22 @@ EXTERN_C const IID IID_IDXGIOutput4; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIOutput4 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIOutput4 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIOutput4 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIOutput4 * This, /* [annotation][in] */ @@ -591,6 +646,7 @@ EXTERN_C const IID IID_IDXGIOutput4; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIOutput4 * This, /* [annotation][in] */ @@ -598,6 +654,7 @@ EXTERN_C const IID IID_IDXGIOutput4; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIOutput4 * This, /* [annotation][in] */ @@ -607,6 +664,7 @@ EXTERN_C const IID IID_IDXGIOutput4; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIOutput4 * This, /* [annotation][in] */ @@ -614,11 +672,13 @@ EXTERN_C const IID IID_IDXGIOutput4; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGIOutput4 * This, /* [annotation][out] */ _Out_ DXGI_OUTPUT_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplayModeList) HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList )( IDXGIOutput4 * This, /* [in] */ DXGI_FORMAT EnumFormat, @@ -628,6 +688,7 @@ EXTERN_C const IID IID_IDXGIOutput4; /* [annotation][out] */ _Out_writes_to_opt_(*pNumModes,*pNumModes) DXGI_MODE_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, FindClosestMatchingMode) HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode )( IDXGIOutput4 * This, /* [annotation][in] */ @@ -637,48 +698,58 @@ EXTERN_C const IID IID_IDXGIOutput4; /* [annotation][in] */ _In_opt_ IUnknown *pConcernedDevice); + DECLSPEC_XFGVIRT(IDXGIOutput, WaitForVBlank) HRESULT ( STDMETHODCALLTYPE *WaitForVBlank )( IDXGIOutput4 * This); + DECLSPEC_XFGVIRT(IDXGIOutput, TakeOwnership) HRESULT ( STDMETHODCALLTYPE *TakeOwnership )( IDXGIOutput4 * This, /* [annotation][in] */ _In_ IUnknown *pDevice, BOOL Exclusive); + DECLSPEC_XFGVIRT(IDXGIOutput, ReleaseOwnership) void ( STDMETHODCALLTYPE *ReleaseOwnership )( IDXGIOutput4 * This); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControlCapabilities) HRESULT ( STDMETHODCALLTYPE *GetGammaControlCapabilities )( IDXGIOutput4 * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL_CAPABILITIES *pGammaCaps); + DECLSPEC_XFGVIRT(IDXGIOutput, SetGammaControl) HRESULT ( STDMETHODCALLTYPE *SetGammaControl )( IDXGIOutput4 * This, /* [annotation][in] */ _In_ const DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControl) HRESULT ( STDMETHODCALLTYPE *GetGammaControl )( IDXGIOutput4 * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, SetDisplaySurface) HRESULT ( STDMETHODCALLTYPE *SetDisplaySurface )( IDXGIOutput4 * This, /* [annotation][in] */ _In_ IDXGISurface *pScanoutSurface); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplaySurfaceData) HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData )( IDXGIOutput4 * This, /* [annotation][in] */ _In_ IDXGISurface *pDestination); + DECLSPEC_XFGVIRT(IDXGIOutput, GetFrameStatistics) HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( IDXGIOutput4 * This, /* [annotation][out] */ _Out_ DXGI_FRAME_STATISTICS *pStats); + DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplayModeList1) HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList1 )( IDXGIOutput4 * This, /* [in] */ DXGI_FORMAT EnumFormat, @@ -688,6 +759,7 @@ EXTERN_C const IID IID_IDXGIOutput4; /* [annotation][out] */ _Out_writes_to_opt_(*pNumModes,*pNumModes) DXGI_MODE_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput1, FindClosestMatchingMode1) HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode1 )( IDXGIOutput4 * This, /* [annotation][in] */ @@ -697,11 +769,13 @@ EXTERN_C const IID IID_IDXGIOutput4; /* [annotation][in] */ _In_opt_ IUnknown *pConcernedDevice); + DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplaySurfaceData1) HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData1 )( IDXGIOutput4 * This, /* [annotation][in] */ _In_ IDXGIResource *pDestination); + DECLSPEC_XFGVIRT(IDXGIOutput1, DuplicateOutput) HRESULT ( STDMETHODCALLTYPE *DuplicateOutput )( IDXGIOutput4 * This, /* [annotation][in] */ @@ -709,9 +783,11 @@ EXTERN_C const IID IID_IDXGIOutput4; /* [annotation][out] */ _COM_Outptr_ IDXGIOutputDuplication **ppOutputDuplication); + DECLSPEC_XFGVIRT(IDXGIOutput2, SupportsOverlays) BOOL ( STDMETHODCALLTYPE *SupportsOverlays )( IDXGIOutput4 * This); + DECLSPEC_XFGVIRT(IDXGIOutput3, CheckOverlaySupport) HRESULT ( STDMETHODCALLTYPE *CheckOverlaySupport )( IDXGIOutput4 * This, /* [annotation][in] */ @@ -721,6 +797,7 @@ EXTERN_C const IID IID_IDXGIOutput4; /* [annotation][out] */ _Out_ UINT *pFlags); + DECLSPEC_XFGVIRT(IDXGIOutput4, CheckOverlayColorSpaceSupport) HRESULT ( STDMETHODCALLTYPE *CheckOverlayColorSpaceSupport )( IDXGIOutput4 * This, /* [annotation][in] */ @@ -878,18 +955,22 @@ EXTERN_C const IID IID_IDXGIFactory4; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIFactory4 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIFactory4 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIFactory4 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIFactory4 * This, /* [annotation][in] */ @@ -898,6 +979,7 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIFactory4 * This, /* [annotation][in] */ @@ -905,6 +987,7 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIFactory4 * This, /* [annotation][in] */ @@ -914,6 +997,7 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIFactory4 * This, /* [annotation][in] */ @@ -921,22 +1005,26 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIFactory, EnumAdapters) HRESULT ( STDMETHODCALLTYPE *EnumAdapters )( IDXGIFactory4 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory, MakeWindowAssociation) HRESULT ( STDMETHODCALLTYPE *MakeWindowAssociation )( IDXGIFactory4 * This, HWND WindowHandle, UINT Flags); + DECLSPEC_XFGVIRT(IDXGIFactory, GetWindowAssociation) HRESULT ( STDMETHODCALLTYPE *GetWindowAssociation )( IDXGIFactory4 * This, /* [annotation][out] */ _Out_ HWND *pWindowHandle); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSwapChain) HRESULT ( STDMETHODCALLTYPE *CreateSwapChain )( IDXGIFactory4 * This, /* [annotation][in] */ @@ -946,24 +1034,29 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSoftwareAdapter) HRESULT ( STDMETHODCALLTYPE *CreateSoftwareAdapter )( IDXGIFactory4 * This, /* [in] */ HMODULE Module, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, EnumAdapters1) HRESULT ( STDMETHODCALLTYPE *EnumAdapters1 )( IDXGIFactory4 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter1 **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, IsCurrent) BOOL ( STDMETHODCALLTYPE *IsCurrent )( IDXGIFactory4 * This); + DECLSPEC_XFGVIRT(IDXGIFactory2, IsWindowedStereoEnabled) BOOL ( STDMETHODCALLTYPE *IsWindowedStereoEnabled )( IDXGIFactory4 * This); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForHwnd) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForHwnd )( IDXGIFactory4 * This, /* [annotation][in] */ @@ -979,6 +1072,7 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForCoreWindow) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForCoreWindow )( IDXGIFactory4 * This, /* [annotation][in] */ @@ -992,6 +1086,7 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory2, GetSharedResourceAdapterLuid) HRESULT ( STDMETHODCALLTYPE *GetSharedResourceAdapterLuid )( IDXGIFactory4 * This, /* [annotation] */ @@ -999,6 +1094,7 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation] */ _Out_ LUID *pLuid); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusWindow) HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusWindow )( IDXGIFactory4 * This, /* [annotation][in] */ @@ -1008,6 +1104,7 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusEvent )( IDXGIFactory4 * This, /* [annotation][in] */ @@ -1015,11 +1112,13 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterStereoStatus) void ( STDMETHODCALLTYPE *UnregisterStereoStatus )( IDXGIFactory4 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusWindow) HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusWindow )( IDXGIFactory4 * This, /* [annotation][in] */ @@ -1029,6 +1128,7 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusEvent )( IDXGIFactory4 * This, /* [annotation][in] */ @@ -1036,11 +1136,13 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterOcclusionStatus) void ( STDMETHODCALLTYPE *UnregisterOcclusionStatus )( IDXGIFactory4 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForComposition) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForComposition )( IDXGIFactory4 * This, /* [annotation][in] */ @@ -1052,9 +1154,11 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory3, GetCreationFlags) UINT ( STDMETHODCALLTYPE *GetCreationFlags )( IDXGIFactory4 * This); + DECLSPEC_XFGVIRT(IDXGIFactory4, EnumAdapterByLuid) HRESULT ( STDMETHODCALLTYPE *EnumAdapterByLuid )( IDXGIFactory4 * This, /* [annotation] */ @@ -1064,6 +1168,7 @@ EXTERN_C const IID IID_IDXGIFactory4; /* [annotation] */ _COM_Outptr_ void **ppvAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory4, EnumWarpAdapter) HRESULT ( STDMETHODCALLTYPE *EnumWarpAdapter )( IDXGIFactory4 * This, /* [annotation] */ @@ -1268,18 +1373,22 @@ EXTERN_C const IID IID_IDXGIAdapter3; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIAdapter3 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIAdapter3 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIAdapter3 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIAdapter3 * This, /* [annotation][in] */ @@ -1288,6 +1397,7 @@ EXTERN_C const IID IID_IDXGIAdapter3; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIAdapter3 * This, /* [annotation][in] */ @@ -1295,6 +1405,7 @@ EXTERN_C const IID IID_IDXGIAdapter3; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIAdapter3 * This, /* [annotation][in] */ @@ -1304,6 +1415,7 @@ EXTERN_C const IID IID_IDXGIAdapter3; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIAdapter3 * This, /* [annotation][in] */ @@ -1311,17 +1423,20 @@ EXTERN_C const IID IID_IDXGIAdapter3; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIAdapter, EnumOutputs) HRESULT ( STDMETHODCALLTYPE *EnumOutputs )( IDXGIAdapter3 * This, /* [in] */ UINT Output, /* [annotation][out][in] */ _COM_Outptr_ IDXGIOutput **ppOutput); + DECLSPEC_XFGVIRT(IDXGIAdapter, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGIAdapter3 * This, /* [annotation][out] */ _Out_ DXGI_ADAPTER_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIAdapter, CheckInterfaceSupport) HRESULT ( STDMETHODCALLTYPE *CheckInterfaceSupport )( IDXGIAdapter3 * This, /* [annotation][in] */ @@ -1329,16 +1444,19 @@ EXTERN_C const IID IID_IDXGIAdapter3; /* [annotation][out] */ _Out_ LARGE_INTEGER *pUMDVersion); + DECLSPEC_XFGVIRT(IDXGIAdapter1, GetDesc1) HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( IDXGIAdapter3 * This, /* [annotation][out] */ _Out_ DXGI_ADAPTER_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGIAdapter2, GetDesc2) HRESULT ( STDMETHODCALLTYPE *GetDesc2 )( IDXGIAdapter3 * This, /* [annotation][out] */ _Out_ DXGI_ADAPTER_DESC2 *pDesc); + DECLSPEC_XFGVIRT(IDXGIAdapter3, RegisterHardwareContentProtectionTeardownStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterHardwareContentProtectionTeardownStatusEvent )( IDXGIAdapter3 * This, /* [annotation][in] */ @@ -1346,11 +1464,13 @@ EXTERN_C const IID IID_IDXGIAdapter3; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIAdapter3, UnregisterHardwareContentProtectionTeardownStatus) void ( STDMETHODCALLTYPE *UnregisterHardwareContentProtectionTeardownStatus )( IDXGIAdapter3 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIAdapter3, QueryVideoMemoryInfo) HRESULT ( STDMETHODCALLTYPE *QueryVideoMemoryInfo )( IDXGIAdapter3 * This, /* [annotation][in] */ @@ -1360,6 +1480,7 @@ EXTERN_C const IID IID_IDXGIAdapter3; /* [annotation][out] */ _Out_ DXGI_QUERY_VIDEO_MEMORY_INFO *pVideoMemoryInfo); + DECLSPEC_XFGVIRT(IDXGIAdapter3, SetVideoMemoryReservation) HRESULT ( STDMETHODCALLTYPE *SetVideoMemoryReservation )( IDXGIAdapter3 * This, /* [annotation][in] */ @@ -1369,6 +1490,7 @@ EXTERN_C const IID IID_IDXGIAdapter3; /* [annotation][in] */ _In_ UINT64 Reservation); + DECLSPEC_XFGVIRT(IDXGIAdapter3, RegisterVideoMemoryBudgetChangeNotificationEvent) HRESULT ( STDMETHODCALLTYPE *RegisterVideoMemoryBudgetChangeNotificationEvent )( IDXGIAdapter3 * This, /* [annotation][in] */ @@ -1376,6 +1498,7 @@ EXTERN_C const IID IID_IDXGIAdapter3; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIAdapter3, UnregisterVideoMemoryBudgetChangeNotification) void ( STDMETHODCALLTYPE *UnregisterVideoMemoryBudgetChangeNotification )( IDXGIAdapter3 * This, /* [annotation][in] */ @@ -1467,6 +1590,8 @@ EXTERN_C const IID IID_IDXGIAdapter3; /* interface __MIDL_itf_dxgi1_4_0000_0004 */ /* [local] */ +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ +#pragma endregion DEFINE_GUID(IID_IDXGISwapChain3,0x94d99bdb,0xf1f8,0x4ab0,0xb2,0x36,0x7d,0xa0,0x17,0x0e,0xda,0xb1); DEFINE_GUID(IID_IDXGIOutput4,0xdc7dca35,0x2196,0x414d,0x9F,0x53,0x61,0x78,0x84,0x03,0x2a,0x60); DEFINE_GUID(IID_IDXGIFactory4,0x1bc6ea02,0xef36,0x464f,0xbf,0x0c,0x21,0xca,0x39,0xe5,0x16,0x8a); diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_5.h b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_5.h index bdee56d..9c18138 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_5.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_5.h @@ -3,14 +3,14 @@ /* this ALWAYS GENERATED file contains the definitions for the interfaces */ - /* File created by MIDL compiler version 8.01.0622 */ + /* File created by MIDL compiler version 8.01.0628 */ /* @@MIDL_FILE_HEADING( ) */ /* verify that the version is high enough to compile this file*/ #ifndef __REQUIRED_RPCNDR_H_VERSION__ -#define __REQUIRED_RPCNDR_H_VERSION__ 475 +#define __REQUIRED_RPCNDR_H_VERSION__ 501 #endif /* verify that the version is high enough to compile this file*/ @@ -37,6 +37,14 @@ #pragma once #endif +#ifndef DECLSPEC_XFGVIRT +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func)) +#else +#define DECLSPEC_XFGVIRT(base, func) +#endif +#endif + /* Forward Declarations */ #ifndef __IDXGIOutput5_FWD_DEFINED__ @@ -78,6 +86,9 @@ extern "C"{ /* interface __MIDL_itf_dxgi1_5_0000_0000 */ /* [local] */ +#include +#pragma region App Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) typedef enum DXGI_OUTDUPL_FLAG { @@ -124,18 +135,22 @@ EXTERN_C const IID IID_IDXGIOutput5; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIOutput5 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIOutput5 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIOutput5 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIOutput5 * This, /* [annotation][in] */ @@ -144,6 +159,7 @@ EXTERN_C const IID IID_IDXGIOutput5; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIOutput5 * This, /* [annotation][in] */ @@ -151,6 +167,7 @@ EXTERN_C const IID IID_IDXGIOutput5; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIOutput5 * This, /* [annotation][in] */ @@ -160,6 +177,7 @@ EXTERN_C const IID IID_IDXGIOutput5; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIOutput5 * This, /* [annotation][in] */ @@ -167,11 +185,13 @@ EXTERN_C const IID IID_IDXGIOutput5; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGIOutput5 * This, /* [annotation][out] */ _Out_ DXGI_OUTPUT_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplayModeList) HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList )( IDXGIOutput5 * This, /* [in] */ DXGI_FORMAT EnumFormat, @@ -181,6 +201,7 @@ EXTERN_C const IID IID_IDXGIOutput5; /* [annotation][out] */ _Out_writes_to_opt_(*pNumModes,*pNumModes) DXGI_MODE_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, FindClosestMatchingMode) HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode )( IDXGIOutput5 * This, /* [annotation][in] */ @@ -190,48 +211,58 @@ EXTERN_C const IID IID_IDXGIOutput5; /* [annotation][in] */ _In_opt_ IUnknown *pConcernedDevice); + DECLSPEC_XFGVIRT(IDXGIOutput, WaitForVBlank) HRESULT ( STDMETHODCALLTYPE *WaitForVBlank )( IDXGIOutput5 * This); + DECLSPEC_XFGVIRT(IDXGIOutput, TakeOwnership) HRESULT ( STDMETHODCALLTYPE *TakeOwnership )( IDXGIOutput5 * This, /* [annotation][in] */ _In_ IUnknown *pDevice, BOOL Exclusive); + DECLSPEC_XFGVIRT(IDXGIOutput, ReleaseOwnership) void ( STDMETHODCALLTYPE *ReleaseOwnership )( IDXGIOutput5 * This); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControlCapabilities) HRESULT ( STDMETHODCALLTYPE *GetGammaControlCapabilities )( IDXGIOutput5 * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL_CAPABILITIES *pGammaCaps); + DECLSPEC_XFGVIRT(IDXGIOutput, SetGammaControl) HRESULT ( STDMETHODCALLTYPE *SetGammaControl )( IDXGIOutput5 * This, /* [annotation][in] */ _In_ const DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControl) HRESULT ( STDMETHODCALLTYPE *GetGammaControl )( IDXGIOutput5 * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, SetDisplaySurface) HRESULT ( STDMETHODCALLTYPE *SetDisplaySurface )( IDXGIOutput5 * This, /* [annotation][in] */ _In_ IDXGISurface *pScanoutSurface); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplaySurfaceData) HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData )( IDXGIOutput5 * This, /* [annotation][in] */ _In_ IDXGISurface *pDestination); + DECLSPEC_XFGVIRT(IDXGIOutput, GetFrameStatistics) HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( IDXGIOutput5 * This, /* [annotation][out] */ _Out_ DXGI_FRAME_STATISTICS *pStats); + DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplayModeList1) HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList1 )( IDXGIOutput5 * This, /* [in] */ DXGI_FORMAT EnumFormat, @@ -241,6 +272,7 @@ EXTERN_C const IID IID_IDXGIOutput5; /* [annotation][out] */ _Out_writes_to_opt_(*pNumModes,*pNumModes) DXGI_MODE_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput1, FindClosestMatchingMode1) HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode1 )( IDXGIOutput5 * This, /* [annotation][in] */ @@ -250,11 +282,13 @@ EXTERN_C const IID IID_IDXGIOutput5; /* [annotation][in] */ _In_opt_ IUnknown *pConcernedDevice); + DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplaySurfaceData1) HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData1 )( IDXGIOutput5 * This, /* [annotation][in] */ _In_ IDXGIResource *pDestination); + DECLSPEC_XFGVIRT(IDXGIOutput1, DuplicateOutput) HRESULT ( STDMETHODCALLTYPE *DuplicateOutput )( IDXGIOutput5 * This, /* [annotation][in] */ @@ -262,9 +296,11 @@ EXTERN_C const IID IID_IDXGIOutput5; /* [annotation][out] */ _COM_Outptr_ IDXGIOutputDuplication **ppOutputDuplication); + DECLSPEC_XFGVIRT(IDXGIOutput2, SupportsOverlays) BOOL ( STDMETHODCALLTYPE *SupportsOverlays )( IDXGIOutput5 * This); + DECLSPEC_XFGVIRT(IDXGIOutput3, CheckOverlaySupport) HRESULT ( STDMETHODCALLTYPE *CheckOverlaySupport )( IDXGIOutput5 * This, /* [annotation][in] */ @@ -274,6 +310,7 @@ EXTERN_C const IID IID_IDXGIOutput5; /* [annotation][out] */ _Out_ UINT *pFlags); + DECLSPEC_XFGVIRT(IDXGIOutput4, CheckOverlayColorSpaceSupport) HRESULT ( STDMETHODCALLTYPE *CheckOverlayColorSpaceSupport )( IDXGIOutput5 * This, /* [annotation][in] */ @@ -285,6 +322,7 @@ EXTERN_C const IID IID_IDXGIOutput5; /* [annotation][out] */ _Out_ UINT *pFlags); + DECLSPEC_XFGVIRT(IDXGIOutput5, DuplicateOutput1) HRESULT ( STDMETHODCALLTYPE *DuplicateOutput1 )( IDXGIOutput5 * This, /* [annotation][in] */ @@ -474,18 +512,22 @@ EXTERN_C const IID IID_IDXGISwapChain4; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGISwapChain4 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGISwapChain4 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGISwapChain4 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGISwapChain4 * This, /* [annotation][in] */ @@ -494,6 +536,7 @@ EXTERN_C const IID IID_IDXGISwapChain4; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGISwapChain4 * This, /* [annotation][in] */ @@ -501,6 +544,7 @@ EXTERN_C const IID IID_IDXGISwapChain4; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGISwapChain4 * This, /* [annotation][in] */ @@ -510,6 +554,7 @@ EXTERN_C const IID IID_IDXGISwapChain4; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGISwapChain4 * This, /* [annotation][in] */ @@ -517,6 +562,7 @@ EXTERN_C const IID IID_IDXGISwapChain4; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice) HRESULT ( STDMETHODCALLTYPE *GetDevice )( IDXGISwapChain4 * This, /* [annotation][in] */ @@ -524,11 +570,13 @@ EXTERN_C const IID IID_IDXGISwapChain4; /* [annotation][retval][out] */ _COM_Outptr_ void **ppDevice); + DECLSPEC_XFGVIRT(IDXGISwapChain, Present) HRESULT ( STDMETHODCALLTYPE *Present )( IDXGISwapChain4 * This, /* [in] */ UINT SyncInterval, /* [in] */ UINT Flags); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetBuffer) HRESULT ( STDMETHODCALLTYPE *GetBuffer )( IDXGISwapChain4 * This, /* [in] */ UINT Buffer, @@ -537,12 +585,14 @@ EXTERN_C const IID IID_IDXGISwapChain4; /* [annotation][out][in] */ _COM_Outptr_ void **ppSurface); + DECLSPEC_XFGVIRT(IDXGISwapChain, SetFullscreenState) HRESULT ( STDMETHODCALLTYPE *SetFullscreenState )( IDXGISwapChain4 * This, /* [in] */ BOOL Fullscreen, /* [annotation][in] */ _In_opt_ IDXGIOutput *pTarget); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetFullscreenState) HRESULT ( STDMETHODCALLTYPE *GetFullscreenState )( IDXGISwapChain4 * This, /* [annotation][out] */ @@ -550,11 +600,13 @@ EXTERN_C const IID IID_IDXGISwapChain4; /* [annotation][out] */ _COM_Outptr_opt_result_maybenull_ IDXGIOutput **ppTarget); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGISwapChain4 * This, /* [annotation][out] */ _Out_ DXGI_SWAP_CHAIN_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeBuffers) HRESULT ( STDMETHODCALLTYPE *ResizeBuffers )( IDXGISwapChain4 * This, /* [in] */ UINT BufferCount, @@ -563,41 +615,49 @@ EXTERN_C const IID IID_IDXGISwapChain4; /* [in] */ DXGI_FORMAT NewFormat, /* [in] */ UINT SwapChainFlags); + DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeTarget) HRESULT ( STDMETHODCALLTYPE *ResizeTarget )( IDXGISwapChain4 * This, /* [annotation][in] */ _In_ const DXGI_MODE_DESC *pNewTargetParameters); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetContainingOutput) HRESULT ( STDMETHODCALLTYPE *GetContainingOutput )( IDXGISwapChain4 * This, /* [annotation][out] */ _COM_Outptr_ IDXGIOutput **ppOutput); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetFrameStatistics) HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( IDXGISwapChain4 * This, /* [annotation][out] */ _Out_ DXGI_FRAME_STATISTICS *pStats); + DECLSPEC_XFGVIRT(IDXGISwapChain, GetLastPresentCount) HRESULT ( STDMETHODCALLTYPE *GetLastPresentCount )( IDXGISwapChain4 * This, /* [annotation][out] */ _Out_ UINT *pLastPresentCount); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetDesc1) HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( IDXGISwapChain4 * This, /* [annotation][out] */ _Out_ DXGI_SWAP_CHAIN_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetFullscreenDesc) HRESULT ( STDMETHODCALLTYPE *GetFullscreenDesc )( IDXGISwapChain4 * This, /* [annotation][out] */ _Out_ DXGI_SWAP_CHAIN_FULLSCREEN_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetHwnd) HRESULT ( STDMETHODCALLTYPE *GetHwnd )( IDXGISwapChain4 * This, /* [annotation][out] */ _Out_ HWND *pHwnd); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetCoreWindow) HRESULT ( STDMETHODCALLTYPE *GetCoreWindow )( IDXGISwapChain4 * This, /* [annotation][in] */ @@ -605,6 +665,7 @@ EXTERN_C const IID IID_IDXGISwapChain4; /* [annotation][out] */ _COM_Outptr_ void **ppUnk); + DECLSPEC_XFGVIRT(IDXGISwapChain1, Present1) HRESULT ( STDMETHODCALLTYPE *Present1 )( IDXGISwapChain4 * This, /* [in] */ UINT SyncInterval, @@ -612,39 +673,47 @@ EXTERN_C const IID IID_IDXGISwapChain4; /* [annotation][in] */ _In_ const DXGI_PRESENT_PARAMETERS *pPresentParameters); + DECLSPEC_XFGVIRT(IDXGISwapChain1, IsTemporaryMonoSupported) BOOL ( STDMETHODCALLTYPE *IsTemporaryMonoSupported )( IDXGISwapChain4 * This); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetRestrictToOutput) HRESULT ( STDMETHODCALLTYPE *GetRestrictToOutput )( IDXGISwapChain4 * This, /* [annotation][out] */ _Out_ IDXGIOutput **ppRestrictToOutput); + DECLSPEC_XFGVIRT(IDXGISwapChain1, SetBackgroundColor) HRESULT ( STDMETHODCALLTYPE *SetBackgroundColor )( IDXGISwapChain4 * This, /* [annotation][in] */ _In_ const DXGI_RGBA *pColor); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetBackgroundColor) HRESULT ( STDMETHODCALLTYPE *GetBackgroundColor )( IDXGISwapChain4 * This, /* [annotation][out] */ _Out_ DXGI_RGBA *pColor); + DECLSPEC_XFGVIRT(IDXGISwapChain1, SetRotation) HRESULT ( STDMETHODCALLTYPE *SetRotation )( IDXGISwapChain4 * This, /* [annotation][in] */ _In_ DXGI_MODE_ROTATION Rotation); + DECLSPEC_XFGVIRT(IDXGISwapChain1, GetRotation) HRESULT ( STDMETHODCALLTYPE *GetRotation )( IDXGISwapChain4 * This, /* [annotation][out] */ _Out_ DXGI_MODE_ROTATION *pRotation); + DECLSPEC_XFGVIRT(IDXGISwapChain2, SetSourceSize) HRESULT ( STDMETHODCALLTYPE *SetSourceSize )( IDXGISwapChain4 * This, UINT Width, UINT Height); + DECLSPEC_XFGVIRT(IDXGISwapChain2, GetSourceSize) HRESULT ( STDMETHODCALLTYPE *GetSourceSize )( IDXGISwapChain4 * This, /* [annotation][out] */ @@ -652,30 +721,37 @@ EXTERN_C const IID IID_IDXGISwapChain4; /* [annotation][out] */ _Out_ UINT *pHeight); + DECLSPEC_XFGVIRT(IDXGISwapChain2, SetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *SetMaximumFrameLatency )( IDXGISwapChain4 * This, UINT MaxLatency); + DECLSPEC_XFGVIRT(IDXGISwapChain2, GetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *GetMaximumFrameLatency )( IDXGISwapChain4 * This, /* [annotation][out] */ _Out_ UINT *pMaxLatency); + DECLSPEC_XFGVIRT(IDXGISwapChain2, GetFrameLatencyWaitableObject) HANDLE ( STDMETHODCALLTYPE *GetFrameLatencyWaitableObject )( IDXGISwapChain4 * This); + DECLSPEC_XFGVIRT(IDXGISwapChain2, SetMatrixTransform) HRESULT ( STDMETHODCALLTYPE *SetMatrixTransform )( IDXGISwapChain4 * This, const DXGI_MATRIX_3X2_F *pMatrix); + DECLSPEC_XFGVIRT(IDXGISwapChain2, GetMatrixTransform) HRESULT ( STDMETHODCALLTYPE *GetMatrixTransform )( IDXGISwapChain4 * This, /* [annotation][out] */ _Out_ DXGI_MATRIX_3X2_F *pMatrix); + DECLSPEC_XFGVIRT(IDXGISwapChain3, GetCurrentBackBufferIndex) UINT ( STDMETHODCALLTYPE *GetCurrentBackBufferIndex )( IDXGISwapChain4 * This); + DECLSPEC_XFGVIRT(IDXGISwapChain3, CheckColorSpaceSupport) HRESULT ( STDMETHODCALLTYPE *CheckColorSpaceSupport )( IDXGISwapChain4 * This, /* [annotation][in] */ @@ -683,11 +759,13 @@ EXTERN_C const IID IID_IDXGISwapChain4; /* [annotation][out] */ _Out_ UINT *pColorSpaceSupport); + DECLSPEC_XFGVIRT(IDXGISwapChain3, SetColorSpace1) HRESULT ( STDMETHODCALLTYPE *SetColorSpace1 )( IDXGISwapChain4 * This, /* [annotation][in] */ _In_ DXGI_COLOR_SPACE_TYPE ColorSpace); + DECLSPEC_XFGVIRT(IDXGISwapChain3, ResizeBuffers1) HRESULT ( STDMETHODCALLTYPE *ResizeBuffers1 )( IDXGISwapChain4 * This, /* [annotation][in] */ @@ -705,6 +783,7 @@ EXTERN_C const IID IID_IDXGISwapChain4; /* [annotation][in] */ _In_reads_(BufferCount) IUnknown *const *ppPresentQueue); + DECLSPEC_XFGVIRT(IDXGISwapChain4, SetHDRMetaData) HRESULT ( STDMETHODCALLTYPE *SetHDRMetaData )( IDXGISwapChain4 * This, /* [annotation][in] */ @@ -932,18 +1011,22 @@ EXTERN_C const IID IID_IDXGIDevice4; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIDevice4 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIDevice4 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIDevice4 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIDevice4 * This, /* [annotation][in] */ @@ -952,6 +1035,7 @@ EXTERN_C const IID IID_IDXGIDevice4; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIDevice4 * This, /* [annotation][in] */ @@ -959,6 +1043,7 @@ EXTERN_C const IID IID_IDXGIDevice4; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIDevice4 * This, /* [annotation][in] */ @@ -968,6 +1053,7 @@ EXTERN_C const IID IID_IDXGIDevice4; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIDevice4 * This, /* [annotation][in] */ @@ -975,11 +1061,13 @@ EXTERN_C const IID IID_IDXGIDevice4; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIDevice, GetAdapter) HRESULT ( STDMETHODCALLTYPE *GetAdapter )( IDXGIDevice4 * This, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **pAdapter); + DECLSPEC_XFGVIRT(IDXGIDevice, CreateSurface) HRESULT ( STDMETHODCALLTYPE *CreateSurface )( IDXGIDevice4 * This, /* [annotation][in] */ @@ -988,9 +1076,10 @@ EXTERN_C const IID IID_IDXGIDevice4; /* [in] */ DXGI_USAGE Usage, /* [annotation][in] */ _In_opt_ const DXGI_SHARED_RESOURCE *pSharedResource, - /* [annotation][out] */ - _COM_Outptr_ IDXGISurface **ppSurface); + /* [annotation][size_is][out] */ + _Out_writes_(NumSurfaces) IDXGISurface **ppSurface); + DECLSPEC_XFGVIRT(IDXGIDevice, QueryResourceResidency) HRESULT ( STDMETHODCALLTYPE *QueryResourceResidency )( IDXGIDevice4 * This, /* [annotation][size_is][in] */ @@ -999,24 +1088,29 @@ EXTERN_C const IID IID_IDXGIDevice4; _Out_writes_(NumResources) DXGI_RESIDENCY *pResidencyStatus, /* [in] */ UINT NumResources); + DECLSPEC_XFGVIRT(IDXGIDevice, SetGPUThreadPriority) HRESULT ( STDMETHODCALLTYPE *SetGPUThreadPriority )( IDXGIDevice4 * This, /* [in] */ INT Priority); + DECLSPEC_XFGVIRT(IDXGIDevice, GetGPUThreadPriority) HRESULT ( STDMETHODCALLTYPE *GetGPUThreadPriority )( IDXGIDevice4 * This, /* [annotation][retval][out] */ _Out_ INT *pPriority); + DECLSPEC_XFGVIRT(IDXGIDevice1, SetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *SetMaximumFrameLatency )( IDXGIDevice4 * This, /* [in] */ UINT MaxLatency); + DECLSPEC_XFGVIRT(IDXGIDevice1, GetMaximumFrameLatency) HRESULT ( STDMETHODCALLTYPE *GetMaximumFrameLatency )( IDXGIDevice4 * This, /* [annotation][out] */ _Out_ UINT *pMaxLatency); + DECLSPEC_XFGVIRT(IDXGIDevice2, OfferResources) HRESULT ( STDMETHODCALLTYPE *OfferResources )( IDXGIDevice4 * This, /* [annotation][in] */ @@ -1026,6 +1120,7 @@ EXTERN_C const IID IID_IDXGIDevice4; /* [annotation][in] */ _In_ DXGI_OFFER_RESOURCE_PRIORITY Priority); + DECLSPEC_XFGVIRT(IDXGIDevice2, ReclaimResources) HRESULT ( STDMETHODCALLTYPE *ReclaimResources )( IDXGIDevice4 * This, /* [annotation][in] */ @@ -1035,14 +1130,17 @@ EXTERN_C const IID IID_IDXGIDevice4; /* [annotation][size_is][out] */ _Out_writes_all_opt_(NumResources) BOOL *pDiscarded); + DECLSPEC_XFGVIRT(IDXGIDevice2, EnqueueSetEvent) HRESULT ( STDMETHODCALLTYPE *EnqueueSetEvent )( IDXGIDevice4 * This, /* [annotation][in] */ _In_ HANDLE hEvent); + DECLSPEC_XFGVIRT(IDXGIDevice3, Trim) void ( STDMETHODCALLTYPE *Trim )( IDXGIDevice4 * This); + DECLSPEC_XFGVIRT(IDXGIDevice4, OfferResources1) HRESULT ( STDMETHODCALLTYPE *OfferResources1 )( IDXGIDevice4 * This, /* [annotation][in] */ @@ -1054,6 +1152,7 @@ EXTERN_C const IID IID_IDXGIDevice4; /* [annotation][in] */ _In_ UINT Flags); + DECLSPEC_XFGVIRT(IDXGIDevice4, ReclaimResources1) HRESULT ( STDMETHODCALLTYPE *ReclaimResources1 )( IDXGIDevice4 * This, /* [annotation][in] */ @@ -1197,18 +1296,22 @@ EXTERN_C const IID IID_IDXGIFactory5; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIFactory5 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIFactory5 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIFactory5 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIFactory5 * This, /* [annotation][in] */ @@ -1217,6 +1320,7 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIFactory5 * This, /* [annotation][in] */ @@ -1224,6 +1328,7 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIFactory5 * This, /* [annotation][in] */ @@ -1233,6 +1338,7 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIFactory5 * This, /* [annotation][in] */ @@ -1240,22 +1346,26 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIFactory, EnumAdapters) HRESULT ( STDMETHODCALLTYPE *EnumAdapters )( IDXGIFactory5 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory, MakeWindowAssociation) HRESULT ( STDMETHODCALLTYPE *MakeWindowAssociation )( IDXGIFactory5 * This, HWND WindowHandle, UINT Flags); + DECLSPEC_XFGVIRT(IDXGIFactory, GetWindowAssociation) HRESULT ( STDMETHODCALLTYPE *GetWindowAssociation )( IDXGIFactory5 * This, /* [annotation][out] */ _Out_ HWND *pWindowHandle); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSwapChain) HRESULT ( STDMETHODCALLTYPE *CreateSwapChain )( IDXGIFactory5 * This, /* [annotation][in] */ @@ -1265,24 +1375,29 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSoftwareAdapter) HRESULT ( STDMETHODCALLTYPE *CreateSoftwareAdapter )( IDXGIFactory5 * This, /* [in] */ HMODULE Module, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, EnumAdapters1) HRESULT ( STDMETHODCALLTYPE *EnumAdapters1 )( IDXGIFactory5 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter1 **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, IsCurrent) BOOL ( STDMETHODCALLTYPE *IsCurrent )( IDXGIFactory5 * This); + DECLSPEC_XFGVIRT(IDXGIFactory2, IsWindowedStereoEnabled) BOOL ( STDMETHODCALLTYPE *IsWindowedStereoEnabled )( IDXGIFactory5 * This); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForHwnd) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForHwnd )( IDXGIFactory5 * This, /* [annotation][in] */ @@ -1298,6 +1413,7 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForCoreWindow) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForCoreWindow )( IDXGIFactory5 * This, /* [annotation][in] */ @@ -1311,6 +1427,7 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory2, GetSharedResourceAdapterLuid) HRESULT ( STDMETHODCALLTYPE *GetSharedResourceAdapterLuid )( IDXGIFactory5 * This, /* [annotation] */ @@ -1318,6 +1435,7 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation] */ _Out_ LUID *pLuid); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusWindow) HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusWindow )( IDXGIFactory5 * This, /* [annotation][in] */ @@ -1327,6 +1445,7 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusEvent )( IDXGIFactory5 * This, /* [annotation][in] */ @@ -1334,11 +1453,13 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterStereoStatus) void ( STDMETHODCALLTYPE *UnregisterStereoStatus )( IDXGIFactory5 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusWindow) HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusWindow )( IDXGIFactory5 * This, /* [annotation][in] */ @@ -1348,6 +1469,7 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusEvent )( IDXGIFactory5 * This, /* [annotation][in] */ @@ -1355,11 +1477,13 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterOcclusionStatus) void ( STDMETHODCALLTYPE *UnregisterOcclusionStatus )( IDXGIFactory5 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForComposition) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForComposition )( IDXGIFactory5 * This, /* [annotation][in] */ @@ -1371,9 +1495,11 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory3, GetCreationFlags) UINT ( STDMETHODCALLTYPE *GetCreationFlags )( IDXGIFactory5 * This); + DECLSPEC_XFGVIRT(IDXGIFactory4, EnumAdapterByLuid) HRESULT ( STDMETHODCALLTYPE *EnumAdapterByLuid )( IDXGIFactory5 * This, /* [annotation] */ @@ -1383,6 +1509,7 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation] */ _COM_Outptr_ void **ppvAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory4, EnumWarpAdapter) HRESULT ( STDMETHODCALLTYPE *EnumWarpAdapter )( IDXGIFactory5 * This, /* [annotation] */ @@ -1390,6 +1517,7 @@ EXTERN_C const IID IID_IDXGIFactory5; /* [annotation] */ _COM_Outptr_ void **ppvAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory5, CheckFeatureSupport) HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( IDXGIFactory5 * This, DXGI_FEATURE Feature, @@ -1518,6 +1646,8 @@ EXTERN_C const IID IID_IDXGIFactory5; /* interface __MIDL_itf_dxgi1_5_0000_0004 */ /* [local] */ +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ +#pragma endregion DEFINE_GUID(IID_IDXGIOutput5,0x80A07424,0xAB52,0x42EB,0x83,0x3C,0x0C,0x42,0xFD,0x28,0x2D,0x98); DEFINE_GUID(IID_IDXGISwapChain4,0x3D585D5A,0xBD4A,0x489E,0xB1,0xF4,0x3D,0xBC,0xB6,0x45,0x2F,0xFB); DEFINE_GUID(IID_IDXGIDevice4,0x95B4F95F,0xD8DA,0x4CA4,0x9E,0xE6,0x3B,0x76,0xD5,0x96,0x8A,0x10); diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_6.h b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_6.h index 35d34b9..9ed4865 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_6.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgi1_6.h @@ -3,14 +3,14 @@ /* this ALWAYS GENERATED file contains the definitions for the interfaces */ - /* File created by MIDL compiler version 8.01.0622 */ + /* File created by MIDL compiler version 8.01.0628 */ /* @@MIDL_FILE_HEADING( ) */ /* verify that the version is high enough to compile this file*/ #ifndef __REQUIRED_RPCNDR_H_VERSION__ -#define __REQUIRED_RPCNDR_H_VERSION__ 475 +#define __REQUIRED_RPCNDR_H_VERSION__ 501 #endif /* verify that the version is high enough to compile this file*/ @@ -37,6 +37,14 @@ #pragma once #endif +#ifndef DECLSPEC_XFGVIRT +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func)) +#else +#define DECLSPEC_XFGVIRT(base, func) +#endif +#endif + /* Forward Declarations */ #ifndef __IDXGIAdapter4_FWD_DEFINED__ @@ -79,6 +87,9 @@ extern "C"{ /* [local] */ // Copyright (c) Microsoft Corporation. All Rights Reserved +#include +#pragma region App Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) HRESULT WINAPI DXGIDeclareAdapterRemovalSupport(); typedef enum DXGI_ADAPTER_FLAG3 @@ -143,18 +154,22 @@ EXTERN_C const IID IID_IDXGIAdapter4; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIAdapter4 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIAdapter4 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIAdapter4 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIAdapter4 * This, /* [annotation][in] */ @@ -163,6 +178,7 @@ EXTERN_C const IID IID_IDXGIAdapter4; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIAdapter4 * This, /* [annotation][in] */ @@ -170,6 +186,7 @@ EXTERN_C const IID IID_IDXGIAdapter4; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIAdapter4 * This, /* [annotation][in] */ @@ -179,6 +196,7 @@ EXTERN_C const IID IID_IDXGIAdapter4; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIAdapter4 * This, /* [annotation][in] */ @@ -186,17 +204,20 @@ EXTERN_C const IID IID_IDXGIAdapter4; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIAdapter, EnumOutputs) HRESULT ( STDMETHODCALLTYPE *EnumOutputs )( IDXGIAdapter4 * This, /* [in] */ UINT Output, /* [annotation][out][in] */ _COM_Outptr_ IDXGIOutput **ppOutput); + DECLSPEC_XFGVIRT(IDXGIAdapter, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGIAdapter4 * This, /* [annotation][out] */ _Out_ DXGI_ADAPTER_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIAdapter, CheckInterfaceSupport) HRESULT ( STDMETHODCALLTYPE *CheckInterfaceSupport )( IDXGIAdapter4 * This, /* [annotation][in] */ @@ -204,16 +225,19 @@ EXTERN_C const IID IID_IDXGIAdapter4; /* [annotation][out] */ _Out_ LARGE_INTEGER *pUMDVersion); + DECLSPEC_XFGVIRT(IDXGIAdapter1, GetDesc1) HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( IDXGIAdapter4 * This, /* [annotation][out] */ _Out_ DXGI_ADAPTER_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGIAdapter2, GetDesc2) HRESULT ( STDMETHODCALLTYPE *GetDesc2 )( IDXGIAdapter4 * This, /* [annotation][out] */ _Out_ DXGI_ADAPTER_DESC2 *pDesc); + DECLSPEC_XFGVIRT(IDXGIAdapter3, RegisterHardwareContentProtectionTeardownStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterHardwareContentProtectionTeardownStatusEvent )( IDXGIAdapter4 * This, /* [annotation][in] */ @@ -221,11 +245,13 @@ EXTERN_C const IID IID_IDXGIAdapter4; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIAdapter3, UnregisterHardwareContentProtectionTeardownStatus) void ( STDMETHODCALLTYPE *UnregisterHardwareContentProtectionTeardownStatus )( IDXGIAdapter4 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIAdapter3, QueryVideoMemoryInfo) HRESULT ( STDMETHODCALLTYPE *QueryVideoMemoryInfo )( IDXGIAdapter4 * This, /* [annotation][in] */ @@ -235,6 +261,7 @@ EXTERN_C const IID IID_IDXGIAdapter4; /* [annotation][out] */ _Out_ DXGI_QUERY_VIDEO_MEMORY_INFO *pVideoMemoryInfo); + DECLSPEC_XFGVIRT(IDXGIAdapter3, SetVideoMemoryReservation) HRESULT ( STDMETHODCALLTYPE *SetVideoMemoryReservation )( IDXGIAdapter4 * This, /* [annotation][in] */ @@ -244,6 +271,7 @@ EXTERN_C const IID IID_IDXGIAdapter4; /* [annotation][in] */ _In_ UINT64 Reservation); + DECLSPEC_XFGVIRT(IDXGIAdapter3, RegisterVideoMemoryBudgetChangeNotificationEvent) HRESULT ( STDMETHODCALLTYPE *RegisterVideoMemoryBudgetChangeNotificationEvent )( IDXGIAdapter4 * This, /* [annotation][in] */ @@ -251,11 +279,13 @@ EXTERN_C const IID IID_IDXGIAdapter4; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIAdapter3, UnregisterVideoMemoryBudgetChangeNotification) void ( STDMETHODCALLTYPE *UnregisterVideoMemoryBudgetChangeNotification )( IDXGIAdapter4 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIAdapter4, GetDesc3) HRESULT ( STDMETHODCALLTYPE *GetDesc3 )( IDXGIAdapter4 * This, /* [annotation][out] */ @@ -415,18 +445,22 @@ EXTERN_C const IID IID_IDXGIOutput6; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIOutput6 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIOutput6 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIOutput6 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIOutput6 * This, /* [annotation][in] */ @@ -435,6 +469,7 @@ EXTERN_C const IID IID_IDXGIOutput6; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIOutput6 * This, /* [annotation][in] */ @@ -442,6 +477,7 @@ EXTERN_C const IID IID_IDXGIOutput6; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIOutput6 * This, /* [annotation][in] */ @@ -451,6 +487,7 @@ EXTERN_C const IID IID_IDXGIOutput6; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIOutput6 * This, /* [annotation][in] */ @@ -458,11 +495,13 @@ EXTERN_C const IID IID_IDXGIOutput6; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDesc) HRESULT ( STDMETHODCALLTYPE *GetDesc )( IDXGIOutput6 * This, /* [annotation][out] */ _Out_ DXGI_OUTPUT_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplayModeList) HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList )( IDXGIOutput6 * This, /* [in] */ DXGI_FORMAT EnumFormat, @@ -472,6 +511,7 @@ EXTERN_C const IID IID_IDXGIOutput6; /* [annotation][out] */ _Out_writes_to_opt_(*pNumModes,*pNumModes) DXGI_MODE_DESC *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput, FindClosestMatchingMode) HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode )( IDXGIOutput6 * This, /* [annotation][in] */ @@ -481,48 +521,58 @@ EXTERN_C const IID IID_IDXGIOutput6; /* [annotation][in] */ _In_opt_ IUnknown *pConcernedDevice); + DECLSPEC_XFGVIRT(IDXGIOutput, WaitForVBlank) HRESULT ( STDMETHODCALLTYPE *WaitForVBlank )( IDXGIOutput6 * This); + DECLSPEC_XFGVIRT(IDXGIOutput, TakeOwnership) HRESULT ( STDMETHODCALLTYPE *TakeOwnership )( IDXGIOutput6 * This, /* [annotation][in] */ _In_ IUnknown *pDevice, BOOL Exclusive); + DECLSPEC_XFGVIRT(IDXGIOutput, ReleaseOwnership) void ( STDMETHODCALLTYPE *ReleaseOwnership )( IDXGIOutput6 * This); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControlCapabilities) HRESULT ( STDMETHODCALLTYPE *GetGammaControlCapabilities )( IDXGIOutput6 * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL_CAPABILITIES *pGammaCaps); + DECLSPEC_XFGVIRT(IDXGIOutput, SetGammaControl) HRESULT ( STDMETHODCALLTYPE *SetGammaControl )( IDXGIOutput6 * This, /* [annotation][in] */ _In_ const DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControl) HRESULT ( STDMETHODCALLTYPE *GetGammaControl )( IDXGIOutput6 * This, /* [annotation][out] */ _Out_ DXGI_GAMMA_CONTROL *pArray); + DECLSPEC_XFGVIRT(IDXGIOutput, SetDisplaySurface) HRESULT ( STDMETHODCALLTYPE *SetDisplaySurface )( IDXGIOutput6 * This, /* [annotation][in] */ _In_ IDXGISurface *pScanoutSurface); + DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplaySurfaceData) HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData )( IDXGIOutput6 * This, /* [annotation][in] */ _In_ IDXGISurface *pDestination); + DECLSPEC_XFGVIRT(IDXGIOutput, GetFrameStatistics) HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( IDXGIOutput6 * This, /* [annotation][out] */ _Out_ DXGI_FRAME_STATISTICS *pStats); + DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplayModeList1) HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList1 )( IDXGIOutput6 * This, /* [in] */ DXGI_FORMAT EnumFormat, @@ -532,6 +582,7 @@ EXTERN_C const IID IID_IDXGIOutput6; /* [annotation][out] */ _Out_writes_to_opt_(*pNumModes,*pNumModes) DXGI_MODE_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput1, FindClosestMatchingMode1) HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode1 )( IDXGIOutput6 * This, /* [annotation][in] */ @@ -541,11 +592,13 @@ EXTERN_C const IID IID_IDXGIOutput6; /* [annotation][in] */ _In_opt_ IUnknown *pConcernedDevice); + DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplaySurfaceData1) HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData1 )( IDXGIOutput6 * This, /* [annotation][in] */ _In_ IDXGIResource *pDestination); + DECLSPEC_XFGVIRT(IDXGIOutput1, DuplicateOutput) HRESULT ( STDMETHODCALLTYPE *DuplicateOutput )( IDXGIOutput6 * This, /* [annotation][in] */ @@ -553,9 +606,11 @@ EXTERN_C const IID IID_IDXGIOutput6; /* [annotation][out] */ _COM_Outptr_ IDXGIOutputDuplication **ppOutputDuplication); + DECLSPEC_XFGVIRT(IDXGIOutput2, SupportsOverlays) BOOL ( STDMETHODCALLTYPE *SupportsOverlays )( IDXGIOutput6 * This); + DECLSPEC_XFGVIRT(IDXGIOutput3, CheckOverlaySupport) HRESULT ( STDMETHODCALLTYPE *CheckOverlaySupport )( IDXGIOutput6 * This, /* [annotation][in] */ @@ -565,6 +620,7 @@ EXTERN_C const IID IID_IDXGIOutput6; /* [annotation][out] */ _Out_ UINT *pFlags); + DECLSPEC_XFGVIRT(IDXGIOutput4, CheckOverlayColorSpaceSupport) HRESULT ( STDMETHODCALLTYPE *CheckOverlayColorSpaceSupport )( IDXGIOutput6 * This, /* [annotation][in] */ @@ -576,6 +632,7 @@ EXTERN_C const IID IID_IDXGIOutput6; /* [annotation][out] */ _Out_ UINT *pFlags); + DECLSPEC_XFGVIRT(IDXGIOutput5, DuplicateOutput1) HRESULT ( STDMETHODCALLTYPE *DuplicateOutput1 )( IDXGIOutput6 * This, /* [annotation][in] */ @@ -588,11 +645,13 @@ EXTERN_C const IID IID_IDXGIOutput6; /* [annotation][out] */ _COM_Outptr_ IDXGIOutputDuplication **ppOutputDuplication); + DECLSPEC_XFGVIRT(IDXGIOutput6, GetDesc1) HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( IDXGIOutput6 * This, /* [annotation][out] */ _Out_ DXGI_OUTPUT_DESC1 *pDesc); + DECLSPEC_XFGVIRT(IDXGIOutput6, CheckHardwareCompositionSupport) HRESULT ( STDMETHODCALLTYPE *CheckHardwareCompositionSupport )( IDXGIOutput6 * This, /* [annotation][out] */ @@ -767,18 +826,22 @@ EXTERN_C const IID IID_IDXGIFactory6; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIFactory6 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIFactory6 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIFactory6 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIFactory6 * This, /* [annotation][in] */ @@ -787,6 +850,7 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIFactory6 * This, /* [annotation][in] */ @@ -794,6 +858,7 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIFactory6 * This, /* [annotation][in] */ @@ -803,6 +868,7 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIFactory6 * This, /* [annotation][in] */ @@ -810,22 +876,26 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIFactory, EnumAdapters) HRESULT ( STDMETHODCALLTYPE *EnumAdapters )( IDXGIFactory6 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory, MakeWindowAssociation) HRESULT ( STDMETHODCALLTYPE *MakeWindowAssociation )( IDXGIFactory6 * This, HWND WindowHandle, UINT Flags); + DECLSPEC_XFGVIRT(IDXGIFactory, GetWindowAssociation) HRESULT ( STDMETHODCALLTYPE *GetWindowAssociation )( IDXGIFactory6 * This, /* [annotation][out] */ _Out_ HWND *pWindowHandle); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSwapChain) HRESULT ( STDMETHODCALLTYPE *CreateSwapChain )( IDXGIFactory6 * This, /* [annotation][in] */ @@ -835,24 +905,29 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSoftwareAdapter) HRESULT ( STDMETHODCALLTYPE *CreateSoftwareAdapter )( IDXGIFactory6 * This, /* [in] */ HMODULE Module, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, EnumAdapters1) HRESULT ( STDMETHODCALLTYPE *EnumAdapters1 )( IDXGIFactory6 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter1 **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, IsCurrent) BOOL ( STDMETHODCALLTYPE *IsCurrent )( IDXGIFactory6 * This); + DECLSPEC_XFGVIRT(IDXGIFactory2, IsWindowedStereoEnabled) BOOL ( STDMETHODCALLTYPE *IsWindowedStereoEnabled )( IDXGIFactory6 * This); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForHwnd) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForHwnd )( IDXGIFactory6 * This, /* [annotation][in] */ @@ -868,6 +943,7 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForCoreWindow) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForCoreWindow )( IDXGIFactory6 * This, /* [annotation][in] */ @@ -881,6 +957,7 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory2, GetSharedResourceAdapterLuid) HRESULT ( STDMETHODCALLTYPE *GetSharedResourceAdapterLuid )( IDXGIFactory6 * This, /* [annotation] */ @@ -888,6 +965,7 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation] */ _Out_ LUID *pLuid); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusWindow) HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusWindow )( IDXGIFactory6 * This, /* [annotation][in] */ @@ -897,6 +975,7 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusEvent )( IDXGIFactory6 * This, /* [annotation][in] */ @@ -904,11 +983,13 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterStereoStatus) void ( STDMETHODCALLTYPE *UnregisterStereoStatus )( IDXGIFactory6 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusWindow) HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusWindow )( IDXGIFactory6 * This, /* [annotation][in] */ @@ -918,6 +999,7 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusEvent )( IDXGIFactory6 * This, /* [annotation][in] */ @@ -925,11 +1007,13 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterOcclusionStatus) void ( STDMETHODCALLTYPE *UnregisterOcclusionStatus )( IDXGIFactory6 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForComposition) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForComposition )( IDXGIFactory6 * This, /* [annotation][in] */ @@ -941,9 +1025,11 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory3, GetCreationFlags) UINT ( STDMETHODCALLTYPE *GetCreationFlags )( IDXGIFactory6 * This); + DECLSPEC_XFGVIRT(IDXGIFactory4, EnumAdapterByLuid) HRESULT ( STDMETHODCALLTYPE *EnumAdapterByLuid )( IDXGIFactory6 * This, /* [annotation] */ @@ -953,6 +1039,7 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation] */ _COM_Outptr_ void **ppvAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory4, EnumWarpAdapter) HRESULT ( STDMETHODCALLTYPE *EnumWarpAdapter )( IDXGIFactory6 * This, /* [annotation] */ @@ -960,6 +1047,7 @@ EXTERN_C const IID IID_IDXGIFactory6; /* [annotation] */ _COM_Outptr_ void **ppvAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory5, CheckFeatureSupport) HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( IDXGIFactory6 * This, DXGI_FEATURE Feature, @@ -967,6 +1055,7 @@ EXTERN_C const IID IID_IDXGIFactory6; _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, UINT FeatureSupportDataSize); + DECLSPEC_XFGVIRT(IDXGIFactory6, EnumAdapterByGpuPreference) HRESULT ( STDMETHODCALLTYPE *EnumAdapterByGpuPreference )( IDXGIFactory6 * This, /* [annotation] */ @@ -1134,18 +1223,22 @@ EXTERN_C const IID IID_IDXGIFactory7; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( IDXGIFactory7 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( IDXGIFactory7 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( IDXGIFactory7 * This); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData) HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1154,6 +1247,7 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation][in] */ _In_reads_bytes_(DataSize) const void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface) HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1161,6 +1255,7 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation][in] */ _In_opt_ const IUnknown *pUnknown); + DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData) HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1170,6 +1265,7 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation][out] */ _Out_writes_bytes_(*pDataSize) void *pData); + DECLSPEC_XFGVIRT(IDXGIObject, GetParent) HRESULT ( STDMETHODCALLTYPE *GetParent )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1177,22 +1273,26 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation][retval][out] */ _COM_Outptr_ void **ppParent); + DECLSPEC_XFGVIRT(IDXGIFactory, EnumAdapters) HRESULT ( STDMETHODCALLTYPE *EnumAdapters )( IDXGIFactory7 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory, MakeWindowAssociation) HRESULT ( STDMETHODCALLTYPE *MakeWindowAssociation )( IDXGIFactory7 * This, HWND WindowHandle, UINT Flags); + DECLSPEC_XFGVIRT(IDXGIFactory, GetWindowAssociation) HRESULT ( STDMETHODCALLTYPE *GetWindowAssociation )( IDXGIFactory7 * This, /* [annotation][out] */ _Out_ HWND *pWindowHandle); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSwapChain) HRESULT ( STDMETHODCALLTYPE *CreateSwapChain )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1202,24 +1302,29 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory, CreateSoftwareAdapter) HRESULT ( STDMETHODCALLTYPE *CreateSoftwareAdapter )( IDXGIFactory7 * This, /* [in] */ HMODULE Module, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, EnumAdapters1) HRESULT ( STDMETHODCALLTYPE *EnumAdapters1 )( IDXGIFactory7 * This, /* [in] */ UINT Adapter, /* [annotation][out] */ _COM_Outptr_ IDXGIAdapter1 **ppAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory1, IsCurrent) BOOL ( STDMETHODCALLTYPE *IsCurrent )( IDXGIFactory7 * This); + DECLSPEC_XFGVIRT(IDXGIFactory2, IsWindowedStereoEnabled) BOOL ( STDMETHODCALLTYPE *IsWindowedStereoEnabled )( IDXGIFactory7 * This); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForHwnd) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForHwnd )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1235,6 +1340,7 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForCoreWindow) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForCoreWindow )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1248,6 +1354,7 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory2, GetSharedResourceAdapterLuid) HRESULT ( STDMETHODCALLTYPE *GetSharedResourceAdapterLuid )( IDXGIFactory7 * This, /* [annotation] */ @@ -1255,6 +1362,7 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation] */ _Out_ LUID *pLuid); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusWindow) HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusWindow )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1264,6 +1372,7 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusEvent )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1271,11 +1380,13 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterStereoStatus) void ( STDMETHODCALLTYPE *UnregisterStereoStatus )( IDXGIFactory7 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusWindow) HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusWindow )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1285,6 +1396,7 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusEvent) HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusEvent )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1292,11 +1404,13 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterOcclusionStatus) void ( STDMETHODCALLTYPE *UnregisterOcclusionStatus )( IDXGIFactory7 * This, /* [annotation][in] */ _In_ DWORD dwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForComposition) HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForComposition )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1308,9 +1422,11 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation][out] */ _COM_Outptr_ IDXGISwapChain1 **ppSwapChain); + DECLSPEC_XFGVIRT(IDXGIFactory3, GetCreationFlags) UINT ( STDMETHODCALLTYPE *GetCreationFlags )( IDXGIFactory7 * This); + DECLSPEC_XFGVIRT(IDXGIFactory4, EnumAdapterByLuid) HRESULT ( STDMETHODCALLTYPE *EnumAdapterByLuid )( IDXGIFactory7 * This, /* [annotation] */ @@ -1320,6 +1436,7 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation] */ _COM_Outptr_ void **ppvAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory4, EnumWarpAdapter) HRESULT ( STDMETHODCALLTYPE *EnumWarpAdapter )( IDXGIFactory7 * This, /* [annotation] */ @@ -1327,6 +1444,7 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation] */ _COM_Outptr_ void **ppvAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory5, CheckFeatureSupport) HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( IDXGIFactory7 * This, DXGI_FEATURE Feature, @@ -1334,6 +1452,7 @@ EXTERN_C const IID IID_IDXGIFactory7; _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData, UINT FeatureSupportDataSize); + DECLSPEC_XFGVIRT(IDXGIFactory6, EnumAdapterByGpuPreference) HRESULT ( STDMETHODCALLTYPE *EnumAdapterByGpuPreference )( IDXGIFactory7 * This, /* [annotation] */ @@ -1345,6 +1464,7 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation] */ _COM_Outptr_ void **ppvAdapter); + DECLSPEC_XFGVIRT(IDXGIFactory7, RegisterAdaptersChangedEvent) HRESULT ( STDMETHODCALLTYPE *RegisterAdaptersChangedEvent )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1352,6 +1472,7 @@ EXTERN_C const IID IID_IDXGIFactory7; /* [annotation][out] */ _Out_ DWORD *pdwCookie); + DECLSPEC_XFGVIRT(IDXGIFactory7, UnregisterAdaptersChangedEvent) HRESULT ( STDMETHODCALLTYPE *UnregisterAdaptersChangedEvent )( IDXGIFactory7 * This, /* [annotation][in] */ @@ -1489,6 +1610,11 @@ EXTERN_C const IID IID_IDXGIFactory7; /* interface __MIDL_itf_dxgi1_6_0000_0004 */ /* [local] */ +#if defined(NTDDI_VERSION) && (NTDDI_VERSION >= NTDDI_WIN10_NI) +HRESULT WINAPI DXGIDisableVBlankVirtualization(); +#endif +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */ +#pragma endregion DEFINE_GUID(IID_IDXGIAdapter4,0x3c8d99d1,0x4fbf,0x4181,0xa8,0x2c,0xaf,0x66,0xbf,0x7b,0xd2,0x4e); DEFINE_GUID(IID_IDXGIOutput6,0x068346e8,0xaaec,0x4b84,0xad,0xd7,0x13,0x7f,0x51,0x3f,0x77,0xa1); DEFINE_GUID(IID_IDXGIFactory6,0xc1b6694f,0xff09,0x44a9,0xb0,0x3c,0x77,0x90,0x0a,0x0a,0x1d,0x17); diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgicommon.h b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgicommon.h index f83aa01..920cee8 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgicommon.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgicommon.h @@ -7,6 +7,7 @@ #define __dxgicommon_h__ + typedef struct DXGI_RATIONAL { UINT Numerator; diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgiformat.h b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgiformat.h index 52aae1b..83e6c07 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/dxgiformat.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/dxgiformat.h @@ -135,6 +135,8 @@ typedef enum DXGI_FORMAT DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE = 189, DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE = 190, + DXGI_FORMAT_A4B4G4R4_UNORM = 191, + DXGI_FORMAT_FORCE_UINT = 0xffffffff } DXGI_FORMAT; diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/pix3.h b/libs/bgfx/3rdparty/directx-headers/include/directx/pix3.h index 311d6c2..b13e8bc 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/pix3.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/pix3.h @@ -1,11 +1,6 @@ -/*==========================================================================; - * - * Copyright (C) Microsoft Corporation. All Rights Reserved. - * - * File: pix3.h - * Content: PIX include file - * - ****************************************************************************/ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + #pragma once #ifndef _PIX3_H_ @@ -14,26 +9,26 @@ #include #ifndef __cplusplus -#error "Only C++ files can include pix.h. C is not supported." +#error "Only C++ files can include pix3.h. C is not supported." #endif -#if defined(XBOX) || defined(_XBOX_ONE) || defined(_DURANGO) -#include "pix3_xbox.h" -#else -#include "pix3_win.h" +#if !defined(USE_PIX_SUPPORTED_ARCHITECTURE) +#if defined(_M_X64) || defined(USE_PIX_ON_ALL_ARCHITECTURES) || defined(_M_ARM64) +#define USE_PIX_SUPPORTED_ARCHITECTURE +#endif #endif -// -// The PIX event/marker APIs compile to nothing on retail builds and on x86 builds -// -#if (!defined(USE_PIX)) && ((defined(_DEBUG) || DBG || (defined(PROFILE) && !defined(FASTCAP)) || defined(PROFILE_BUILD)) && !defined(i386) && defined(_AMD64_) && !defined(_PREFAST_)) +#if !defined(USE_PIX) +#if defined(USE_PIX_SUPPORTED_ARCHITECTURE) && (defined(_DEBUG) || DBG || defined(PROFILE) || defined(PROFILE_BUILD)) && !defined(_PREFAST_) #define USE_PIX #endif +#endif -#if defined(USE_PIX) && !defined(_AMD64_) && !defined(USE_PIX_ON_ALL_ARCHITECTURES) -#pragma message("Warning: Pix markers are only supported on AMD64") +#if defined(USE_PIX) && !defined(USE_PIX_SUPPORTED_ARCHITECTURE) +#pragma message("Warning: Pix markers are only supported on AMD64 and ARM64") #endif + // These flags are used by both PIXBeginCapture and PIXGetCaptureState #define PIX_CAPTURE_TIMING (1 << 0) #define PIX_CAPTURE_GPU (1 << 1) @@ -44,49 +39,122 @@ #define PIX_CAPTURE_SYSTEM_MONITOR_COUNTERS (1 << 6) #define PIX_CAPTURE_VIDEO (1 << 7) #define PIX_CAPTURE_AUDIO (1 << 8) +#define PIX_CAPTURE_GPU_TRACE (1 << 9) +#define PIX_CAPTURE_RESERVED (1 << 15) -typedef union PIXCaptureParameters +union PIXCaptureParameters { + enum PIXCaptureStorage + { + Memory = 0, + MemoryCircular = 1, // Xbox only + FileCircular = 2, // PC only + }; + struct GpuCaptureParameters { - PVOID reserved; + PCWSTR FileName; } GpuCaptureParameters; struct TimingCaptureParameters { + PCWSTR FileName; + UINT32 MaximumToolingMemorySizeMb; + PIXCaptureStorage CaptureStorage; + + BOOL CaptureGpuTiming; + BOOL CaptureCallstacks; - PWSTR FileName; + BOOL CaptureCpuSamples; + UINT32 CpuSamplesPerSecond; + + BOOL CaptureFileIO; + + BOOL CaptureVirtualAllocEvents; + BOOL CaptureHeapAllocEvents; + BOOL CaptureXMemEvents; // Xbox only + BOOL CapturePixMemEvents; + BOOL CapturePageFaultEvents; + BOOL CaptureVideoFrames; // Xbox only } TimingCaptureParameters; -} PIXCaptureParameters, *PPIXCaptureParameters; + struct GpuTraceParameters // Xbox Series and newer only + { + PWSTR FileName; + UINT32 MaximumToolingMemorySizeMb; + BOOL CaptureGpuOccupancy; + } GpuTraceParameters; +}; -#if defined (USE_PIX) && (defined(_AMD64_) || defined(USE_PIX_ON_ALL_ARCHITECTURES)) +typedef PIXCaptureParameters* PPIXCaptureParameters; + +#if defined(XBOX) || defined(_XBOX_ONE) || defined(_DURANGO) || defined(_GAMING_XBOX) || defined(_GAMING_XBOX_SCARLETT) +#include "pix3_xbox.h" +#else +#include "pix3_win.h" +#endif + +#if defined(XBOX) || defined(_XBOX_ONE) || defined(_DURANGO) || defined(_GAMING_XBOX) || defined(_GAMING_XBOX_SCARLETT) +#define PIX_XBOX +#if defined(_GAMING_XBOX) || defined(_GAMING_XBOX_SCARLETT) +#define PIX_GAMING_XBOX +#endif +#endif + +#if !defined(PIX_USE_GPU_MARKERS_V2) +#ifdef PIX_GAMING_XBOX +#define PIX_USE_GPU_MARKERS_V2 +#endif +#endif + +#if defined(USE_PIX_SUPPORTED_ARCHITECTURE) && (defined(USE_PIX) || defined(USE_PIX_RETAIL)) + +#define PIX_EVENTS_ARE_TURNED_ON #include "PIXEventsCommon.h" -#include "PIXEventsGenerated.h" +#include "PIXEvents.h" +#ifdef USE_PIX // Starts a programmatically controlled capture. // captureFlags uses the PIX_CAPTURE_* family of flags to specify the type of capture to take -extern "C" HRESULT WINAPI PIXBeginCapture(DWORD captureFlags, _In_opt_ const PPIXCaptureParameters captureParameters); +extern "C" HRESULT WINAPI PIXBeginCapture2(DWORD captureFlags, _In_opt_ const PPIXCaptureParameters captureParameters); +inline HRESULT PIXBeginCapture(DWORD captureFlags, _In_opt_ const PPIXCaptureParameters captureParameters) { return PIXBeginCapture2(captureFlags, captureParameters); } // Stops a programmatically controlled capture // If discard == TRUE, the captured data is discarded // If discard == FALSE, the captured data is saved +// discard parameter is not supported on Windows extern "C" HRESULT WINAPI PIXEndCapture(BOOL discard); extern "C" DWORD WINAPI PIXGetCaptureState(); extern "C" void WINAPI PIXReportCounter(_In_ PCWSTR name, float value); -#else +#endif // USE_PIX + +#endif // (USE_PIX_SUPPORTED_ARCHITECTURE) && (USE_PIX || USE_PIX_RETAIL) + +#if !defined(USE_PIX_SUPPORTED_ARCHITECTURE) || !defined(USE_PIX) // Eliminate these APIs when not using PIX +inline HRESULT PIXBeginCapture2(DWORD, _In_opt_ const PIXCaptureParameters*) { return S_OK; } inline HRESULT PIXBeginCapture(DWORD, _In_opt_ const PIXCaptureParameters*) { return S_OK; } inline HRESULT PIXEndCapture(BOOL) { return S_OK; } +inline HRESULT PIXGpuCaptureNextFrames(PCWSTR, UINT32) { return S_OK; } +inline HRESULT PIXSetTargetWindow(HWND) { return S_OK; } +inline HRESULT PIXForceD3D11On12() { return S_OK; } +inline HRESULT WINAPI PIXSetHUDOptions(PIXHUDOptions) { return S_OK; } +inline bool WINAPI PIXIsAttachedForGpuCapture() { return false; } +inline HINSTANCE WINAPI PIXOpenCaptureInUI(PCWSTR) { return 0; } +inline HMODULE PIXLoadLatestWinPixGpuCapturerLibrary() { return nullptr; } +inline HMODULE PIXLoadLatestWinPixTimingCapturerLibrary() { return nullptr; } inline DWORD PIXGetCaptureState() { return 0; } inline void PIXReportCounter(_In_ PCWSTR, float) {} +inline void PIXNotifyWakeFromFenceSignal(_In_ HANDLE) {} + +#if !defined(USE_PIX_RETAIL) inline void PIXBeginEvent(UINT64, _In_ PCSTR, ...) {} inline void PIXBeginEvent(UINT64, _In_ PCWSTR, ...) {} @@ -98,19 +166,30 @@ inline void PIXSetMarker(UINT64, _In_ PCSTR, ...) {} inline void PIXSetMarker(UINT64, _In_ PCWSTR, ...) {} inline void PIXSetMarker(void*, UINT64, _In_ PCSTR, ...) {} inline void PIXSetMarker(void*, UINT64, _In_ PCWSTR, ...) {} +inline void PIXBeginRetailEvent(void*, UINT64, _In_ PCSTR, ...) {} +inline void PIXBeginRetailEvent(void*, UINT64, _In_ PCWSTR, ...) {} +inline void PIXEndRetailEvent(void*) {} +inline void PIXSetRetailMarker(void*, UINT64, _In_ PCSTR, ...) {} +inline void PIXSetRetailMarker(void*, UINT64, _In_ PCWSTR, ...) {} inline void PIXScopedEvent(UINT64, _In_ PCSTR, ...) {} inline void PIXScopedEvent(UINT64, _In_ PCWSTR, ...) {} inline void PIXScopedEvent(void*, UINT64, _In_ PCSTR, ...) {} inline void PIXScopedEvent(void*, UINT64, _In_ PCWSTR, ...) {} -#endif // USE_PIX +#endif // !USE_PIX_RETAIL + +// don't show warnings about expressions with no effect +#pragma warning(disable:4548) +#pragma warning(disable:4555) + +#endif // !USE_PIX_SUPPORTED_ARCHITECTURE || !USE_PIX // Use these functions to specify colors to pass as metadata to a PIX event/marker API. // Use PIX_COLOR() to specify a particular color for an event. // Or, use PIX_COLOR_INDEX() to specify a set of unique event categories, and let PIX choose // the colors to represent each category. -inline UINT PIX_COLOR(BYTE r, BYTE g, BYTE b) { return 0xff000000 | (r << 16) | (g << 8) | b; } -inline UINT PIX_COLOR_INDEX(BYTE i) { return i; } -const UINT PIX_COLOR_DEFAULT = PIX_COLOR_INDEX(0); +inline UINT32 PIX_COLOR(UINT8 r, UINT8 g, UINT8 b) { return 0xff000000u | ((UINT32)r << 16) | ((UINT32)g << 8) | (UINT32)b; } +inline UINT8 PIX_COLOR_INDEX(UINT8 i) { return i; } +const UINT8 PIX_COLOR_DEFAULT = PIX_COLOR_INDEX(0); #endif // _PIX3_H_ diff --git a/libs/bgfx/3rdparty/directx-headers/include/directx/pix3_win.h b/libs/bgfx/3rdparty/directx-headers/include/directx/pix3_win.h index 2b3dcd5..6171af0 100644 --- a/libs/bgfx/3rdparty/directx-headers/include/directx/pix3_win.h +++ b/libs/bgfx/3rdparty/directx-headers/include/directx/pix3_win.h @@ -1,12 +1,6 @@ -/*==========================================================================; - * - * Copyright (C) Microsoft Corporation. All Rights Reserved. - * - * File: PIX3_win.h - * Content: PIX include file - * Don't include this file directly - use pix3.h - * - ****************************************************************************/ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +// Don't include this file directly - use pix3.h #pragma once @@ -17,37 +11,499 @@ #ifndef _PIX3_WIN_H_ #define _PIX3_WIN_H_ -struct PIXEventsBlockInfo -{ -}; +// PIXEventsThreadInfo is defined in PIXEventsCommon.h +struct PIXEventsThreadInfo; -struct PIXEventsThreadInfo -{ - PIXEventsBlockInfo* block; - UINT64* biasedLimit; - UINT64* destination; - UINT64* limit; - UINT64 id; -}; +//extern "C" PIXEventsThreadInfo* WINAPI PIXGetThreadInfo() noexcept; +// +//#if defined(USE_PIX) && defined(USE_PIX_SUPPORTED_ARCHITECTURE) +//// Notifies PIX that an event handle was set as a result of a D3D12 fence being signaled. +//// The event specified must have the same handle value as the handle +//// used in ID3D12Fence::SetEventOnCompletion. +//extern "C" void WINAPI PIXNotifyWakeFromFenceSignal(_In_ HANDLE event); +// +//// Notifies PIX that a block of memory was allocated +//extern "C" void WINAPI PIXRecordMemoryAllocationEvent(USHORT allocatorId, void* baseAddress, size_t size, UINT64 metadata); +// +//// Notifies PIX that a block of memory was freed +//extern "C" void WINAPI PIXRecordMemoryFreeEvent(USHORT allocatorId, void* baseAddress, size_t size, UINT64 metadata); +// +//#else +// +//// Eliminate these APIs when not using PIX +//inline void PIXRecordMemoryAllocationEvent(USHORT, void*, size_t, UINT64) {} +//inline void PIXRecordMemoryFreeEvent(USHORT, void*, size_t, UINT64) {} +// +//#endif -// The following defines denote the different metadata values that have been used -// by tools to denote how to parse pix marker event data. The first two values -// are legacy values. +// The following WINPIX_EVENT_* defines denote the different metadata values that have +// been used by tools to denote how to parse pix marker event data. The first two values +// are legacy values used by pix.h in the Windows SDK. #define WINPIX_EVENT_UNICODE_VERSION 0 #define WINPIX_EVENT_ANSI_VERSION 1 + +// These values denote PIX marker event data that was created by the WinPixEventRuntime. +// In early 2023 we revised the PIX marker format and defined a new version number. #define WINPIX_EVENT_PIX3BLOB_VERSION 2 +#define WINPIX_EVENT_PIX3BLOB_V2 6345127 // A number that other applications are unlikely to have used before +// For backcompat reasons, the WinPixEventRuntime uses the older PIX3BLOB format when it passes data +// into the D3D12 runtime. It will be updated to use the V2 format in the future. #define D3D12_EVENT_METADATA WINPIX_EVENT_PIX3BLOB_VERSION __forceinline UINT64 PIXGetTimestampCounter() { LARGE_INTEGER time = {}; QueryPerformanceCounter(&time); - return time.QuadPart; + return static_cast(time.QuadPart); +} + +enum PIXHUDOptions +{ + PIX_HUD_SHOW_ON_ALL_WINDOWS = 0x1, + PIX_HUD_SHOW_ON_TARGET_WINDOW_ONLY = 0x2, + PIX_HUD_SHOW_ON_NO_WINDOWS = 0x4 +}; +DEFINE_ENUM_FLAG_OPERATORS(PIXHUDOptions); + +#if defined(USE_PIX_SUPPORTED_ARCHITECTURE) && defined(USE_PIX) + +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM | WINAPI_PARTITION_GAMES) + +#include +#include +#include +#include + +#define PIXERRORCHECK(value) do { \ + if (FAILED(value)) \ + return nullptr; \ + } while(0) + +namespace PixImpl +{ +#ifndef PIX3_WIN_UNIT_TEST + + __forceinline BOOL GetModuleHandleExW( + DWORD dwFlags, + LPCWSTR lpModuleName, + HMODULE* phModule) + { + return ::GetModuleHandleExW(dwFlags, lpModuleName, phModule); + } + + __forceinline HRESULT SHGetKnownFolderPath( + REFKNOWNFOLDERID rfid, + DWORD dwFlags, + HANDLE hToken, + PWSTR* ppszPath) + { + return ::SHGetKnownFolderPath(rfid, dwFlags, hToken, ppszPath); + } + + __forceinline void CoTaskMemFree(LPVOID pv) + { + return ::CoTaskMemFree(pv); + } + + __forceinline HANDLE FindFirstFileW( + LPCWSTR lpFileName, + LPWIN32_FIND_DATAW lpFindFileData) + { + return ::FindFirstFileW(lpFileName, lpFindFileData); + } + + __forceinline DWORD GetFileAttributesW(LPCWSTR lpFileName) + { + return ::GetFileAttributesW(lpFileName); + } + + __forceinline BOOL FindNextFileW( + HANDLE hFindFile, + LPWIN32_FIND_DATAW lpFindFileData) + { + return ::FindNextFileW(hFindFile, lpFindFileData); + } + + __forceinline BOOL FindClose(HANDLE hFindFile) + { + return ::FindClose(hFindFile); + } + + __forceinline HMODULE LoadLibraryExW(LPCWSTR lpLibFileName, DWORD flags) + { + return ::LoadLibraryExW(lpLibFileName, NULL, flags); + } + +#endif // !PIX3_WIN_UNIT_TESTS + + __forceinline void * GetGpuCaptureFunctionPtr(LPCSTR fnName) noexcept + { + HMODULE module = GetModuleHandleW(L"WinPixGpuCapturer.dll"); + if (module == NULL) + { + return nullptr; + } + + auto fn = (void*)GetProcAddress(module, fnName); + if (fn == nullptr) + { + return nullptr; + } + + return fn; + } + + __forceinline void* GetTimingCaptureFunctionPtr(LPCSTR fnName) noexcept + { + HMODULE module = GetModuleHandleW(L"WinPixTimingCapturer.dll"); + if (module == NULL) + { + return nullptr; + } + + auto fn = (void*)GetProcAddress(module, fnName); + if (fn == nullptr) + { + return nullptr; + } + + return fn; + } + + __forceinline HMODULE PIXLoadLatestCapturerLibrary(wchar_t const* capturerDllName, DWORD flags) + { + HMODULE libHandle{}; + + if (PixImpl::GetModuleHandleExW(0, capturerDllName, &libHandle)) + { + return libHandle; + } + + LPWSTR programFilesPath = nullptr; + if (FAILED(PixImpl::SHGetKnownFolderPath(FOLDERID_ProgramFiles, KF_FLAG_DEFAULT, NULL, &programFilesPath))) + { + PixImpl::CoTaskMemFree(programFilesPath); + return nullptr; + } + + wchar_t pixSearchPath[MAX_PATH]; + + if (FAILED(StringCchCopyW(pixSearchPath, MAX_PATH, programFilesPath))) + { + PixImpl::CoTaskMemFree(programFilesPath); + return nullptr; + } + PixImpl::CoTaskMemFree(programFilesPath); + + PIXERRORCHECK(StringCchCatW(pixSearchPath, MAX_PATH, L"\\Microsoft PIX\\*")); + + WIN32_FIND_DATAW findData; + bool foundPixInstallation = false; + wchar_t newestVersionFound[MAX_PATH]; + wchar_t output[MAX_PATH]; + wchar_t possibleOutput[MAX_PATH]; + + HANDLE hFind = PixImpl::FindFirstFileW(pixSearchPath, &findData); + if (hFind != INVALID_HANDLE_VALUE) + { + do + { + if (((findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY) && + (findData.cFileName[0] != '.')) + { + if (!foundPixInstallation || wcscmp(newestVersionFound, findData.cFileName) <= 0) + { + // length - 1 to get rid of the wildcard character in the search path + PIXERRORCHECK(StringCchCopyNW(possibleOutput, MAX_PATH, pixSearchPath, wcslen(pixSearchPath) - 1)); + PIXERRORCHECK(StringCchCatW(possibleOutput, MAX_PATH, findData.cFileName)); + PIXERRORCHECK(StringCchCatW(possibleOutput, MAX_PATH, L"\\")); + PIXERRORCHECK(StringCchCatW(possibleOutput, MAX_PATH, capturerDllName)); + + DWORD result = PixImpl::GetFileAttributesW(possibleOutput); + + if (result != INVALID_FILE_ATTRIBUTES && !(result & FILE_ATTRIBUTE_DIRECTORY)) + { + foundPixInstallation = true; + PIXERRORCHECK(StringCchCopyW(newestVersionFound, _countof(newestVersionFound), findData.cFileName)); + PIXERRORCHECK(StringCchCopyW(output, _countof(possibleOutput), possibleOutput)); + } + } + } + } while (PixImpl::FindNextFileW(hFind, &findData) != 0); + } + + PixImpl::FindClose(hFind); + + if (!foundPixInstallation) + { + SetLastError(ERROR_FILE_NOT_FOUND); + return nullptr; + } + + return PixImpl::LoadLibraryExW(output, flags); + } +} + +#undef PIXERRORCHECK + +__forceinline HMODULE PIXLoadLatestWinPixGpuCapturerLibrary() +{ + return PixImpl::PIXLoadLatestCapturerLibrary( + L"WinPixGpuCapturer.dll", + LOAD_LIBRARY_SEARCH_DEFAULT_DIRS); +} + +__forceinline HMODULE PIXLoadLatestWinPixTimingCapturerLibrary() +{ + return PixImpl::PIXLoadLatestCapturerLibrary( + L"WinPixTimingCapturer.dll", + LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR); +} + +__forceinline HRESULT WINAPI PIXSetTargetWindow(HWND hwnd) +{ + typedef void(WINAPI* SetGlobalTargetWindowFn)(HWND); + + auto fn = (SetGlobalTargetWindowFn)PixImpl::GetGpuCaptureFunctionPtr("SetGlobalTargetWindow"); + if (fn == nullptr) + { + return HRESULT_FROM_WIN32(GetLastError()); + } + + fn(hwnd); + return S_OK; +} + +__forceinline HRESULT WINAPI PIXGpuCaptureNextFrames(PCWSTR fileName, UINT32 numFrames) +{ + typedef HRESULT(WINAPI* CaptureNextFrameFn)(PCWSTR, UINT32); + + auto fn = (CaptureNextFrameFn)PixImpl::GetGpuCaptureFunctionPtr("CaptureNextFrame"); + if (fn == nullptr) + { + return HRESULT_FROM_WIN32(GetLastError()); + } + + return fn(fileName, numFrames); +} + +extern "C" __forceinline HRESULT WINAPI PIXBeginCapture2(DWORD captureFlags, _In_opt_ const PPIXCaptureParameters captureParameters) +{ + if (captureFlags == PIX_CAPTURE_GPU) + { + typedef HRESULT(WINAPI* BeginProgrammaticGpuCaptureFn)(const PPIXCaptureParameters); + + auto fn = (BeginProgrammaticGpuCaptureFn)PixImpl::GetGpuCaptureFunctionPtr("BeginProgrammaticGpuCapture"); + if (fn == nullptr) + { + return HRESULT_FROM_WIN32(GetLastError()); + } + + return fn(captureParameters); + } + else if (captureFlags == PIX_CAPTURE_TIMING) + { + typedef HRESULT(WINAPI* BeginProgrammaticTimingCaptureFn)(void const*, UINT64); + + auto fn = (BeginProgrammaticTimingCaptureFn)PixImpl::GetTimingCaptureFunctionPtr("BeginProgrammaticTimingCapture"); + if (fn == nullptr) + { + return HRESULT_FROM_WIN32(GetLastError()); + } + + return fn(&captureParameters->TimingCaptureParameters, sizeof(captureParameters->TimingCaptureParameters)); + } + else + { + return E_NOTIMPL; + } +} + +extern "C" __forceinline HRESULT WINAPI PIXEndCapture(BOOL discard) +{ + // We can't tell if the user wants to end a GPU Capture or a Timing Capture. + // The user shouldn't have both WinPixGpuCapturer and WinPixTimingCapturer loaded in the process though, + // so we can just look for one of them and call it. + typedef HRESULT(WINAPI* EndProgrammaticGpuCaptureFn)(void); + auto gpuFn = (EndProgrammaticGpuCaptureFn)PixImpl::GetGpuCaptureFunctionPtr("EndProgrammaticGpuCapture"); + if (gpuFn != NULL) + { + return gpuFn(); + } + + typedef HRESULT(WINAPI* EndProgrammaticTimingCaptureFn)(BOOL); + auto timingFn = (EndProgrammaticTimingCaptureFn)PixImpl::GetTimingCaptureFunctionPtr("EndProgrammaticTimingCapture"); + if (timingFn != NULL) + { + return timingFn(discard); + } + + return HRESULT_FROM_WIN32(GetLastError()); +} + +__forceinline HRESULT WINAPI PIXForceD3D11On12() +{ + typedef HRESULT (WINAPI* ForceD3D11On12Fn)(void); + + auto fn = (ForceD3D11On12Fn)PixImpl::GetGpuCaptureFunctionPtr("ForceD3D11On12"); + if (fn == NULL) + { + return HRESULT_FROM_WIN32(GetLastError()); + } + + return fn(); +} + +__forceinline HRESULT WINAPI PIXSetHUDOptions(PIXHUDOptions hudOptions) +{ + typedef HRESULT(WINAPI* SetHUDOptionsFn)(PIXHUDOptions); + + auto fn = (SetHUDOptionsFn)PixImpl::GetGpuCaptureFunctionPtr("SetHUDOptions"); + if (fn == NULL) + { + return HRESULT_FROM_WIN32(GetLastError()); + } + + return fn(hudOptions); +} + +__forceinline bool WINAPI PIXIsAttachedForGpuCapture() +{ + typedef bool(WINAPI* GetIsAttachedToPixFn)(void); + auto fn = (GetIsAttachedToPixFn)PixImpl::GetGpuCaptureFunctionPtr("GetIsAttachedToPix"); + if (fn == NULL) + { + OutputDebugStringW(L"WinPixEventRuntime error: Mismatched header/dll. Please ensure that pix3.h and WinPixGpuCapturer.dll match"); + return false; + } + + return fn(); +} + +__forceinline HINSTANCE WINAPI PIXOpenCaptureInUI(PCWSTR fileName) +{ + return ShellExecuteW(0, 0, fileName, 0, 0, SW_SHOW); +} + +#else +__forceinline HMODULE PIXLoadLatestWinPixGpuCapturerLibrary() +{ + return nullptr; +} +__forceinline HMODULE PIXLoadLatestWinPixTimingCapturerLibrary() +{ + return nullptr; } +__forceinline HRESULT WINAPI PIXSetTargetWindow(HWND) +{ + return E_NOTIMPL; +} + +__forceinline HRESULT WINAPI PIXGpuCaptureNextFrames(PCWSTR, UINT32) +{ + return E_NOTIMPL; +} +extern "C" __forceinline HRESULT WINAPI PIXBeginCapture2(DWORD, _In_opt_ const PPIXCaptureParameters) +{ + return E_NOTIMPL; +} +extern "C" __forceinline HRESULT WINAPI PIXEndCapture(BOOL) +{ + return E_NOTIMPL; +} +__forceinline HRESULT WINAPI PIXForceD3D11On12() +{ + return E_NOTIMPL; +} +__forceinline HRESULT WINAPI PIXSetHUDOptions(PIXHUDOptions) +{ + return E_NOTIMPL; +} +__forceinline bool WINAPI PIXIsAttachedForGpuCapture() +{ + return false; +} +__forceinline HINSTANCE WINAPI PIXOpenCaptureInUI(PCWSTR) +{ + return 0; +} +#endif // WINAPI_PARTITION + +#endif // USE_PIX_SUPPORTED_ARCHITECTURE || USE_PIX + +#if defined(__d3d12_h__) -#define PIXSetCPUMarkerOnContext(context, metadata, ...) MakeCPUSetMarkerForContext(metadata, context, __VA_ARGS__) -#define PIXBeginCPUEventOnContext(context, metadata, ...) MakeCPUBeginEventForContext(metadata, context, __VA_ARGS__) -#define PIXEndCPUEventOnContext(context) MakeCPUEndEventForContext(context) +inline void PIXInsertTimingMarkerOnContextForBeginEvent(_In_ ID3D12GraphicsCommandList* commandList, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size) +{ + UNREFERENCED_PARAMETER(eventType); + commandList->BeginEvent(WINPIX_EVENT_PIX3BLOB_V2, data, size); +} + +inline void PIXInsertTimingMarkerOnContextForBeginEvent(_In_ ID3D12CommandQueue* commandQueue, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size) +{ + UNREFERENCED_PARAMETER(eventType); + commandQueue->BeginEvent(WINPIX_EVENT_PIX3BLOB_V2, data, size); +} + +inline void PIXInsertTimingMarkerOnContextForSetMarker(_In_ ID3D12GraphicsCommandList* commandList, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size) +{ + UNREFERENCED_PARAMETER(eventType); + commandList->SetMarker(WINPIX_EVENT_PIX3BLOB_V2, data, size); +} + +inline void PIXInsertTimingMarkerOnContextForSetMarker(_In_ ID3D12CommandQueue* commandQueue, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size) +{ + UNREFERENCED_PARAMETER(eventType); + commandQueue->SetMarker(WINPIX_EVENT_PIX3BLOB_V2, data, size); +} + +inline void PIXInsertTimingMarkerOnContextForEndEvent(_In_ ID3D12GraphicsCommandList* commandList, UINT8 eventType) +{ + UNREFERENCED_PARAMETER(eventType); + commandList->EndEvent(); +} + +inline void PIXInsertTimingMarkerOnContextForEndEvent(_In_ ID3D12CommandQueue* commandQueue, UINT8 eventType) +{ + UNREFERENCED_PARAMETER(eventType); + commandQueue->EndEvent(); +} + +inline void PIXInsertGPUMarkerOnContextForBeginEvent(_In_ ID3D12GraphicsCommandList* commandList, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size) +{ + UNREFERENCED_PARAMETER(eventType); + commandList->BeginEvent(WINPIX_EVENT_PIX3BLOB_V2, data, size); +} + +inline void PIXInsertGPUMarkerOnContextForBeginEvent(_In_ ID3D12CommandQueue* commandQueue, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size) +{ + UNREFERENCED_PARAMETER(eventType); + commandQueue->BeginEvent(WINPIX_EVENT_PIX3BLOB_V2, data, size); +} + +inline void PIXInsertGPUMarkerOnContextForSetMarker(_In_ ID3D12GraphicsCommandList* commandList, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size) +{ + UNREFERENCED_PARAMETER(eventType); + commandList->SetMarker(WINPIX_EVENT_PIX3BLOB_V2, data, size); +} + +inline void PIXInsertGPUMarkerOnContextForSetMarker(_In_ ID3D12CommandQueue* commandQueue, UINT8 eventType, _In_reads_bytes_(size) void* data, UINT size) +{ + UNREFERENCED_PARAMETER(eventType); + commandQueue->SetMarker(WINPIX_EVENT_PIX3BLOB_V2, data, size); +} + +inline void PIXInsertGPUMarkerOnContextForEndEvent(_In_ ID3D12GraphicsCommandList* commandList, UINT8, void*, UINT) +{ + commandList->EndEvent(); +} + +inline void PIXInsertGPUMarkerOnContextForEndEvent(_In_ ID3D12CommandQueue* commandQueue, UINT8, void*, UINT) +{ + commandQueue->EndEvent(); +} + +#endif #endif //_PIX3_WIN_H_ diff --git a/libs/bgfx/3rdparty/glsl-optimizer/src/glsl/ir_print_glsl_visitor.cpp b/libs/bgfx/3rdparty/glsl-optimizer/src/glsl/ir_print_glsl_visitor.cpp index 22d8af4..0a7bdb7 100644 --- a/libs/bgfx/3rdparty/glsl-optimizer/src/glsl/ir_print_glsl_visitor.cpp +++ b/libs/bgfx/3rdparty/glsl-optimizer/src/glsl/ir_print_glsl_visitor.cpp @@ -954,7 +954,7 @@ void ir_print_glsl_visitor::visit(ir_texture *ir) ir->coordinate->accept(this); // lod - if (ir->op == ir_txl || ir->op == ir_txf || ir->op == ir_txf_ms) + if (ir->op == ir_txl || ir->op == ir_txf) { buffer.asprintf_append (", "); ir->lod_info.lod->accept(this); diff --git a/libs/bgfx/3rdparty/glslang/LICENSE.txt b/libs/bgfx/3rdparty/glslang/LICENSE.txt index 054e68a..1ea89c0 100644 --- a/libs/bgfx/3rdparty/glslang/LICENSE.txt +++ b/libs/bgfx/3rdparty/glslang/LICENSE.txt @@ -13,9 +13,6 @@ Other parts, outside of glslang proper, include: - update_glslang_sources.py, which is not part of the project proper and does not need to be used. -- the SPIR-V "remapper", which is optional, but has the same license as - glslang proper - - Google tests and SPIR-V tools, and anything in the external subdirectory are external and optional; see them for their respective licenses. diff --git a/libs/bgfx/3rdparty/glslang/SPIRV/GLSL.ext.ARM.h b/libs/bgfx/3rdparty/glslang/SPIRV/GLSL.ext.ARM.h index 14425be..eef5b03 100644 --- a/libs/bgfx/3rdparty/glslang/SPIRV/GLSL.ext.ARM.h +++ b/libs/bgfx/3rdparty/glslang/SPIRV/GLSL.ext.ARM.h @@ -1,5 +1,5 @@ /* -** Copyright (c) 2022 ARM Limited +** Copyright (c) 2022, 2025 ARM Limited ** ** Permission is hereby granted, free of charge, to any person obtaining a copy ** of this software and/or associated documentation files (the "Materials"), @@ -28,8 +28,10 @@ #define GLSLextARM_H static const int GLSLextARMVersion = 100; -static const int GLSLextARMRevision = 1; +static const int GLSLextARMRevision = 2; -static const char * const E_SPV_ARM_core_builtins = "SPV_ARM_core_builtins"; +static const char* const E_SPV_ARM_core_builtins = "SPV_ARM_core_builtins"; +static const char* const E_SPV_ARM_cooperative_matrix_layouts = "SPV_ARM_cooperative_matrix_layouts"; +static const char* const E_SPV_ARM_tensors = "SPV_ARM_tensors"; #endif // #ifndef GLSLextARM_H diff --git a/libs/bgfx/3rdparty/glslang/SPIRV/GLSL.ext.EXT.h b/libs/bgfx/3rdparty/glslang/SPIRV/GLSL.ext.EXT.h index 07f3c30..748d9c8 100644 --- a/libs/bgfx/3rdparty/glslang/SPIRV/GLSL.ext.EXT.h +++ b/libs/bgfx/3rdparty/glslang/SPIRV/GLSL.ext.EXT.h @@ -41,6 +41,6 @@ static const char* const E_SPV_EXT_shader_atomic_float_min_max = "SPV_EXT_shader static const char* const E_SPV_EXT_shader_image_int64 = "SPV_EXT_shader_image_int64"; static const char* const E_SPV_EXT_shader_tile_image = "SPV_EXT_shader_tile_image"; static const char* const E_SPV_EXT_mesh_shader = "SPV_EXT_mesh_shader"; -static const char* const E_SPV_ARM_cooperative_matrix_layouts = "SPV_ARM_cooperative_matrix_layouts"; +static const char* const E_SPV_EXT_float8 = "SPV_EXT_float8"; #endif // #ifndef GLSLextEXT_H diff --git a/libs/bgfx/3rdparty/glslang/SPIRV/GLSL.ext.QCOM.h b/libs/bgfx/3rdparty/glslang/SPIRV/GLSL.ext.QCOM.h index a671d79..7633d40 100644 --- a/libs/bgfx/3rdparty/glslang/SPIRV/GLSL.ext.QCOM.h +++ b/libs/bgfx/3rdparty/glslang/SPIRV/GLSL.ext.QCOM.h @@ -39,6 +39,8 @@ static const int GLSLextQCOMRevision = 1; const char* const E_SPV_QCOM_image_processing = "SPV_QCOM_image_processing"; //SPV_QCOM_image_processing2 const char* const E_SPV_QCOM_image_processing2 = "SPV_QCOM_image_processing2"; +//SPV_QCOM_cooperative_matrix_conversion +const char* const E_SPV_QCOM_cooperative_matrix_conversion = "SPV_QCOM_cooperative_matrix_conversion"; //SPV_QCOM_tile_shading const char* const E_SPV_QCOM_tile_shading = "SPV_QCOM_tile_shading"; diff --git a/libs/bgfx/3rdparty/glslang/SPIRV/GlslangToSpv.cpp b/libs/bgfx/3rdparty/glslang/SPIRV/GlslangToSpv.cpp index 9088f77..eec6859 100644 --- a/libs/bgfx/3rdparty/glslang/SPIRV/GlslangToSpv.cpp +++ b/libs/bgfx/3rdparty/glslang/SPIRV/GlslangToSpv.cpp @@ -1505,6 +1505,10 @@ bool IsDescriptorResource(const glslang::TType& type) type.getBasicType() == glslang::EbtAccStruct) return type.getQualifier().isUniformOrBuffer(); + // Tensors are tied to a descriptor. + if (type.isTensorARM()) + return true; + // None of the above. return false; } @@ -2399,6 +2403,16 @@ bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::T node->getRight()->traverse(this); spv::Id index = accessChainLoad(node->getRight()->getType()); + // Zero-extend smaller unsigned integer types for array indexing. + // SPIR-V OpAccessChain treats indices as signed, so we need to zero-extend + // unsigned types to preserve their values (signed types are fine as-is). + spv::Id indexType = builder.getTypeId(index); + if (builder.isUintType(indexType) && builder.getScalarTypeWidth(indexType) < 32) { + // Zero-extend unsigned types to preserve their values + spv::Id uintType = builder.makeUintType(32); + index = builder.createUnaryOp(spv::Op::OpUConvert, uintType, index); + } + addIndirectionIndexCapabilities(node->getLeft()->getType(), node->getRight()->getType()); // restore the saved access chain @@ -2855,6 +2869,10 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI one = builder.makeFloat16Constant(1.0F); else if (node->getBasicType() == glslang::EbtBFloat16) one = builder.makeBFloat16Constant(1.0F); + else if (node->getBasicType() == glslang::EbtFloatE5M2) + one = builder.makeFloatE5M2Constant(1.0F); + else if (node->getBasicType() == glslang::EbtFloatE4M3) + one = builder.makeFloatE4M3Constant(1.0F); else if (node->getBasicType() == glslang::EbtInt8 || node->getBasicType() == glslang::EbtUint8) one = builder.makeInt8Constant(1); else if (node->getBasicType() == glslang::EbtInt16 || node->getBasicType() == glslang::EbtUint16) @@ -3198,6 +3216,14 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt case glslang::EOpConstructBF16Vec2: case glslang::EOpConstructBF16Vec3: case glslang::EOpConstructBF16Vec4: + case glslang::EOpConstructFloatE5M2: + case glslang::EOpConstructFloatE5M2Vec2: + case glslang::EOpConstructFloatE5M2Vec3: + case glslang::EOpConstructFloatE5M2Vec4: + case glslang::EOpConstructFloatE4M3: + case glslang::EOpConstructFloatE4M3Vec2: + case glslang::EOpConstructFloatE4M3Vec3: + case glslang::EOpConstructFloatE4M3Vec4: case glslang::EOpConstructBool: case glslang::EOpConstructBVec2: case glslang::EOpConstructBVec3: @@ -3240,6 +3266,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt case glslang::EOpConstructCooperativeMatrixNV: case glslang::EOpConstructCooperativeMatrixKHR: case glslang::EOpConstructCooperativeVectorNV: + case glslang::EOpConstructSaturated: { builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename()); std::vector arguments; @@ -3277,6 +3304,16 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt constructed = createCompositeConstruct(resultType(), constituents); } else if (isMatrix) constructed = builder.createMatrixConstructor(precision, arguments, resultType()); + else if (node->getOp() == glslang::EOpConstructSaturated) { + OpDecorations decorations = { TranslatePrecisionDecoration(node->getOperationPrecision()), + TranslateNoContractionDecoration(node->getType().getQualifier()), + TranslateNonUniformDecoration(lvalueCoherentFlags) }; + + constructed = createConversion(node->getOp(), decorations, resultType(), arguments[1], + node->getType().getBasicType(), node->getSequence()[1]->getAsTyped()->getBasicType()); + builder.addDecoration(constructed, spv::Decoration::SaturatedToLargestFloat8NormalConversionEXT); + builder.createStore(constructed, arguments[0]); + } else constructed = builder.createConstructor(precision, arguments, resultType()); @@ -3557,6 +3594,9 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt builder.addCapability(spv::Capability::TextureBlockMatchQCOM); builder.addExtension(spv::E_SPV_QCOM_image_processing); break; + case glslang::EOpTensorWriteARM: + noReturnValue = true; + break; case glslang::EOpImageBlockMatchWindowSSDQCOM: case glslang::EOpImageBlockMatchWindowSADQCOM: @@ -3807,6 +3847,10 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt if (arg == 0 || arg == 2) lvalue = true; break; + case glslang::EOpTensorReadARM: + if (arg == 2) + lvalue = true; + break; default: break; } @@ -4218,6 +4262,24 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt // store the result to the pointer builder.createStore(result, operands[0]); result = 0; + } else if (node->getOp() == glslang::EOpBitCastArrayQCOM) { + builder.addCapability(spv::Capability::CooperativeMatrixConversionQCOM); + builder.addExtension(spv::E_SPV_QCOM_cooperative_matrix_conversion); + result = builder.createUnaryOp(spv::Op::OpBitCastArrayQCOM, resultType(), operands[0]); + } else if (node->getOp() == glslang::EOpCompositeConstructCoopMatQCOM) { + builder.addCapability(spv::Capability::CooperativeMatrixConversionQCOM); + builder.addExtension(spv::E_SPV_QCOM_cooperative_matrix_conversion); + result = builder.createUnaryOp(spv::Op::OpCompositeConstructCoopMatQCOM, resultType(), operands[0]); + } else if (node->getOp() == glslang::EOpCompositeExtractCoopMatQCOM) { + builder.addCapability(spv::Capability::CooperativeMatrixConversionQCOM); + builder.addExtension(spv::E_SPV_QCOM_cooperative_matrix_conversion); + result = builder.createUnaryOp(spv::Op::OpCompositeExtractCoopMatQCOM, resultType(), operands[0]); + } else if (node->getOp() == glslang::EOpExtractSubArrayQCOM) { + builder.addCapability(spv::Capability::CooperativeMatrixConversionQCOM); + builder.addExtension(spv::E_SPV_QCOM_cooperative_matrix_conversion); + + std::vector arguments { operands[0], operands[1] };; + result = builder.createOp(spv::Op::OpExtractSubArrayQCOM, resultType(), arguments); } else if (node->getOp() == glslang::EOpCooperativeVectorMatMulNV || node->getOp() == glslang::EOpCooperativeVectorMatMulAddNV) { auto matrixOperands = spv::CooperativeMatrixOperandsMask::MaskNone; @@ -4308,6 +4370,66 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt idImmOps.push_back(spv::IdImmediate(true, operands[0])); // A builder.createNoResultOp(spv::Op::OpCooperativeVectorReduceSumAccumulateNV, idImmOps); result = 0; + } else if (node->getOp() == glslang::EOpTensorReadARM || + node->getOp() == glslang::EOpTensorWriteARM) { + const bool isWrite = node->getOp() == glslang::EOpTensorWriteARM; + const unsigned int tensorMinOperandCount = 3; + assert(operands.size() >= tensorMinOperandCount); + std::vector idImmOps; + + idImmOps.push_back(spv::IdImmediate(true, operands[0])); // tensor + idImmOps.push_back(spv::IdImmediate(true, operands[1])); // coords + if (isWrite) { + idImmOps.push_back(spv::IdImmediate(true, operands[2])); // value + } + + // Analyze the tensor operands + spv::IdImmediate tensorOperands = { false, uint32_t(spv::TensorOperandsMask::MaskNone) }; + bool pushExtraArg = false; + if (operands.size() > tensorMinOperandCount) { + auto enumVal = builder.getConstantScalar(operands[tensorMinOperandCount]); + + if (enumVal & uint32_t(spv::TensorOperandsMask::NontemporalARM)) { + tensorOperands.word |= uint32_t(spv::TensorOperandsMask::NontemporalARM); + } + if (enumVal & uint32_t(spv::TensorOperandsMask::OutOfBoundsValueARM)) { + tensorOperands.word |= uint32_t(spv::TensorOperandsMask::OutOfBoundsValueARM); + assert(operands.size() >= tensorMinOperandCount + 2 && + "TensorOperandsOutOfBoundsValueMask requires an additional value"); + pushExtraArg = true; + } + } + + // Append optional tensor operands if the mask was non-zero. + if (tensorOperands.word) { + idImmOps.push_back(tensorOperands); + if (pushExtraArg) + idImmOps.push_back(spv::IdImmediate(true, operands[tensorMinOperandCount + 1])); + } + + if (isWrite) { + builder.createNoResultOp(spv::Op::OpTensorWriteARM, idImmOps); + result = 0; + } else { + // Use the result argument type as the OpTensorReadARM result type. + const glslang::TType &resArgType = glslangOperands[2]->getAsTyped()->getType(); + spv::Id retType = convertGlslangToSpvType(resArgType); + result = builder.createOp(spv::Op::OpTensorReadARM, retType, idImmOps); + // Store the result to the result argument. + builder.createStore(result, operands[2]); + } + } else if (node->getOp() == glslang::EOpTensorSizeARM) { + // Expected operands are (tensor, dimension) + assert(operands.size() == 2); + + spv::Id tensorOp = operands[0]; + spv::Id dimOp = operands[1]; + assert(builder.isTensorTypeARM(builder.getTypeId(tensorOp)) && "operand #0 must be a tensor"); + + std::vector idImmOps; + idImmOps.push_back(spv::IdImmediate(true, tensorOp)); + idImmOps.push_back(spv::IdImmediate(true, dimOp)); + result = builder.createOp(spv::Op::OpTensorQuerySizeARM, resultType(), idImmOps); } else if (atomic) { // Handle all atomics glslang::TBasicType typeProxy = (node->getOp() == glslang::EOpAtomicStore) @@ -5007,6 +5129,12 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty case glslang::EbtBFloat16: spvType = builder.makeBFloat16Type(); break; + case glslang::EbtFloatE5M2: + spvType = builder.makeFloatE5M2Type(); + break; + case glslang::EbtFloatE4M3: + spvType = builder.makeFloatE4M3Type(); + break; case glslang::EbtInt8: spvType = builder.makeIntType(8); break; @@ -5257,6 +5385,11 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty builder.addCapability(spv::Capability::BFloat16CooperativeMatrixKHR); } + if (type.getBasicType() == glslang::EbtFloatE5M2 || type.getBasicType() == glslang::EbtFloatE4M3) { + builder.addExtension(spv::E_SPV_EXT_float8); + builder.addCapability(spv::Capability::Float8CooperativeMatrixEXT); + } + if (type.getBasicType() == glslang::EbtFloat16) builder.addCapability(spv::Capability::Float16); if (type.getBasicType() == glslang::EbtUint8 || type.getBasicType() == glslang::EbtInt8) { @@ -5266,10 +5399,29 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty spv::Id scope = makeArraySizeId(*type.getTypeParameters()->arraySizes, 0); spv::Id rows = makeArraySizeId(*type.getTypeParameters()->arraySizes, 1); spv::Id cols = makeArraySizeId(*type.getTypeParameters()->arraySizes, 2); - spv::Id use = builder.makeUintConstant(type.getCoopMatKHRuse()); + spv::Id use = makeArraySizeId(*type.getTypeParameters()->arraySizes, 3, true); spvType = builder.makeCooperativeMatrixTypeKHR(spvType, scope, rows, cols, use); } + else if (type.isTensorARM()) { + builder.addCapability(spv::Capability::TensorsARM); + builder.addExtension(spv::E_SPV_ARM_tensors); + if (type.getBasicType() == glslang::EbtInt8 || type.getBasicType() == glslang::EbtUint8) { + builder.addCapability(spv::Capability::Int8); + } else if (type.getBasicType() == glslang::EbtInt16 || + type.getBasicType() == glslang::EbtUint16) { + builder.addCapability(spv::Capability::Int16); + } else if (type.getBasicType() == glslang::EbtInt64 || + type.getBasicType() == glslang::EbtUint64) { + builder.addCapability(spv::Capability::Int64); + } else if (type.getBasicType() == glslang::EbtFloat16) { + builder.addCapability(spv::Capability::Float16); + } + + spv::Id rank = makeArraySizeId(*type.getTypeParameters()->arraySizes, 0); + + spvType = builder.makeTensorTypeARM(spvType, rank); + } if (type.isCoopVecNV()) { builder.addCapability(spv::Capability::CooperativeVectorNV); @@ -5444,6 +5596,7 @@ spv::Id TGlslangToSpvTraverser::convertGlslangStructToSpvType(const glslang::TTy int memberDelta = 0; // how much the member's index changes from glslang to SPIR-V, normally 0, // except sometimes for blocks std::vector > deferredForwardPointers; + std::vector memberDebugInfo; for (int i = 0; i < (int)glslangMembers->size(); i++) { auto& glslangMember = (*glslangMembers)[i]; if (glslangMember.type->hiddenMember()) { @@ -5494,15 +5647,39 @@ spv::Id TGlslangToSpvTraverser::convertGlslangStructToSpvType(const glslang::TTy // + Not as clean as desired. Traverser queries/sets persistent state. This is fragile. // + Table lookup during creation of composite debug types. This really shouldn't be necessary. if(options.emitNonSemanticShaderDebugInfo) { - builder.debugTypeLocs[spvMember].name = glslangMember.type->getFieldName().c_str(); - builder.debugTypeLocs[spvMember].line = glslangMember.loc.line; - builder.debugTypeLocs[spvMember].column = glslangMember.loc.column; + spv::StructMemberDebugInfo debugInfo{}; + debugInfo.name = glslangMember.type->getFieldName(); + debugInfo.line = glslangMember.loc.line; + debugInfo.column = glslangMember.loc.column; + + // Per the GLSL spec, bool variables inside of a uniform or buffer block are generated as uint. + // But for debug info, we want to represent them as bool because that is the original type in + // the source code. The bool type can be nested within a vector or a multidimensional array, + // so we must construct the chain of types up from the scalar bool. + if (glslangIntermediate->getSource() == glslang::EShSourceGlsl && explicitLayout != glslang::ElpNone && + glslangMember.type->getBasicType() == glslang::EbtBool) { + auto typeId = builder.makeBoolType(); + if (glslangMember.type->isVector()) { + typeId = builder.makeVectorType(typeId, glslangMember.type->getVectorSize()); + } + if (glslangMember.type->isArray()) { + const auto* arraySizes = glslangMember.type->getArraySizes(); + int dims = arraySizes->getNumDims(); + for (int i = dims - 1; i >= 0; --i) { + spv::Id size = builder.makeIntConstant(arraySizes->getDimSize(i)); + typeId = builder.makeArrayType(typeId, size, 0); + } + } + debugInfo.debugTypeOverride = builder.getDebugType(typeId); + } + + memberDebugInfo.push_back(debugInfo); } } } // Make the SPIR-V type - spv::Id spvType = builder.makeStructType(spvMembers, type.getTypeName().c_str(), false); + spv::Id spvType = builder.makeStructType(spvMembers, memberDebugInfo, type.getTypeName().c_str(), false); if (! HasNonLayoutQualifiers(type, qualifier)) structMap[explicitLayout][qualifier.layoutMatrix][glslangMembers] = spvType; @@ -6371,6 +6548,10 @@ void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate& if (i == 2) lvalue = true; break; + case glslang::EOpConstructSaturated: + if (i == 0) + lvalue = true; + break; default: break; } @@ -6917,7 +7098,7 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO for (int i = 0; i < 5; i++) { members.push_back(builder.getContainedTypeId(resultStructType, i)); } - spv::Id resType = builder.makeStructType(members, "ResType"); + spv::Id resType = builder.makeStructType(members, {}, "ResType"); //call ImageFootprintNV spv::Id res = builder.createTextureCall(precision, resType, sparse, cracked.fetch, cracked.proj, @@ -8124,7 +8305,7 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, OpDecora int vectorSize = builder.isVectorType(destType) ? builder.getNumTypeComponents(destType) : 0; - if (IsOpNumericConv(op)) { + if (IsOpNumericConv(op) || op == glslang::EOpConstructSaturated) { if (isTypeSignedInt(operandBasicType) && isTypeFloat(resultBasicType)) { convOp = spv::Op::OpConvertSToF; } @@ -10583,6 +10764,12 @@ spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glsla case glslang::EbtBFloat16: spvConsts.push_back(builder.makeBFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst())); break; + case glslang::EbtFloatE5M2: + spvConsts.push_back(builder.makeFloatE5M2Constant(zero ? 0.0F : (float)consts[nextConst].getDConst())); + break; + case glslang::EbtFloatE4M3: + spvConsts.push_back(builder.makeFloatE4M3Constant(zero ? 0.0F : (float)consts[nextConst].getDConst())); + break; default: assert(0); break; @@ -10638,6 +10825,12 @@ spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glsla case glslang::EbtBFloat16: scalar = builder.makeBFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant); break; + case glslang::EbtFloatE5M2: + scalar = builder.makeFloatE5M2Constant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant); + break; + case glslang::EbtFloatE4M3: + scalar = builder.makeFloatE4M3Constant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant); + break; case glslang::EbtReference: scalar = builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const(), specConstant); scalar = builder.createUnaryOp(spv::Op::OpBitcast, typeId, scalar); diff --git a/libs/bgfx/3rdparty/glslang/SPIRV/SpvBuilder.cpp b/libs/bgfx/3rdparty/glslang/SPIRV/SpvBuilder.cpp index 0f953ac..0d77fe6 100644 --- a/libs/bgfx/3rdparty/glslang/SPIRV/SpvBuilder.cpp +++ b/libs/bgfx/3rdparty/glslang/SPIRV/SpvBuilder.cpp @@ -138,7 +138,7 @@ Id Builder::makeSamplerType() if (emitNonSemanticShaderDebugInfo) { - auto const debugResultId = makeCompositeDebugType({}, "type.sampler", NonSemanticShaderDebugInfo100Structure, true); + auto const debugResultId = makeOpaqueDebugType("type.sampler"); debugId[type->getResultId()] = debugResultId; } @@ -341,11 +341,87 @@ Id Builder::makeBFloat16Type() return type->getResultId(); } +Id Builder::makeFloatE5M2Type() +{ + // try to find it + Instruction* type; + for (int t = 0; t < (int)groupedTypes[enumCast(Op::OpTypeFloat)].size(); ++t) { + type = groupedTypes[enumCast(Op::OpTypeFloat)][t]; + if (type->getNumOperands() != 2) { + continue; + } + if (type->getImmediateOperand(0) == (unsigned)8 && + type->getImmediateOperand(1) == FPEncoding::Float8E5M2EXT) + return type->getResultId(); + } + + // not found, make it + type = new Instruction(getUniqueId(), NoType, Op::OpTypeFloat); + type->addImmediateOperand(8); + type->addImmediateOperand(FPEncoding::Float8E5M2EXT); + groupedTypes[enumCast(Op::OpTypeFloat)].push_back(type); + constantsTypesGlobals.push_back(std::unique_ptr(type)); + module.mapInstruction(type); + + addExtension(spv::E_SPV_EXT_float8); + addCapability(Capability::Float8EXT); + +#if 0 + // XXX not supported + if (emitNonSemanticShaderDebugInfo) + { + auto const debugResultId = makeFloatDebugType(width); + debugId[type->getResultId()] = debugResultId; + } +#endif + + return type->getResultId(); +} + +Id Builder::makeFloatE4M3Type() +{ + // try to find it + Instruction* type; + for (int t = 0; t < (int)groupedTypes[enumCast(Op::OpTypeFloat)].size(); ++t) { + type = groupedTypes[enumCast(Op::OpTypeFloat)][t]; + if (type->getNumOperands() != 2) { + continue; + } + if (type->getImmediateOperand(0) == (unsigned)8 && + type->getImmediateOperand(1) == FPEncoding::Float8E4M3EXT) + return type->getResultId(); + } + + // not found, make it + type = new Instruction(getUniqueId(), NoType, Op::OpTypeFloat); + type->addImmediateOperand(8); + type->addImmediateOperand(FPEncoding::Float8E4M3EXT); + groupedTypes[enumCast(Op::OpTypeFloat)].push_back(type); + constantsTypesGlobals.push_back(std::unique_ptr(type)); + module.mapInstruction(type); + + addExtension(spv::E_SPV_EXT_float8); + addCapability(Capability::Float8EXT); + +#if 0 + // XXX not supported + if (emitNonSemanticShaderDebugInfo) + { + auto const debugResultId = makeFloatDebugType(width); + debugId[type->getResultId()] = debugResultId; + } +#endif + + return type->getResultId(); +} + // Make a struct without checking for duplication. // See makeStructResultType() for non-decorated structs // needed as the result of some instructions, which does // check for duplicates. -Id Builder::makeStructType(const std::vector& members, const char* name, bool const compilerGenerated) +// For compiler-generated structs, debug info is ignored. +Id Builder::makeStructType(const std::vector& members, const std::vector& memberDebugInfo, + const char* name, bool const compilerGenerated) { // Don't look for previous one, because in the general case, // structs can be duplicated except for decorations. @@ -359,9 +435,10 @@ Id Builder::makeStructType(const std::vector& members, const char* name, boo module.mapInstruction(type); addName(type->getResultId(), name); - if (emitNonSemanticShaderDebugInfo && !compilerGenerated) - { - auto const debugResultId = makeCompositeDebugType(members, name, NonSemanticShaderDebugInfo100Structure); + if (emitNonSemanticShaderDebugInfo && !compilerGenerated) { + assert(members.size() == memberDebugInfo.size()); + auto const debugResultId = + makeCompositeDebugType(members, memberDebugInfo, name, NonSemanticShaderDebugInfo100Structure); debugId[type->getResultId()] = debugResultId; } @@ -389,7 +466,7 @@ Id Builder::makeStructResultType(Id type0, Id type1) members.push_back(type0); members.push_back(type1); - return makeStructType(members, "ResType"); + return makeStructType(members, {}, "ResType"); } Id Builder::makeVectorType(Id component, int size) @@ -513,7 +590,7 @@ Id Builder::makeCooperativeMatrixTypeKHR(Id component, Id scope, Id rows, Id col debugName += std::string(findName(cols)) + ">"; // There's no nonsemantic debug info instruction for cooperative matrix types, // use opaque composite instead. - auto const debugResultId = makeCompositeDebugType({}, debugName.c_str(), NonSemanticShaderDebugInfo100Structure, true); + auto const debugResultId = makeOpaqueDebugType(debugName.c_str()); debugId[type->getResultId()] = debugResultId; } @@ -578,6 +655,26 @@ Id Builder::makeCooperativeVectorTypeNV(Id componentType, Id components) return type->getResultId(); } +Id Builder::makeTensorTypeARM(Id elementType, Id rank) +{ + // See if an OpTypeTensorARM with same element type and rank already exists. + for (int t = 0; t < (int)groupedTypes[enumCast(Op::OpTypeTensorARM)].size(); ++t) { + const Instruction *type = groupedTypes[enumCast(Op::OpTypeTensorARM)][t]; + if (type->getIdOperand(0) == elementType && type->getIdOperand(1) == rank) + return type->getResultId(); + } + + // Not found, make it. + std::unique_ptr type(new Instruction(getUniqueId(), NoType, Op::OpTypeTensorARM)); + type->addIdOperand(elementType); + type->addIdOperand(rank); + groupedTypes[enumCast(Op::OpTypeTensorARM)].push_back(type.get()); + module.mapInstruction(type.get()); + Id resultID = type->getResultId(); + constantsTypesGlobals.push_back(std::move(type)); + return resultID; +} + Id Builder::makeGenericType(spv::Op opcode, std::vector& operands) { // try to find it @@ -835,7 +932,7 @@ Id Builder::makeImageType(Id sampledType, Dim dim, bool depth, bool arrayed, boo } }; - auto const debugResultId = makeCompositeDebugType({}, TypeName(), NonSemanticShaderDebugInfo100Class, true); + auto const debugResultId = makeOpaqueDebugType(TypeName()); debugId[type->getResultId()] = debugResultId; } @@ -862,7 +959,7 @@ Id Builder::makeSampledImageType(Id imageType) if (emitNonSemanticShaderDebugInfo) { - auto const debugResultId = makeCompositeDebugType({}, "type.sampled.image", NonSemanticShaderDebugInfo100Class, true); + auto const debugResultId = makeOpaqueDebugType("type.sampled.image"); debugId[type->getResultId()] = debugResultId; } @@ -1059,7 +1156,7 @@ Id Builder::makeMatrixDebugType(Id const vectorType, int const vectorCount, bool return type->getResultId(); } -Id Builder::makeMemberDebugType(Id const memberType, DebugTypeLoc const& debugTypeLoc) +Id Builder::makeMemberDebugType(Id const memberType, StructMemberDebugInfo const& debugTypeLoc) { assert(debugId[memberType] != 0); @@ -1068,12 +1165,13 @@ Id Builder::makeMemberDebugType(Id const memberType, DebugTypeLoc const& debugTy type->addIdOperand(nonSemanticShaderDebugInfo); type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeMember); type->addIdOperand(getStringId(debugTypeLoc.name)); // name id - type->addIdOperand(debugId[memberType]); // type id - type->addIdOperand(makeDebugSource(currentFileId)); // source id - type->addIdOperand(makeUintConstant(debugTypeLoc.line)); // line id TODO: currentLine is always zero + type->addIdOperand(debugTypeLoc.debugTypeOverride != 0 ? debugTypeLoc.debugTypeOverride + : debugId[memberType]); // type id + type->addIdOperand(makeDebugSource(currentFileId)); // source id + type->addIdOperand(makeUintConstant(debugTypeLoc.line)); // line id TODO: currentLine is always zero type->addIdOperand(makeUintConstant(debugTypeLoc.column)); // TODO: column id - type->addIdOperand(makeUintConstant(0)); // TODO: offset id - type->addIdOperand(makeUintConstant(0)); // TODO: size id + type->addIdOperand(makeUintConstant(0)); // TODO: offset id + type->addIdOperand(makeUintConstant(0)); // TODO: size id type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsPublic)); // flags id groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeMember].push_back(type); @@ -1083,23 +1181,16 @@ Id Builder::makeMemberDebugType(Id const memberType, DebugTypeLoc const& debugTy return type->getResultId(); } -// Note: To represent a source language opaque type, this instruction must have no Members operands, Size operand must be -// DebugInfoNone, and Name must start with @ to avoid clashes with user defined names. -Id Builder::makeCompositeDebugType(std::vector const& memberTypes, char const*const name, - NonSemanticShaderDebugInfo100DebugCompositeType const tag, bool const isOpaqueType) +Id Builder::makeCompositeDebugType(std::vector const& memberTypes, std::vector const& memberDebugInfo, + char const* const name, NonSemanticShaderDebugInfo100DebugCompositeType const tag) { // Create the debug member types. std::vector memberDebugTypes; - for(auto const memberType : memberTypes) { - assert(debugTypeLocs.find(memberType) != debugTypeLocs.end()); - - // There _should_ be debug types for all the member types but currently buffer references - // do not have member debug info generated. - if (debugId[memberType]) - memberDebugTypes.emplace_back(makeMemberDebugType(memberType, debugTypeLocs[memberType])); - - // TODO: Need to rethink this method of passing location information. - // debugTypeLocs.erase(memberType); + assert(memberTypes.size() == memberDebugInfo.size()); + for (size_t i = 0; i < memberTypes.size(); i++) { + if (debugId[memberTypes[i]]) { + memberDebugTypes.emplace_back(makeMemberDebugType(memberTypes[i], memberDebugInfo[i])); + } } // Create The structure debug type. @@ -1113,16 +1204,9 @@ Id Builder::makeCompositeDebugType(std::vector const& memberTypes, char cons type->addIdOperand(makeUintConstant(currentLine)); // line id TODO: currentLine always zero? type->addIdOperand(makeUintConstant(0)); // TODO: column id type->addIdOperand(makeDebugCompilationUnit()); // scope id - if(isOpaqueType == true) { - // Prepend '@' to opaque types. - type->addIdOperand(getStringId('@' + std::string(name))); // linkage name id - type->addIdOperand(makeDebugInfoNone()); // size id - } else { - type->addIdOperand(getStringId(name)); // linkage name id - type->addIdOperand(makeUintConstant(0)); // TODO: size id - } + type->addIdOperand(getStringId(name)); // linkage name id + type->addIdOperand(makeUintConstant(0)); // TODO: size id type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsPublic)); // flags id - assert(isOpaqueType == false || (isOpaqueType == true && memberDebugTypes.empty())); for(auto const memberDebugType : memberDebugTypes) { type->addIdOperand(memberDebugType); } @@ -1134,6 +1218,34 @@ Id Builder::makeCompositeDebugType(std::vector const& memberTypes, char cons return type->getResultId(); } +// The NonSemantic Shader Debug Info doesn't really have a dedicated opcode for opaque types. Instead, we use DebugTypeComposite. +// To represent a source language opaque type, this instruction must have no Members operands, Size operand must be +// DebugInfoNone, and Name must start with @ to avoid clashes with user defined names. +Id Builder::makeOpaqueDebugType(char const* const name) +{ + // Create The structure debug type. + Instruction* type = new Instruction(getUniqueId(), makeVoidType(), Op::OpExtInst); + type->reserveOperands(11); + type->addIdOperand(nonSemanticShaderDebugInfo); + type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeComposite); + type->addIdOperand(getStringId(name)); // name id + type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100Structure)); // tag id + type->addIdOperand(makeDebugSource(currentFileId)); // source id + type->addIdOperand(makeUintConstant(currentLine)); // line id TODO: currentLine always zero? + type->addIdOperand(makeUintConstant(0)); // TODO: column id + type->addIdOperand(makeDebugCompilationUnit()); // scope id + // Prepend '@' to opaque types. + type->addIdOperand(getStringId('@' + std::string(name))); // linkage name id + type->addIdOperand(makeDebugInfoNone()); // size id + type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsPublic)); // flags id + + groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeComposite].push_back(type); + constantsTypesGlobals.push_back(std::unique_ptr(type)); + module.mapInstruction(type); + + return type->getResultId(); +} + Id Builder::makePointerDebugType(StorageClass storageClass, Id const baseType) { const Id debugBaseType = debugId[baseType]; @@ -1307,7 +1419,7 @@ Id Builder::createDebugLocalVariable(Id type, char const*const name, size_t cons inst->addIdOperand(currentDebugScopeId.top()); // scope id inst->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsLocal)); // flags id if(argNumber != 0) { - inst->addIdOperand(makeUintConstant(argNumber)); + inst->addIdOperand(makeUintConstant(static_cast(argNumber))); } constantsTypesGlobals.push_back(std::unique_ptr(inst)); @@ -1371,7 +1483,7 @@ Id Builder::makeAccelerationStructureType() constantsTypesGlobals.push_back(std::unique_ptr(type)); module.mapInstruction(type); if (emitNonSemanticShaderDebugInfo) { - spv::Id debugType = makeCompositeDebugType({}, "accelerationStructure", NonSemanticShaderDebugInfo100Structure, true); + spv::Id debugType = makeOpaqueDebugType("accelerationStructure"); debugId[type->getResultId()] = debugType; } } else { @@ -1390,7 +1502,7 @@ Id Builder::makeRayQueryType() constantsTypesGlobals.push_back(std::unique_ptr(type)); module.mapInstruction(type); if (emitNonSemanticShaderDebugInfo) { - spv::Id debugType = makeCompositeDebugType({}, "rayQuery", NonSemanticShaderDebugInfo100Structure, true); + spv::Id debugType = makeOpaqueDebugType("rayQuery"); debugId[type->getResultId()] = debugType; } } else { @@ -1897,6 +2009,62 @@ Id Builder::makeBFloat16Constant(float bf16, bool specConstant) return c->getResultId(); } +Id Builder::makeFloatE5M2Constant(float fe5m2, bool specConstant) +{ + Op opcode = specConstant ? Op::OpSpecConstant : Op::OpConstant; + Id typeId = makeFloatE5M2Type(); + + spvutils::HexFloat> fVal(fe5m2); + spvutils::HexFloat> fe5m2Val(0); + fVal.castTo(fe5m2Val, spvutils::kRoundToZero); + + unsigned value = fe5m2Val.value().getAsFloat().get_value(); + + // See if we already made it. Applies only to regular constants, because specialization constants + // must remain distinct for the purpose of applying a SpecId decoration. + if (!specConstant) { + Id existing = findScalarConstant(Op::OpTypeFloat, opcode, typeId, value); + if (existing) + return existing; + } + + Instruction* c = new Instruction(getUniqueId(), typeId, opcode); + c->addImmediateOperand(value); + constantsTypesGlobals.push_back(std::unique_ptr(c)); + groupedConstants[enumCast(Op::OpTypeFloat)].push_back(c); + module.mapInstruction(c); + + return c->getResultId(); +} + +Id Builder::makeFloatE4M3Constant(float fe4m3, bool specConstant) +{ + Op opcode = specConstant ? Op::OpSpecConstant : Op::OpConstant; + Id typeId = makeFloatE4M3Type(); + + spvutils::HexFloat> fVal(fe4m3); + spvutils::HexFloat> fe4m3Val(0); + fVal.castTo(fe4m3Val, spvutils::kRoundToZero); + + unsigned value = fe4m3Val.value().getAsFloat().get_value(); + + // See if we already made it. Applies only to regular constants, because specialization constants + // must remain distinct for the purpose of applying a SpecId decoration. + if (!specConstant) { + Id existing = findScalarConstant(Op::OpTypeFloat, opcode, typeId, value); + if (existing) + return existing; + } + + Instruction* c = new Instruction(getUniqueId(), typeId, opcode); + c->addImmediateOperand(value); + constantsTypesGlobals.push_back(std::unique_ptr(c)); + groupedConstants[enumCast(Op::OpTypeFloat)].push_back(c); + module.mapInstruction(c); + + return c->getResultId(); +} + Id Builder::makeFpConstant(Id type, double d, bool specConstant) { const int width = getScalarTypeWidth(type); diff --git a/libs/bgfx/3rdparty/glslang/SPIRV/SpvBuilder.h b/libs/bgfx/3rdparty/glslang/SPIRV/SpvBuilder.h index f5aa17b..2ab7d02 100644 --- a/libs/bgfx/3rdparty/glslang/SPIRV/SpvBuilder.h +++ b/libs/bgfx/3rdparty/glslang/SPIRV/SpvBuilder.h @@ -82,6 +82,14 @@ typedef enum { Spv_1_6 = (1 << 16) | (6 << 8), } SpvVersion; +struct StructMemberDebugInfo { + std::string name {}; + int line {0}; + int column {0}; + // Set if the caller knows a better debug type than what is associated with the functional SPIR-V type. + spv::Id debugTypeOverride {0}; +}; + class Builder { public: Builder(unsigned int spvVersion, unsigned int userNumber, SpvBuildLogger* logger); @@ -198,6 +206,14 @@ class Builder { return id; } + // Maps the given OpType Id to a Non-Semantic DebugType Id. + Id getDebugType(Id type) { + if (emitNonSemanticShaderDebugInfo) { + return debugId[type]; + } + return 0; + } + // For creating new types (will return old type if the requested one was already made). Id makeVoidType(); Id makeBoolType(); @@ -209,7 +225,10 @@ class Builder { Id makeUintType(int width) { return makeIntegerType(width, false); } Id makeFloatType(int width); Id makeBFloat16Type(); - Id makeStructType(const std::vector& members, const char* name, bool const compilerGenerated = true); + Id makeFloatE5M2Type(); + Id makeFloatE4M3Type(); + Id makeStructType(const std::vector& members, const std::vector& memberDebugInfo, + const char* name, bool const compilerGenerated = true); Id makeStructResultType(Id type0, Id type1); Id makeVectorType(Id component, int size); Id makeMatrixType(Id component, int cols, int rows); @@ -223,15 +242,10 @@ class Builder { Id makeCooperativeMatrixTypeNV(Id component, Id scope, Id rows, Id cols); Id makeCooperativeMatrixTypeWithSameShape(Id component, Id otherType); Id makeCooperativeVectorTypeNV(Id componentType, Id components); + Id makeTensorTypeARM(Id elementType, Id rank); Id makeGenericType(spv::Op opcode, std::vector& operands); // SPIR-V NonSemantic Shader DebugInfo Instructions - struct DebugTypeLoc { - std::string name {}; - int line {0}; - int column {0}; - }; - std::unordered_map debugTypeLocs; Id makeDebugInfoNone(); Id makeBoolDebugType(int const size); Id makeIntegerDebugType(int const width, bool const hasSign); @@ -240,9 +254,10 @@ class Builder { Id makeArrayDebugType(Id const baseType, Id const componentCount); Id makeVectorDebugType(Id const baseType, int const componentCount); Id makeMatrixDebugType(Id const vectorType, int const vectorCount, bool columnMajor = true); - Id makeMemberDebugType(Id const memberType, DebugTypeLoc const& debugTypeLoc); - Id makeCompositeDebugType(std::vector const& memberTypes, char const*const name, - NonSemanticShaderDebugInfo100DebugCompositeType const tag, bool const isOpaqueType = false); + Id makeMemberDebugType(Id const memberType, StructMemberDebugInfo const& debugTypeLoc); + Id makeCompositeDebugType(std::vector const& memberTypes, std::vector const& memberDebugInfo, + char const* const name, NonSemanticShaderDebugInfo100DebugCompositeType const tag); + Id makeOpaqueDebugType(char const* const name); Id makePointerDebugType(StorageClass storageClass, Id const baseType); Id makeForwardPointerDebugType(StorageClass storageClass); Id makeDebugSource(const Id fileName); @@ -320,6 +335,7 @@ class Builder { } bool isTensorViewType(Id typeId) const { return getTypeClass(typeId) == Op::OpTypeTensorViewNV; } bool isCooperativeVectorType(Id typeId) const { return getTypeClass(typeId) == Op::OpTypeCooperativeVectorNV; } + bool isTensorTypeARM(Id typeId) const { return getTypeClass(typeId) == Op::OpTypeTensorARM; } bool isAggregateType(Id typeId) const { return isArrayType(typeId) || isStructType(typeId) || isCooperativeMatrixType(typeId); } bool isImageType(Id typeId) const { return getTypeClass(typeId) == Op::OpTypeImage; } @@ -414,6 +430,8 @@ class Builder { Id makeDoubleConstant(double d, bool specConstant = false); Id makeFloat16Constant(float f16, bool specConstant = false); Id makeBFloat16Constant(float bf16, bool specConstant = false); + Id makeFloatE5M2Constant(float fe5m2, bool specConstant = false); + Id makeFloatE4M3Constant(float fe4m3, bool specConstant = false); Id makeFpConstant(Id type, double d, bool specConstant = false); Id importNonSemanticShaderDebugInfoInstructions(); diff --git a/libs/bgfx/3rdparty/glslang/SPIRV/disassemble.cpp b/libs/bgfx/3rdparty/glslang/SPIRV/disassemble.cpp index a733996..9b85ff2 100644 --- a/libs/bgfx/3rdparty/glslang/SPIRV/disassemble.cpp +++ b/libs/bgfx/3rdparty/glslang/SPIRV/disassemble.cpp @@ -61,7 +61,7 @@ namespace spv { #include "GLSL.ext.QCOM.h" } } -const char* GlslStd450DebugNames[spv::GLSLstd450Count]; +static const char* GlslStd450DebugNames[spv::GLSLstd450Count]; namespace spv { @@ -382,9 +382,22 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode, break; case Op::OpTypeFloat: switch (stream[word]) { + case 8: case 16: - if (numOperands > 1 && stream[word+1] == spv::FPEncoding::BFloat16KHR) { - idDescriptor[resultId] = "bfloat16_t"; + if (numOperands > 1) { + switch (stream[word+1]) { + default: + assert(0); [[fallthrough]]; + case (int)spv::FPEncoding::BFloat16KHR: + idDescriptor[resultId] = "bfloat16_t"; + break; + case (int)spv::FPEncoding::Float8E4M3EXT: + idDescriptor[resultId] = "floate4m3_t"; + break; + case (int)spv::FPEncoding::Float8E5M2EXT: + idDescriptor[resultId] = "floate5m2_t"; + break; + } } else { idDescriptor[resultId] = "float16_t"; } diff --git a/libs/bgfx/3rdparty/glslang/SPIRV/doc.cpp b/libs/bgfx/3rdparty/glslang/SPIRV/doc.cpp index db097a7..b0189a5 100644 --- a/libs/bgfx/3rdparty/glslang/SPIRV/doc.cpp +++ b/libs/bgfx/3rdparty/glslang/SPIRV/doc.cpp @@ -344,6 +344,8 @@ const char* DecorationString(int decoration) case (int)Decoration::AliasedPointerEXT: return "DecorationAliasedPointerEXT"; case (int)Decoration::HitObjectShaderRecordBufferNV: return "DecorationHitObjectShaderRecordBufferNV"; + + case (int)Decoration::SaturatedToLargestFloat8NormalConversionEXT: return "DecorationSaturatedToLargestFloat8NormalConversionEXT"; } } @@ -975,7 +977,7 @@ const char* CapabilityString(int info) case (int)Capability::SubgroupBallotKHR: return "SubgroupBallotKHR"; case (int)Capability::DrawParameters: return "DrawParameters"; case (int)Capability::SubgroupVoteKHR: return "SubgroupVoteKHR"; - case (int)Capability::GroupNonUniformRotateKHR: return "CapabilityGroupNonUniformRotateKHR"; + case (int)Capability::GroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR"; case (int)Capability::StorageUniformBufferBlock16: return "StorageUniformBufferBlock16"; case (int)Capability::StorageUniform16: return "StorageUniform16"; @@ -1021,7 +1023,7 @@ const char* CapabilityString(int info) case (int)Capability::RayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR"; case (int)Capability::DisplacementMicromapNV: return "DisplacementMicromapNV"; case (int)Capability::RayTracingOpacityMicromapEXT: return "RayTracingOpacityMicromapEXT"; - case (int)Capability::RayTracingDisplacementMicromapNV: return "CapabilityRayTracingDisplacementMicromapNV"; + case (int)Capability::RayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; case (int)Capability::RayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR"; case (int)Capability::ComputeDerivativeGroupQuadsNV: return "ComputeDerivativeGroupQuadsNV"; case (int)Capability::ComputeDerivativeGroupLinearNV: return "ComputeDerivativeGroupLinearNV"; @@ -1069,15 +1071,16 @@ const char* CapabilityString(int info) case (int)Capability::CooperativeVectorNV: return "CooperativeVectorNV"; case (int)Capability::CooperativeVectorTrainingNV: return "CooperativeVectorTrainingNV"; - case (int)Capability::FragmentShaderSampleInterlockEXT: return "CapabilityFragmentShaderSampleInterlockEXT"; - case (int)Capability::FragmentShaderPixelInterlockEXT: return "CapabilityFragmentShaderPixelInterlockEXT"; - case (int)Capability::FragmentShaderShadingRateInterlockEXT: return "CapabilityFragmentShaderShadingRateInterlockEXT"; + case (int)Capability::FragmentShaderSampleInterlockEXT: return "FragmentShaderSampleInterlockEXT"; + case (int)Capability::FragmentShaderPixelInterlockEXT: return "FragmentShaderPixelInterlockEXT"; + case (int)Capability::FragmentShaderShadingRateInterlockEXT: return "FragmentShaderShadingRateInterlockEXT"; case (int)Capability::TileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT"; case (int)Capability::TileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT"; case (int)Capability::TileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT"; case (int)Capability::CooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM"; + case (int)Capability::TensorsARM: return "TensorsARM"; case (int)Capability::FragmentShadingRateKHR: return "FragmentShadingRateKHR"; @@ -1087,7 +1090,7 @@ const char* CapabilityString(int info) case (int)Capability::QuadControlKHR: return "QuadControlKHR"; case (int)Capability::Int64ImageEXT: return "Int64ImageEXT"; - case (int)Capability::IntegerFunctions2INTEL: return "CapabilityIntegerFunctions2INTEL"; + case (int)Capability::IntegerFunctions2INTEL: return "IntegerFunctions2INTEL"; case (int)Capability::ExpectAssumeKHR: return "ExpectAssumeKHR"; @@ -1098,9 +1101,9 @@ const char* CapabilityString(int info) case (int)Capability::AtomicFloat32MinMaxEXT: return "AtomicFloat32MinMaxEXT"; case (int)Capability::AtomicFloat64MinMaxEXT: return "AtomicFloat64MinMaxEXT"; - case (int)Capability::WorkgroupMemoryExplicitLayoutKHR: return "CapabilityWorkgroupMemoryExplicitLayoutKHR"; - case (int)Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR: return "CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR"; - case (int)Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR: return "CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR"; + case (int)Capability::WorkgroupMemoryExplicitLayoutKHR: return "WorkgroupMemoryExplicitLayoutKHR"; + case (int)Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR: return "WorkgroupMemoryExplicitLayout8BitAccessKHR"; + case (int)Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR: return "WorkgroupMemoryExplicitLayout16BitAccessKHR"; case (int)Capability::CoreBuiltinsARM: return "CoreBuiltinsARM"; case (int)Capability::ShaderInvocationReorderNV: return "ShaderInvocationReorderNV"; @@ -1111,7 +1114,9 @@ const char* CapabilityString(int info) case (int)Capability::TileShadingQCOM: return "TileShadingQCOM"; case (int)Capability::TextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM"; - case (int)Capability::ReplicatedCompositesEXT: return "CapabilityReplicatedCompositesEXT"; + case (int)Capability::CooperativeMatrixConversionQCOM: return "CooperativeMatrixConversionQCOM"; + + case (int)Capability::ReplicatedCompositesEXT: return "ReplicatedCompositesEXT"; case (int)Capability::DotProductKHR: return "DotProductKHR"; case (int)Capability::DotProductInputAllKHR: return "DotProductInputAllKHR"; @@ -1123,9 +1128,12 @@ const char* CapabilityString(int info) case (int)Capability::RayTracingSpheresGeometryNV: return "RayTracingSpheresGeometryNV"; case (int)Capability::RayTracingLinearSweptSpheresGeometryNV: return "RayTracingLinearSweptSpheresGeometryNV"; - case (int)Capability::BFloat16TypeKHR: return "CapabilityBFloat16TypeKHR"; - case (int)Capability::BFloat16DotProductKHR: return "CapabilityBFloat16DotProductKHR"; - case (int)Capability::BFloat16CooperativeMatrixKHR: return "CapabilityBFloat16CooperativeMatrixKHR"; + case (int)Capability::BFloat16TypeKHR: return "BFloat16TypeKHR"; + case (int)Capability::BFloat16DotProductKHR: return "BFloat16DotProductKHR"; + case (int)Capability::BFloat16CooperativeMatrixKHR: return "BFloat16CooperativeMatrixKHR"; + + case (int)Capability::Float8EXT: return "Float8EXT"; + case (int)Capability::Float8CooperativeMatrixEXT: return "Float8CooperativeMatrixEXT"; default: return "Bad"; } @@ -1621,6 +1629,11 @@ const char* OpcodeString(int op) case (int)Op::OpTensorViewSetStrideNV: return "OpTensorViewSetStrideNV"; case (int)Op::OpTensorViewSetClipNV: return "OpTensorViewSetClipNV"; + case (int)Op::OpTypeTensorARM: return "OpTypeTensorARM"; + case (int)Op::OpTensorReadARM: return "OpTensorReadARM"; + case (int)Op::OpTensorWriteARM: return "OpTensorWriteARM"; + case (int)Op::OpTensorQuerySizeARM: return "OpTensorQuerySizeARM"; + case (int)Op::OpTypeCooperativeVectorNV: return "OpTypeCooperativeVectorNV"; case (int)Op::OpCooperativeVectorMatrixMulNV: return "OpCooperativeVectorMatrixMulNV"; case (int)Op::OpCooperativeVectorMatrixMulAddNV: return "OpCooperativeVectorMatrixMulAddNV"; @@ -1689,6 +1702,11 @@ const char* OpcodeString(int op) case (int)Op::OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM"; case (int)Op::OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM"; + case (int)Op::OpBitCastArrayQCOM: return "OpBitCastArrayQCOM"; + case (int)Op::OpCompositeConstructCoopMatQCOM: return "OpCompositeConstructCoopMatQCOM"; + case (int)Op::OpCompositeExtractCoopMatQCOM: return "OpCompositeExtractCoopMatQCOM"; + case (int)Op::OpExtractSubArrayQCOM: return "OpExtractSubArrayQCOM"; + case (int)Op::OpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT"; case (int)Op::OpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT"; case (int)Op::OpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT"; @@ -1828,6 +1846,10 @@ void Parameterize() InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].setResultAndType(false, false); InstructionDesc[enumCast(Op::OpCooperativeVectorReduceSumAccumulateNV)].setResultAndType(false, false); + InstructionDesc[enumCast(Op::OpTypeTensorARM)].setResultAndType(true, false); + InstructionDesc[enumCast(Op::OpTensorReadARM)].setResultAndType(true, true); + InstructionDesc[enumCast(Op::OpTensorWriteARM)].setResultAndType(false, false); + // Specific additional context-dependent operands ExecutionModeOperands[enumCast(ExecutionMode::Invocations)].push(OperandLiteralNumber, "'Number of <>'"); @@ -3709,6 +3731,19 @@ void Parameterize() InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].operands.push(OperandImageOperands, "", true); InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].setResultAndType(true, true); + InstructionDesc[enumCast(Op::OpBitCastArrayQCOM)].operands.push(OperandId, "'source array'"); + InstructionDesc[enumCast(Op::OpBitCastArrayQCOM)].setResultAndType(true, true); + + InstructionDesc[enumCast(Op::OpCompositeConstructCoopMatQCOM)].operands.push(OperandId, "'source array'"); + InstructionDesc[enumCast(Op::OpCompositeConstructCoopMatQCOM)].setResultAndType(true, true); + + InstructionDesc[enumCast(Op::OpCompositeExtractCoopMatQCOM)].operands.push(OperandId, "'source cooperative matrix'"); + InstructionDesc[enumCast(Op::OpCompositeExtractCoopMatQCOM)].setResultAndType(true, true); + + InstructionDesc[enumCast(Op::OpExtractSubArrayQCOM)].operands.push(OperandId, "'source array'"); + InstructionDesc[enumCast(Op::OpExtractSubArrayQCOM)].operands.push(OperandId, "'start index'"); + InstructionDesc[enumCast(Op::OpExtractSubArrayQCOM)].setResultAndType(true, true); + InstructionDesc[enumCast(Op::OpConstantCompositeReplicateEXT)].operands.push(OperandId, "'Value'"); InstructionDesc[enumCast(Op::OpSpecConstantCompositeReplicateEXT)].operands.push(OperandId, "'Value'"); InstructionDesc[enumCast(Op::OpCompositeConstructReplicateEXT)].operands.push(OperandId, "'Value'"); @@ -3800,6 +3835,24 @@ void Parameterize() InstructionDesc[enumCast(Op::OpSUDotAccSatKHR)].operands.push(OperandId, "'Vector2'"); InstructionDesc[enumCast(Op::OpSUDotAccSatKHR)].operands.push(OperandId, "'Accumulator'"); InstructionDesc[enumCast(Op::OpSUDotAccSatKHR)].operands.push(OperandLiteralNumber, "'PackedVectorFormat'"); + + InstructionDesc[enumCast(Op::OpTypeTensorARM)].operands.push(OperandId, "'Element Type'"); + InstructionDesc[enumCast(Op::OpTypeTensorARM)].operands.push(OperandId, "'Rank'"); + + InstructionDesc[enumCast(Op::OpTensorReadARM)].operands.push(OperandId, "'Tensor'"); + InstructionDesc[enumCast(Op::OpTensorReadARM)].operands.push(OperandId, "'Coordinate'"); + InstructionDesc[enumCast(Op::OpTensorReadARM)].operands.push(OperandLiteralNumber, "'Tensor Operand'", true); + InstructionDesc[enumCast(Op::OpTensorReadARM)].operands.push(OperandVariableIds, "'Tensor Operands'"); + + InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandId, "'Tensor'"); + InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandId, "'Coordinate'"); + InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandId, "'Object'"); + InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandLiteralNumber, "'Tensor Operand'", true); + InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandVariableIds, "'Tensor Operands'"); + + InstructionDesc[enumCast(Op::OpTensorQuerySizeARM)].operands.push(OperandId, "'Tensor'"); + InstructionDesc[enumCast(Op::OpTensorQuerySizeARM)].operands.push(OperandId, "'Dimension'", true); + }); } diff --git a/libs/bgfx/3rdparty/glslang/SPIRV/hex_float.h b/libs/bgfx/3rdparty/glslang/SPIRV/hex_float.h index 785e8af..c2259e3 100644 --- a/libs/bgfx/3rdparty/glslang/SPIRV/hex_float.h +++ b/libs/bgfx/3rdparty/glslang/SPIRV/hex_float.h @@ -50,6 +50,52 @@ class Float16 { uint16_t val; }; +class FloatE5M2 { + public: + FloatE5M2(uint8_t v) : val(v) {} + FloatE5M2() {} + static bool isNan(const FloatE5M2& val) { + return ((val.val & 0x7C) == 0x7C) && ((val.val & 0x3) != 0); + } + // Returns true if the given value is any kind of infinity. + static bool isInfinity(const FloatE5M2& val) { + return ((val.val & 0x7C) == 0x7C) && ((val.val & 0x3) == 0); + } + FloatE5M2(const FloatE5M2& other) { val = other.val; } + uint8_t get_value() const { return val; } + + // Returns the maximum normal value. + static FloatE5M2 max() { return FloatE5M2(0x7B); } + // Returns the lowest normal value. + static FloatE5M2 lowest() { return FloatE5M2(0xFB); } + + private: + uint8_t val; +}; + +class FloatE4M3 { + public: + FloatE4M3(uint8_t v) : val(v) {} + FloatE4M3() {} + static bool isNan(const FloatE4M3& val) { + return (val.val & 0x7F) == 0x7F; + } + // Returns true if the given value is any kind of infinity. + static bool isInfinity(const FloatE4M3&) { + return false; + } + FloatE4M3(const FloatE4M3& other) { val = other.val; } + uint8_t get_value() const { return val; } + + // Returns the maximum normal value. + static FloatE4M3 max() { return FloatE4M3(0x7E); } + // Returns the lowest normal value. + static FloatE4M3 lowest() { return FloatE4M3(0xFE); } + + private: + uint8_t val; +}; + // To specialize this type, you must override uint_type to define // an unsigned integer that can fit your floating point type. // You must also add a isNan function that returns true if @@ -95,6 +141,30 @@ struct FloatProxyTraits { static Float16 lowest() { return Float16::lowest(); } }; +template <> +struct FloatProxyTraits { + typedef uint8_t uint_type; + static bool isNan(FloatE5M2 f) { return FloatE5M2::isNan(f); } + // Returns true if the given value is any kind of infinity. + static bool isInfinity(FloatE5M2 f) { return FloatE5M2::isInfinity(f); } + // Returns the maximum normal value. + static FloatE5M2 max() { return FloatE5M2::max(); } + // Returns the lowest normal value. + static FloatE5M2 lowest() { return FloatE5M2::lowest(); } +}; + +template <> +struct FloatProxyTraits { + typedef uint8_t uint_type; + static bool isNan(FloatE4M3 f) { return FloatE4M3::isNan(f); } + // Returns true if the given value is any kind of infinity. + static bool isInfinity(FloatE4M3 f) { return FloatE4M3::isInfinity(f); } + // Returns the maximum normal value. + static FloatE4M3 max() { return FloatE4M3::max(); } + // Returns the lowest normal value. + static FloatE4M3 lowest() { return FloatE4M3::lowest(); } +}; + // Since copying a floating point number (especially if it is NaN) // does not guarantee that bits are preserved, this class lets us // store the type and use it as a float when necessary. @@ -182,6 +252,7 @@ struct HexFloatTraits { // The bias of the exponent. (How much we need to subtract from the stored // value to get the correct value.) static const uint32_t exponent_bias = 0; + static bool supportsInfinity() { return true; } }; // Traits for IEEE float. @@ -196,6 +267,7 @@ struct HexFloatTraits> { static const uint_type num_exponent_bits = 8; static const uint_type num_fraction_bits = 23; static const uint_type exponent_bias = 127; + static bool supportsInfinity() { return true; } }; // Traits for IEEE double. @@ -210,6 +282,7 @@ struct HexFloatTraits> { static const uint_type num_exponent_bits = 11; static const uint_type num_fraction_bits = 52; static const uint_type exponent_bias = 1023; + static bool supportsInfinity() { return true; } }; // Traits for IEEE half. @@ -224,6 +297,33 @@ struct HexFloatTraits> { static const uint_type num_exponent_bits = 5; static const uint_type num_fraction_bits = 10; static const uint_type exponent_bias = 15; + static bool supportsInfinity() { return true; } +}; + +template <> +struct HexFloatTraits> { + typedef uint8_t uint_type; + typedef int8_t int_type; + typedef uint8_t underlying_type; + typedef uint8_t native_type; + static const uint_type num_used_bits = 8; + static const uint_type num_exponent_bits = 5; + static const uint_type num_fraction_bits = 2; + static const uint_type exponent_bias = 15; + static bool supportsInfinity() { return true; } +}; + +template <> +struct HexFloatTraits> { + typedef uint8_t uint_type; + typedef int8_t int_type; + typedef uint8_t underlying_type; + typedef uint8_t native_type; + static const uint_type num_used_bits = 8; + static const uint_type num_exponent_bits = 4; + static const uint_type num_fraction_bits = 3; + static const uint_type exponent_bias = 7; + static bool supportsInfinity() { return false; } }; enum round_direction { @@ -243,6 +343,7 @@ class HexFloat { typedef typename Traits::int_type int_type; typedef typename Traits::underlying_type underlying_type; typedef typename Traits::native_type native_type; + using Traits_T = Traits; explicit HexFloat(T f) : value_(f) {} @@ -584,14 +685,22 @@ class HexFloat { (getBits() & exponent_mask) == exponent_mask && significand != 0; bool is_inf = !is_nan && - ((exponent + carried) > static_cast(other_T::exponent_bias) || + (((exponent + carried) > static_cast(other_T::exponent_bias) && other_T::Traits_T::supportsInfinity()) || + ((exponent + carried) > static_cast(other_T::exponent_bias + 1) && !other_T::Traits_T::supportsInfinity()) || (significand == 0 && (getBits() & exponent_mask) == exponent_mask)); // If we are Nan or Inf we should pass that through. if (is_inf) { - other.set_value(BitwiseCast( - static_cast( - (negate ? other_T::sign_mask : 0) | other_T::exponent_mask))); + if (other_T::Traits_T::supportsInfinity()) { + // encode as +/-inf + other.set_value(BitwiseCast( + static_cast( + (negate ? other_T::sign_mask : 0) | other_T::exponent_mask))); + } else { + // encode as +/-nan + other.set_value(BitwiseCast( + static_cast(negate ? ~0 : ~other_T::sign_mask))); + } return; } if (is_nan) { diff --git a/libs/bgfx/3rdparty/glslang/SPIRV/spirv.hpp11 b/libs/bgfx/3rdparty/glslang/SPIRV/spirv.hpp11 index e9e36c3..2ad294d 100644 --- a/libs/bgfx/3rdparty/glslang/SPIRV/spirv.hpp11 +++ b/libs/bgfx/3rdparty/glslang/SPIRV/spirv.hpp11 @@ -547,6 +547,7 @@ enum class Decoration : unsigned { MaxByteOffset = 45, AlignmentId = 46, MaxByteOffsetId = 47, + SaturatedToLargestFloat8NormalConversionEXT = 4216, NoSignedWrap = 4469, NoUnsignedWrap = 4470, WeightTextureQCOM = 4487, @@ -1069,7 +1070,10 @@ enum class Capability : unsigned { TileImageColorReadAccessEXT = 4166, TileImageDepthReadAccessEXT = 4167, TileImageStencilReadAccessEXT = 4168, + TensorsARM = 4174, CooperativeMatrixLayoutsARM = 4201, + Float8EXT = 4212, + Float8CooperativeMatrixEXT = 4213, FragmentShadingRateKHR = 4422, SubgroupBallotKHR = 4423, DrawParameters = 4427, @@ -1106,6 +1110,7 @@ enum class Capability : unsigned { TextureBoxFilterQCOM = 4485, TextureBlockMatchQCOM = 4486, TileShadingQCOM = 4495, + CooperativeMatrixConversionQCOM = 4496, TextureBlockMatch2QCOM = 4498, Float16ImageAMD = 5008, ImageGatherBiasLodAMD = 5009, @@ -1457,6 +1462,18 @@ enum class TensorAddressingOperandsMask : unsigned { DecodeFunc = 0x00000002, }; +enum class TensorOperandsShift : unsigned { + NontemporalARM = 0, + OutOfBoundsValueARM = 1, + Max = 0x7fffffff, +}; + +enum class TensorOperandsMask : unsigned { + MaskNone = 0, + NontemporalARM = 0x00000001, + OutOfBoundsValueARM = 0x00000002, +}; + enum class InitializationModeQualifier : unsigned { InitOnDeviceReprogramINTEL = 0, InitOnDeviceResetINTEL = 1, @@ -1543,6 +1560,8 @@ enum class RawAccessChainOperandsMask : unsigned { enum class FPEncoding : unsigned { BFloat16KHR = 0, + Float8E4M3EXT = 4214, + Float8E5M2EXT = 4215, Max = 0x7fffffff, }; @@ -1921,6 +1940,10 @@ enum class Op : unsigned { OpColorAttachmentReadEXT = 4160, OpDepthAttachmentReadEXT = 4161, OpStencilAttachmentReadEXT = 4162, + OpTypeTensorARM = 4163, + OpTensorReadARM = 4164, + OpTensorWriteARM = 4165, + OpTensorQuerySizeARM = 4166, OpTerminateInvocation = 4416, OpTypeUntypedPointerKHR = 4417, OpUntypedVariableKHR = 4418, @@ -1974,10 +1997,14 @@ enum class Op : unsigned { OpImageBoxFilterQCOM = 4481, OpImageBlockMatchSSDQCOM = 4482, OpImageBlockMatchSADQCOM = 4483, + OpBitCastArrayQCOM = 4497, OpImageBlockMatchWindowSSDQCOM = 4500, OpImageBlockMatchWindowSADQCOM = 4501, OpImageBlockMatchGatherSSDQCOM = 4502, OpImageBlockMatchGatherSADQCOM = 4503, + OpCompositeConstructCoopMatQCOM = 4540, + OpCompositeExtractCoopMatQCOM = 4541, + OpExtractSubArrayQCOM = 4542, OpGroupIAddNonUniformAMD = 5000, OpGroupFAddNonUniformAMD = 5001, OpGroupFMinNonUniformAMD = 5002, @@ -2730,6 +2757,10 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case Op::OpColorAttachmentReadEXT: *hasResult = true; *hasResultType = true; break; case Op::OpDepthAttachmentReadEXT: *hasResult = true; *hasResultType = true; break; case Op::OpStencilAttachmentReadEXT: *hasResult = true; *hasResultType = true; break; + case Op::OpTypeTensorARM: *hasResult = true; *hasResultType = false; break; + case Op::OpTensorReadARM: *hasResult = true; *hasResultType = true; break; + case Op::OpTensorWriteARM: *hasResult = false; *hasResultType = false; break; + case Op::OpTensorQuerySizeARM: *hasResult = true; *hasResultType = true; break; case Op::OpTerminateInvocation: *hasResult = false; *hasResultType = false; break; case Op::OpTypeUntypedPointerKHR: *hasResult = true; *hasResultType = false; break; case Op::OpUntypedVariableKHR: *hasResult = true; *hasResultType = true; break; @@ -2777,10 +2808,14 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case Op::OpImageBoxFilterQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpImageBlockMatchSSDQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpImageBlockMatchSADQCOM: *hasResult = true; *hasResultType = true; break; + case Op::OpBitCastArrayQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpImageBlockMatchWindowSSDQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpImageBlockMatchWindowSADQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpImageBlockMatchGatherSSDQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpImageBlockMatchGatherSADQCOM: *hasResult = true; *hasResultType = true; break; + case Op::OpCompositeConstructCoopMatQCOM: *hasResult = true; *hasResultType = true; break; + case Op::OpCompositeExtractCoopMatQCOM: *hasResult = true; *hasResultType = true; break; + case Op::OpExtractSubArrayQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; case Op::OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; case Op::OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; @@ -3596,6 +3631,7 @@ inline const char* DecorationToString(Decoration value) { case Decoration::MaxByteOffset: return "MaxByteOffset"; case Decoration::AlignmentId: return "AlignmentId"; case Decoration::MaxByteOffsetId: return "MaxByteOffsetId"; + case Decoration::SaturatedToLargestFloat8NormalConversionEXT: return "SaturatedToLargestFloat8NormalConversionEXT"; case Decoration::NoSignedWrap: return "NoSignedWrap"; case Decoration::NoUnsignedWrap: return "NoUnsignedWrap"; case Decoration::WeightTextureQCOM: return "WeightTextureQCOM"; @@ -3938,7 +3974,10 @@ inline const char* CapabilityToString(Capability value) { case Capability::TileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT"; case Capability::TileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT"; case Capability::TileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT"; + case Capability::TensorsARM: return "TensorsARM"; case Capability::CooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM"; + case Capability::Float8EXT: return "Float8EXT"; + case Capability::Float8CooperativeMatrixEXT: return "Float8CooperativeMatrixEXT"; case Capability::FragmentShadingRateKHR: return "FragmentShadingRateKHR"; case Capability::SubgroupBallotKHR: return "SubgroupBallotKHR"; case Capability::DrawParameters: return "DrawParameters"; @@ -3973,6 +4012,7 @@ inline const char* CapabilityToString(Capability value) { case Capability::TextureBoxFilterQCOM: return "TextureBoxFilterQCOM"; case Capability::TextureBlockMatchQCOM: return "TextureBlockMatchQCOM"; case Capability::TileShadingQCOM: return "TileShadingQCOM"; + case Capability::CooperativeMatrixConversionQCOM: return "CooperativeMatrixConversionQCOM"; case Capability::TextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM"; case Capability::Float16ImageAMD: return "Float16ImageAMD"; case Capability::ImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; @@ -4277,6 +4317,8 @@ inline const char* NamedMaximumNumberOfRegistersToString(NamedMaximumNumberOfReg inline const char* FPEncodingToString(FPEncoding value) { switch (value) { case FPEncoding::BFloat16KHR: return "BFloat16KHR"; + case FPEncoding::Float8E4M3EXT: return "Float8E4M3EXT"; + case FPEncoding::Float8E5M2EXT: return "Float8E5M2EXT"; default: return "Unknown"; } } @@ -4661,6 +4703,10 @@ inline const char* OpToString(Op value) { case Op::OpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT"; case Op::OpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT"; case Op::OpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT"; + case Op::OpTypeTensorARM: return "OpTypeTensorARM"; + case Op::OpTensorReadARM: return "OpTensorReadARM"; + case Op::OpTensorWriteARM: return "OpTensorWriteARM"; + case Op::OpTensorQuerySizeARM: return "OpTensorQuerySizeARM"; case Op::OpTerminateInvocation: return "OpTerminateInvocation"; case Op::OpTypeUntypedPointerKHR: return "OpTypeUntypedPointerKHR"; case Op::OpUntypedVariableKHR: return "OpUntypedVariableKHR"; @@ -4708,10 +4754,14 @@ inline const char* OpToString(Op value) { case Op::OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM"; case Op::OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM"; case Op::OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM"; + case Op::OpBitCastArrayQCOM: return "OpBitCastArrayQCOM"; case Op::OpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM"; case Op::OpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM"; case Op::OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM"; case Op::OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM"; + case Op::OpCompositeConstructCoopMatQCOM: return "OpCompositeConstructCoopMatQCOM"; + case Op::OpCompositeExtractCoopMatQCOM: return "OpCompositeExtractCoopMatQCOM"; + case Op::OpExtractSubArrayQCOM: return "OpExtractSubArrayQCOM"; case Op::OpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD"; case Op::OpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD"; case Op::OpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD"; @@ -5161,6 +5211,10 @@ constexpr TensorAddressingOperandsMask operator|(TensorAddressingOperandsMask a, constexpr TensorAddressingOperandsMask operator&(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) & unsigned(b)); } constexpr TensorAddressingOperandsMask operator^(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) ^ unsigned(b)); } constexpr TensorAddressingOperandsMask operator~(TensorAddressingOperandsMask a) { return TensorAddressingOperandsMask(~unsigned(a)); } +constexpr TensorOperandsMask operator|(TensorOperandsMask a, TensorOperandsMask b) { return TensorOperandsMask(unsigned(a) | unsigned(b)); } +constexpr TensorOperandsMask operator&(TensorOperandsMask a, TensorOperandsMask b) { return TensorOperandsMask(unsigned(a) & unsigned(b)); } +constexpr TensorOperandsMask operator^(TensorOperandsMask a, TensorOperandsMask b) { return TensorOperandsMask(unsigned(a) ^ unsigned(b)); } +constexpr TensorOperandsMask operator~(TensorOperandsMask a) { return TensorOperandsMask(~unsigned(a)); } constexpr MatrixMultiplyAccumulateOperandsMask operator|(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) | unsigned(b)); } constexpr MatrixMultiplyAccumulateOperandsMask operator&(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) & unsigned(b)); } constexpr MatrixMultiplyAccumulateOperandsMask operator^(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) ^ unsigned(b)); } diff --git a/libs/bgfx/3rdparty/glslang/StandAlone/StandAlone.cpp b/libs/bgfx/3rdparty/glslang/StandAlone/StandAlone.cpp index b1853b0..be7f442 100644 --- a/libs/bgfx/3rdparty/glslang/StandAlone/StandAlone.cpp +++ b/libs/bgfx/3rdparty/glslang/StandAlone/StandAlone.cpp @@ -815,6 +815,14 @@ void ProcessArguments(std::vector>& workItem lowerword == "shift-ssbo-binding" || lowerword == "sbb") { ProcessBindingBase(argc, argv, glslang::EResSsbo); + } else if (lowerword == "shift-combined-sampler-bindings" || + lowerword == "shift-combined-sampler-binding" || + lowerword == "scsb") { + ProcessBindingBase(argc, argv, glslang::EResCombinedSampler); + } else if (lowerword == "shift-as-bindings" || + lowerword == "shift-as-binding" || + lowerword == "sab") { + ProcessBindingBase(argc, argv, glslang::EResAs); } else if (lowerword == "source-entrypoint" || // synonyms lowerword == "sep") { if (argc <= 1) @@ -874,7 +882,7 @@ void ProcessArguments(std::vector>& workItem TargetVersion = glslang::EShTargetSpv_1_6; } else Error("--target-env expected one of: vulkan1.0, vulkan1.1, vulkan1.2,\n" - "vulkan1.3, opengl, spirv1.0, spirv1.1, spirv1.2, spirv1.3,\n" + "vulkan1.3, vulkan1.4, opengl, spirv1.0, spirv1.1, spirv1.2, spirv1.3,\n" "spirv1.4, spirv1.5 or spirv1.6"); } bumpArg(); @@ -1972,47 +1980,45 @@ void usage() " rcall for a ray callable shader\n" "2) ..glsl or ..hlsl compound suffix, where stage options are\n" " described above\n" - "3) .conf, to provide a config file that replaces the default configuration\n" - " (see -c option below for generating a template)\n" + "3) .conf, to provide a config file that replaces the default configuration (see\n" + " -c option below for generating a template)\n" "\n" "Options:\n" " -C cascading errors; risk crash from accumulation of error recoveries\n" " -D input is HLSL (this is the default when any suffix is .hlsl)\n" - " -D | --define-macro | --D \n" + " -D | --D | --define-macro \n" " define a pre-processor macro\n" - " -E print pre-processed GLSL; cannot be used with -l;\n" - " errors will appear on stderr\n" - " -G[ver] create SPIR-V binary, under OpenGL semantics; turns on -l;\n" - " default file name is .spv (-o overrides this);\n" - " 'ver', when present, is the version of the input semantics,\n" - " which will appear in #define GL_SPIRV ver;\n" - " '--client opengl100' is the same as -G100;\n" - " a '--target-env' for OpenGL will also imply '-G';\n" - " currently only supports GLSL\n" + " -E print pre-processed GLSL; cannot be used with -l; errors will\n" + " appear on stderr\n" + " -G[ver] create SPIR-V binary under OpenGL semantics; turns on -l; default\n" + " file name is .spv (-o overrides this); ver, when present,\n" + " is the version of the input semantics which will appear in\n" + " '#define GL_SPIRV ver'; --client opengl100 is the same as -G100; a\n" + " --target-env for OpenGL will also imply -G; currently only\n" + " supports GLSL\n" " -H print human readable form of SPIR-V; turns on -V\n" - " -I add dir to the include search path; includer's directory\n" - " is searched first, followed by left-to-right order of -I\n" + " -I add to the include search path; includer's directory is\n" + " searched first, followed by left-to-right order of -I\n" " -Od disables optimization; may cause illegal SPIR-V for HLSL\n" " -Os optimizes SPIR-V to minimize size\n" - " -P | --preamble-text | --P \n" - " inject custom preamble text, which is treated as if it\n" - " appeared immediately after the version declaration (if any).\n" + " -P | --P | --preamble-text \n" + " inject custom preamble text which is treated as if it appeared\n" + " immediately after the version declaration (if any)\n" " -R use relaxed verification rules for generating Vulkan SPIR-V,\n" - " allowing the use of default uniforms, atomic_uints, and\n" - " gl_VertexID and gl_InstanceID keywords.\n" - " -S uses specified stage rather than parsing the file extension\n" - " choices for include vert, tesc, tese, geom, frag, comp.\n" - " A full list of options is given above." + " allowing the use of default uniforms, atomic_uints, and the\n" + " gl_VertexID and gl_InstanceID keywords\n" + " -S uses the specified rather than parsing the file extension;\n" + " choices for include vert, tesc, tese, geom, frag, and\n" + " comp; a full list of options is given above\n" " -U | --undef-macro | --U \n" " undefine a pre-processor macro\n" - " -V[ver] create SPIR-V binary, under Vulkan semantics; turns on -l;\n" - " default file name is .spv (-o overrides this)\n" - " 'ver', when present, is the version of the input semantics,\n" - " which will appear in #define VULKAN ver\n" - " '--client vulkan100' is the same as -V100\n" - " a '--target-env' for Vulkan will also imply '-V'\n" - " -c configuration dump;\n" - " creates the default configuration file (redirect to a .conf file)\n" + " -V[ver] create SPIR-V binary under Vulkan semantics; turns on -l; default\n" + " file name is .spv (-o overrides this); ver, when present,\n" + " is the version of the input semantics which will appear in\n" + " '#define VULKAN ver'; --client vulkan100 is the same as -V100; a\n" + " '--target-env' for Vulkan will also imply '-V'\n" + " -c configuration dump; creates the default configuration file\n" + " (redirect to a .conf file)\n" " -d default to desktop (#version 110) when there is no shader #version\n" " (default is ES version 100)\n" " -e | --entry-point \n" @@ -2024,148 +2030,170 @@ void usage() " -g0 strip debug information\n" " -gV generate nonsemantic shader debug information\n" " -gVS generate nonsemantic shader debug information with source\n" - " -h print this usage message\n" + " -h | --help print this usage message\n" " -i intermediate tree (glslang AST) is printed out\n" " -l link all input files together to form a single module\n" " -m memory leak mode\n" - " -o save binary to , requires a binary option (e.g., -V)\n" + " -o save binary to ; requires a binary option (e.g., -V)\n" " -q dump reflection query database; requires -l for linking\n" " -r | --relaxed-errors\n" " relaxed GLSL semantic error-checking mode\n" " -s silence syntax and semantic error reporting\n" " -t multi-threaded mode\n" + " -u:\n" + " specify a uniform location override for --aml\n" " -v | --version\n" " print version strings\n" " -w | --suppress-warnings\n" - " suppress GLSL warnings, except as required by \"#extension : warn\"\n" + " suppress GLSL warnings, except as required by '#extension : warn'\n" " -x save binary output as text-based 32-bit hexadecimal numbers\n" - " -u: specify a uniform location override for --aml\n" - " --uniform-base set a base to use for generated uniform locations\n" - " --auto-map-bindings | --amb automatically bind uniform variables\n" - " without explicit bindings\n" + " --absolute-path prints absolute path for messages\n" + " --auto-map-binding | --auto-map-bindings | --amb\n" + " automatically bind uniform variables without\n" + " explicit bindings\n" " --auto-map-locations | --aml automatically locate input/output lacking\n" " 'location' (fragile, not cross stage)\n" - " --absolute-path Prints absolute path for messages\n" - " --auto-sampled-textures Removes sampler variables and converts\n" + " --auto-sampled-textures removes sampler variables and converts\n" " existing textures to sampled textures\n" - " --client {vulkan|opengl} see -V and -G\n" + " --client {vulkan | opengl}\n" + " see -V and -G\n" " --depfile writes depfile for build systems\n" - " --dump-builtin-symbols prints builtin symbol table prior each compile\n" + " --dump-builtin-symbols prints builtin symbol table prior each\n" + " compile\n" " -dumpfullversion | -dumpversion print bare major.minor.patchlevel\n" - " --flatten-uniform-arrays | --fua flatten uniform texture/sampler arrays to\n" + " --enhanced-msgs print more readable error messages (GLSL\n" + " only)\n" + " --error-column display the column of the error along the\n" + " line\n" + " --flatten-uniform-array | --flatten-uniform-arrays | --fua\n" + " flatten uniform texture/sampler arrays to\n" " scalars\n" " --glsl-version {100 | 110 | 120 | 130 | 140 | 150 |\n" - " 300es | 310es | 320es | 330\n" + " 300es | 310es | 320es | 330 |\n" " 400 | 410 | 420 | 430 | 440 | 450 | 460}\n" - " set GLSL version, overrides #version\n" - " in shader source\n" - " --hlsl-offsets allow block offsets to follow HLSL rules\n" - " works independently of source language\n" - " --hlsl-iomap perform IO mapping in HLSL register space\n" - " --hlsl-enable-16bit-types allow 16-bit types in SPIR-V for HLSL\n" + " set GLSL version; overrides #version in\n" + " shader source\n" + " --hlsl-dx-position-w W component of SV_Position in HLSL fragment\n" + " shaders compatible with DirectX\n" " --hlsl-dx9-compatible interprets sampler declarations as a\n" " texture/sampler combo like DirectX9 would,\n" " and recognizes DirectX9-specific semantics\n" - " --hlsl-dx-position-w W component of SV_Position in HLSL fragment\n" - " shaders compatible with DirectX\n" + " --hlsl-enable-16bit-types allow 16-bit types in SPIR-V for HLSL\n" + " --hlsl-iomap | --hlsl-iomapper | --hlsl-iomapping\n" + " perform IO mapping in HLSL register space\n" + " --hlsl-offsets allow block offsets to follow HLSL rules;\n" + " works independently of source language\n" " --invert-y | --iy invert position.Y output in vertex shader\n" - " --enhanced-msgs print more readable error messages (GLSL only)\n" - " --error-column display the column of the error along the line\n" " --keep-uncalled | --ku don't eliminate uncalled functions\n" + " --lto perform link time optimization\n" " --nan-clamp favor non-NaN operand in min, max, and clamp\n" + " --no-link only compile shader; do not link (GLSL only)\n" + " NOTE: this option will set the export\n" + " linkage attribute on all functions\n" " --no-storage-format | --nsf use Unknown image format\n" - " --quiet do not print anything to stdout, unless\n" + " --quiet do not print anything to stdout unless\n" " requested by another option\n" - " --reflect-strict-array-suffix use strict array suffix rules when\n" - " reflecting\n" + " --reflect-all-block-variables reflect all variables in blocks, whether\n" + " inactive or active\n" " --reflect-basic-array-suffix arrays of basic types will have trailing [0]\n" " --reflect-intermediate-io reflection includes inputs/outputs of linked\n" " shaders rather than just vertex/fragment\n" " --reflect-separate-buffers reflect buffer variables and blocks\n" " separately to uniforms\n" - " --reflect-all-block-variables reflect all variables in blocks, whether\n" - " inactive or active\n" + " --reflect-strict-array-suffix use strict array suffix rules when\n" + " reflecting\n" " --reflect-unwrap-io-blocks unwrap input/output blocks the same as\n" " uniform blocks\n" - " --resource-set-binding [stage] name set binding\n" + " --resource-set-binding [name] [binding]...\n" " set descriptor set and binding for\n" " individual resources\n" - " --resource-set-binding [stage] set\n" + " --resource-set-binding [stage] \n" " set descriptor set for all resources\n" - " --rsb synonym for --resource-set-binding\n" - " --set-block-backing name {uniform|buffer|push_constant}\n" - " changes the backing type of a uniform, buffer,\n" - " or push_constant block declared in\n" - " in the program, when using -R option.\n" - " This can be used to change the backing\n" - " for existing blocks as well as implicit ones\n" - " such as 'gl_DefaultUniformBlock'.\n" - " --sbs synonym for set-block-storage\n" - " --set-atomic-counter-block name set\n" - " set name, and descriptor set for\n" - " atomic counter blocks, with -R opt\n" + " --resource-set-bindings | --rsb synonyms for --resource-set-binding\n" + " --set-atomic-counter-block \n" + " set name and descriptor set for atomic\n" + " counter blocks with -R opt\n" " --sacb synonym for set-atomic-counter-block\n" - " --set-default-uniform-block name set binding\n" + " --set-block-backing name {uniform | buffer | push_constant}\n" + " changes the backing type of a uniform,\n" + " buffer, or push_constant block declared in\n" + " the program when using the -R option; this\n" + " can be used to change the backing for\n" + " existing blocks as well as implicit ones\n" + " such as 'gl_DefaultUniformBlock'\n" + " --set-default-uniform-block \n" " set name, descriptor set, and binding for\n" - " global default-uniform-block, with -R opt\n" + " global default-uniform-block with -R opt\n" " --sdub synonym for set-default-uniform-block\n" - " --shift-image-binding [stage] num\n" - " base binding number for images (uav)\n" - " --shift-image-binding [stage] [num set]...\n" + " --shift-image-binding [stage] \n" + " base binding number for images (UAV)\n" + " --shift-image-binding [stage] ...\n" " per-descriptor-set shift values\n" - " --sib synonym for --shift-image-binding\n" - " --shift-sampler-binding [stage] num\n" + " --shift-image-bindings | --sib synonyms for --shift-image-binding\n" + " --shift-sampler-binding [stage] \n" " base binding number for samplers\n" - " --shift-sampler-binding [stage] [num set]...\n" + " --shift-sampler-binding [stage] ...\n" " per-descriptor-set shift values\n" - " --ssb synonym for --shift-sampler-binding\n" - " --shift-ssbo-binding [stage] num base binding number for SSBOs\n" - " --shift-ssbo-binding [stage] [num set]...\n" + " --shift-sampler-bindings | --ssb synonyms for --shift-sampler-binding\n" + " --shift-ssbo-binding [stage] \n" + " base binding number for SSBOs\n" + " --shift-ssbo-binding [stage] ...\n" " per-descriptor-set shift values\n" - " --sbb synonym for --shift-ssbo-binding\n" - " --shift-texture-binding [stage] num\n" + " --shift-ssbo-bindings | --sbb synonyms for --shift-ssbo-binding\n" + " --shift-texture-binding [stage] \n" " base binding number for textures\n" - " --shift-texture-binding [stage] [num set]...\n" + " --shift-texture-binding [stage] ...\n" + " per-descriptor-set shift values\n" + " --shift-texture-bindings | --stb synonyms for --shift-texture-binding\n" + " --shift-uav-binding [stage] base binding number for UAVs\n" + " --shift-uav-binding [stage] ...\n" " per-descriptor-set shift values\n" - " --stb synonym for --shift-texture-binding\n" - " --shift-uav-binding [stage] num base binding number for UAVs\n" - " --shift-uav-binding [stage] [num set]...\n" + " --shift-uav-bindings | --suavb synonyms for --shift-uav-binding\n" + " --shift-ubo-binding [stage] base binding number for UBOs\n" + " --shift-ubo-binding [stage] ...\n" " per-descriptor-set shift values\n" - " --suavb synonym for --shift-uav-binding\n" - " --shift-UBO-binding [stage] num base binding number for UBOs\n" - " --shift-UBO-binding [stage] [num set]...\n" + " --shift-ubo-bindings | --sub |\n" + " --shift-cbuffer-binding | --shift-cbuffer-bindings | --scb\n" + " synonyms for --shift-ubo-binding\n" + " --shift-combined-sampler-binding [stage] \n" + " base binding number for combined samplers\n" + " --shift-combined-sampler-binding [stage] ...\n" " per-descriptor-set shift values\n" - " --sub synonym for --shift-UBO-binding\n" - " --shift-cbuffer-binding | --scb synonyms for --shift-UBO-binding\n" + " --shift-combined-sampler-bindings | --scsb\n" + " synonyms for --shift-combined-sampler-binding\n" + " --shift-as-binding [stage] \n" + " base binding number for acceleration structures\n" + " --shift-as-binding [stage] ...\n" + " per-descriptor-set shift values\n" + " --shift-as-bindings | --sab\n" + " synonyms for --shift-as-binding\n" " --spirv-dis output standard-form disassembly; works only\n" " when a SPIR-V generation option is also used\n" " --spirv-val execute the SPIRV-Tools validator\n" - " --source-entrypoint the given shader source function is\n" - " renamed to be the given in -e\n" - " --sep synonym for --source-entrypoint\n" + " --source-entrypoint | --sep \n" + " the given shader source function is renamed\n" + " to be the given in -e\n" " --stdin read from stdin instead of from a file;\n" " requires providing the shader stage using -S\n" - " --target-env {vulkan1.0 | vulkan1.1 | vulkan1.2 | vulkan1.3 | opengl |\n" - " spirv1.0 | spirv1.1 | spirv1.2 | spirv1.3 | spirv1.4 |\n" - " spirv1.5 | spirv1.6}\n" - " Set the execution environment that the\n" - " generated code will be executed in.\n" - " Defaults to:\n" + " --target-env {vulkan1.0 | vulkan1.1 | vulkan1.2 | vulkan1.3 | vulkan1.4 |\n" + " opengl | spirv1.0 | spirv1.1 | spirv1.2 | spirv1.3 |\n" + " spirv1.4 | spirv1.5 | spirv1.6}\n" + " set the execution environment the generated\n" + " code will be executed in; defaults to:\n" " * vulkan1.0 under --client vulkan\n" " * opengl under --client opengl\n" " * spirv1.0 under --target-env vulkan1.0\n" " * spirv1.3 under --target-env vulkan1.1\n" " * spirv1.5 under --target-env vulkan1.2\n" " * spirv1.6 under --target-env vulkan1.3\n" - " Multiple --target-env can be specified.\n" - " --variable-name \n" - " --vn creates a C header file that contains a\n" - " uint32_t array named \n" - " initialized with the shader binary code\n" - " --no-link Only compile shader; do not link (GLSL-only)\n" - " NOTE: this option will set the export linkage\n" - " attribute on all functions\n" - " --lto perform link time optimization\n" + " * spirv1.6 under --target-env vulkan1.4\n" + " multiple --target-env can be specified\n" + " --uniform-base set a base to use for generated uniform\n" + " locations\n" + " --variable-name | --vn \n" + " creates a C header file that contains a\n" + " uint32_t array named initialized with\n" + " the shader binary code\n" " --validate-io validate cross stage IO\n"); exit(EFailUsage); diff --git a/libs/bgfx/3rdparty/glslang/build_info.h b/libs/bgfx/3rdparty/glslang/build_info.h index f78ec2a..d8f2a74 100644 --- a/libs/bgfx/3rdparty/glslang/build_info.h +++ b/libs/bgfx/3rdparty/glslang/build_info.h @@ -34,8 +34,8 @@ #ifndef GLSLANG_BUILD_INFO #define GLSLANG_BUILD_INFO -#define GLSLANG_VERSION_MAJOR 15 -#define GLSLANG_VERSION_MINOR 3 +#define GLSLANG_VERSION_MAJOR 16 +#define GLSLANG_VERSION_MINOR 0 #define GLSLANG_VERSION_PATCH 0 #define GLSLANG_VERSION_FLAVOR "" diff --git a/libs/bgfx/3rdparty/glslang/glslang/CInterface/glslang_c_interface.cpp b/libs/bgfx/3rdparty/glslang/glslang/CInterface/glslang_c_interface.cpp index d391c1d..72841c1 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/CInterface/glslang_c_interface.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/CInterface/glslang_c_interface.cpp @@ -351,6 +351,14 @@ GLSLANG_EXPORT void glslang_shader_set_preamble(glslang_shader_t* shader, const shader->shader->setPreamble(s); } +GLSLANG_EXPORT void glslang_shader_set_entry_point(glslang_shader_t* shader, const char* s) { + shader->shader->setEntryPoint(s); +} + +GLSLANG_EXPORT void glslang_shader_set_invert_y(glslang_shader_t* shader, bool y) { + shader->shader->setInvertY(y); +} + GLSLANG_EXPORT void glslang_shader_shift_binding(glslang_shader_t* shader, glslang_resource_type_t res, unsigned int base) { const glslang::TResourceType res_type = glslang::TResourceType(res); diff --git a/libs/bgfx/3rdparty/glslang/glslang/Include/BaseTypes.h b/libs/bgfx/3rdparty/glslang/glslang/Include/BaseTypes.h index a33ab3f..f0c8714 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/Include/BaseTypes.h +++ b/libs/bgfx/3rdparty/glslang/glslang/Include/BaseTypes.h @@ -50,6 +50,8 @@ enum TBasicType { EbtDouble, EbtFloat16, EbtBFloat16, + EbtFloatE5M2, + EbtFloatE4M3, EbtInt8, EbtUint8, EbtInt16, @@ -72,6 +74,7 @@ enum TBasicType { EbtTensorLayoutNV, EbtTensorViewNV, EbtCoopvecNV, + EbtTensorARM, // SPIR-V type defined by spirv_type EbtSpirvType, @@ -609,6 +612,8 @@ __inline bool isTypeFloat(TBasicType type) case EbtDouble: case EbtFloat16: case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: return true; default: return false; @@ -620,6 +625,8 @@ __inline uint32_t GetNumBits(TBasicType type) switch (type) { case EbtInt8: case EbtUint8: + case EbtFloatE5M2: + case EbtFloatE4M3: return 8; case EbtBFloat16: case EbtFloat16: diff --git a/libs/bgfx/3rdparty/glslang/glslang/Include/ConstantUnion.h b/libs/bgfx/3rdparty/glslang/glslang/Include/ConstantUnion.h index da4737b..bf6b8a8 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/Include/ConstantUnion.h +++ b/libs/bgfx/3rdparty/glslang/glslang/Include/ConstantUnion.h @@ -899,6 +899,17 @@ class TConstUnionArray { unionArray = new TConstUnionVector(size, val); } + TConstUnionArray* clone() const + { + TConstUnionArray *copy = new TConstUnionArray(size()); + if (unionArray) { + for (const auto i : *unionArray) { + copy->unionArray->push_back(i); + } + } + return copy; + } + int size() const { return unionArray ? (int)unionArray->size() : 0; } TConstUnion& operator[](size_t index) { return (*unionArray)[index]; } const TConstUnion& operator[](size_t index) const { return (*unionArray)[index]; } diff --git a/libs/bgfx/3rdparty/glslang/glslang/Include/PoolAlloc.h b/libs/bgfx/3rdparty/glslang/glslang/Include/PoolAlloc.h index 8a92841..6b6dfd6 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/Include/PoolAlloc.h +++ b/libs/bgfx/3rdparty/glslang/glslang/Include/PoolAlloc.h @@ -292,8 +292,7 @@ class pool_allocator { template pool_allocator(const pool_allocator& p) : allocator(p.getAllocator()) { } - - GLSLANG_EXPORT_FOR_TESTS + pointer allocate(size_type n) { return reinterpret_cast(getAllocator().allocate(n * sizeof(T))); } pointer allocate(size_type n, const void*) { diff --git a/libs/bgfx/3rdparty/glslang/glslang/Include/Types.h b/libs/bgfx/3rdparty/glslang/glslang/Include/Types.h index d6841bb..faada17 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/Include/Types.h +++ b/libs/bgfx/3rdparty/glslang/glslang/Include/Types.h @@ -252,6 +252,8 @@ struct TSampler { // misnomer now; includes images, textures without sampler, case EbtUint: s.append("u"); break; case EbtFloat16: s.append("f16"); break; case EbtBFloat16: s.append("bf16"); break; + case EbtFloatE5M2: s.append("fe5m2"); break; + case EbtFloatE4M3: s.append("fe4m3"); break; case EbtInt8: s.append("i8"); break; case EbtUint16: s.append("u8"); break; case EbtInt16: s.append("i16"); break; @@ -1500,6 +1502,7 @@ class TPublicType { bool coopmatKHR : 1; bool coopvecNV : 1; bool tileAttachmentQCOM: 1; + uint32_t tensorRankARM : 4; TArraySizes* arraySizes; const TType* userDef; TSourceLoc loc; @@ -1511,7 +1514,8 @@ class TPublicType { bool isCoopmatNV() const { return coopmatNV; } bool isCoopmatKHR() const { return coopmatKHR; } bool isCoopvecNV() const { return coopvecNV; } - bool isCoopmatOrvec() const { return isCoopmat() || isCoopvecNV(); } + bool isTensorARM() const { return tensorRankARM; } + bool hasTypeParameter() const { return isCoopmat() || isCoopvecNV() || isTensorARM(); } bool isTensorLayoutNV() const { return basicType == EbtTensorLayoutNV; } bool isTensorViewNV() const { return basicType == EbtTensorViewNV; } @@ -1530,6 +1534,7 @@ class TPublicType { coopmatKHR = false; coopvecNV = false; tileAttachmentQCOM = false; + tensorRankARM = 0; spirvType = nullptr; } @@ -1590,7 +1595,7 @@ class TType { explicit TType(TBasicType t = EbtVoid, TStorageQualifier q = EvqTemporary, int vs = 1, int mc = 0, int mr = 0, bool isVector = false) : basicType(t), vectorSize(static_cast(vs) & 0b1111), matrixCols(static_cast(mc) & 0b1111), matrixRows(static_cast(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), - tileAttachmentQCOM(false), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr), + tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr), spirvType(nullptr) { assert(vs >= 0); @@ -1606,7 +1611,7 @@ class TType { TType(TBasicType t, TStorageQualifier q, TPrecisionQualifier p, int vs = 1, int mc = 0, int mr = 0, bool isVector = false) : basicType(t), vectorSize(static_cast(vs) & 0b1111), matrixCols(static_cast(mc) & 0b1111), matrixRows(static_cast(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), - tileAttachmentQCOM(false), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr), + tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr), spirvType(nullptr) { assert(vs >= 0); @@ -1624,7 +1629,7 @@ class TType { explicit TType(const TPublicType& p) : basicType(p.basicType), vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false), coopmatNV(p.coopmatNV), coopmatKHR(p.coopmatKHR), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(p.coopvecNV), - tileAttachmentQCOM(p.tileAttachmentQCOM), arraySizes(p.arraySizes), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(p.typeParameters), + tileAttachmentQCOM(p.tileAttachmentQCOM), tensorRankARM(p.tensorRankARM), arraySizes(p.arraySizes), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(p.typeParameters), spirvType(p.spirvType) { if (basicType == EbtSampler) @@ -1677,11 +1682,17 @@ class TType { if (p.isCoopvecNV() && p.typeParameters) { basicType = p.typeParameters->basicType; } + if (p.isTensorARM() && p.typeParameters) { + basicType = p.typeParameters->basicType; + if (p.typeParameters->arraySizes->getNumDims() > 0) { + tensorRankARM = static_cast(p.typeParameters->arraySizes->getDimSize(0)) & 0b1111; + } + } } // for construction of sampler types TType(const TSampler& sampler, TStorageQualifier q = EvqUniform, TArraySizes* as = nullptr) : basicType(EbtSampler), vectorSize(1u), matrixCols(0u), matrixRows(0u), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), - tileAttachmentQCOM(false), arraySizes(as), structure(nullptr), fieldName(nullptr), typeName(nullptr), + tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(as), structure(nullptr), fieldName(nullptr), typeName(nullptr), sampler(sampler), typeParameters(nullptr), spirvType(nullptr) { qualifier.clear(); @@ -1739,7 +1750,7 @@ class TType { // for making structures, ... TType(TTypeList* userDef, const TString& n) : basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), - tileAttachmentQCOM(false), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr), + tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr), spirvType(nullptr) { sampler.clear(); @@ -1749,7 +1760,7 @@ class TType { // For interface blocks TType(TTypeList* userDef, const TString& n, const TQualifier& q) : basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false), - tileAttachmentQCOM(false), qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr), + tileAttachmentQCOM(false), tensorRankARM(0), qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr), spirvType(nullptr) { sampler.clear(); @@ -1758,7 +1769,7 @@ class TType { // for block reference (first parameter must be EbtReference) explicit TType(TBasicType t, const TType &p, const TString& n) : basicType(t), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), - tileAttachmentQCOM(false), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr), + tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr), spirvType(nullptr) { assert(t == EbtReference); @@ -1798,6 +1809,7 @@ class TType { coopmatKHRUseValid = copyOf.coopmatKHRUseValid; coopvecNV = copyOf.isCoopVecNV(); tileAttachmentQCOM = copyOf.tileAttachmentQCOM; + tensorRankARM = copyOf.tensorRankARM; } // Make complete copy of the whole type graph rooted at 'copyOf'. @@ -1837,6 +1849,7 @@ class TType { return *typeName; } + virtual bool hasFieldName() const { return (fieldName != nullptr); } virtual const TString& getFieldName() const { assert(fieldName); @@ -1895,7 +1908,8 @@ class TType { virtual void updateImplicitArraySize(int size) { assert(isArray()); arraySizes->updateImplicitSize(size); } virtual void setImplicitlySized(bool isImplicitSized) { arraySizes->setImplicitlySized(isImplicitSized); } virtual bool isStruct() const { return basicType == EbtStruct || basicType == EbtBlock; } - virtual bool isFloatingDomain() const { return basicType == EbtFloat || basicType == EbtDouble || basicType == EbtFloat16 || basicType == EbtBFloat16; } + virtual bool isFloatingDomain() const { return basicType == EbtFloat || basicType == EbtDouble || basicType == EbtFloat16 || + basicType == EbtBFloat16 || basicType == EbtFloatE5M2 || basicType == EbtFloatE4M3; } virtual bool isIntegerDomain() const { switch (basicType) { @@ -1916,7 +1930,9 @@ class TType { } virtual bool isOpaque() const { return basicType == EbtSampler || basicType == EbtAtomicUint || basicType == EbtAccStruct || basicType == EbtRayQuery - || basicType == EbtHitObjectNV || isTileAttachmentQCOM(); } + || basicType == EbtHitObjectNV || isTileAttachmentQCOM() + || isTensorARM(); + } virtual bool isBuiltIn() const { return getQualifier().builtIn != EbvNone; } virtual bool isAttachmentEXT() const { return basicType == EbtSampler && getSampler().isAttachmentEXT(); } @@ -1933,8 +1949,10 @@ class TType { bool isCoopMatNV() const { return coopmatNV; } bool isCoopMatKHR() const { return coopmatKHR; } bool isCoopVecNV() const { return coopvecNV; } - bool isCoopMatOrVec() const { return isCoopMat() || isCoopVecNV(); } bool isTileAttachmentQCOM() const { return tileAttachmentQCOM; } + bool isTensorARM() const { return tensorRankARM; } + bool hasTypeParameter() const { return isCoopMat() || isCoopVecNV() || isTensorARM(); } + int getTensorRankARM() const { return static_cast(tensorRankARM); } bool isReference() const { return getBasicType() == EbtReference; } bool isSpirvType() const { return getBasicType() == EbtSpirvType; } int getCoopMatKHRuse() const { return static_cast(coopmatKHRuse); } @@ -1996,6 +2014,11 @@ class TType { virtual bool containsNonOpaque() const { + if (isTensorARM()) { + // Tensors have a numerical basicType even though it is Opaque + return false; + } + const auto nonOpaque = [](const TType* t) { switch (t->basicType) { case EbtVoid: @@ -2003,6 +2026,8 @@ class TType { case EbtDouble: case EbtFloat16: case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: case EbtInt8: case EbtUint8: case EbtInt16: @@ -2039,6 +2064,10 @@ class TType { { return containsBasicType(EbtBFloat16); } + bool contains8BitFloat() const + { + return containsBasicType(EbtFloatE5M2) || containsBasicType(EbtFloatE4M3); + } bool contains64BitInt() const { return containsBasicType(EbtInt64) || containsBasicType(EbtUint64); @@ -2161,6 +2190,8 @@ class TType { case EbtDouble: return "double"; case EbtFloat16: return "float16_t"; case EbtBFloat16: return "bfloat16_t"; + case EbtFloatE5M2: return "floate5m2_t"; + case EbtFloatE4M3: return "floate4m3_t"; case EbtInt8: return "int8_t"; case EbtUint8: return "uint8_t"; case EbtInt16: return "int16_t"; @@ -2180,6 +2211,7 @@ class TType { case EbtTensorLayoutNV: return "tensorLayoutNV"; case EbtTensorViewNV: return "tensorViewNV"; case EbtCoopvecNV: return "coopvecNV"; + case EbtTensorARM: return "tensorARM"; default: return "unknown type"; } } @@ -2792,6 +2824,7 @@ class TType { isCoopMatNV() == right.isCoopMatNV() && isCoopMatKHR() == right.isCoopMatKHR() && isCoopVecNV() == right.isCoopVecNV() && + isTensorARM() == right.isTensorARM() && sameStructType(right, lpidx, rpidx) && sameReferenceType(right); } @@ -2839,8 +2872,8 @@ class TType { else rv = false; } else if (isCoopMatKHR() && right.isCoopMatKHR()) { - if (getBasicType() == EbtFloat || getBasicType() == EbtFloat16 || getBasicType() == EbtBFloat16) - rv = right.getBasicType() == EbtFloat || right.getBasicType() == EbtFloat16 || right.getBasicType() == EbtBFloat16 || right.getBasicType() == EbtCoopmat; + if (isFloatingDomain()) + rv = right.isFloatingDomain() || right.getBasicType() == EbtCoopmat; else if (getBasicType() == EbtUint || getBasicType() == EbtUint8 || getBasicType() == EbtUint16) rv = right.getBasicType() == EbtUint || right.getBasicType() == EbtUint8 || right.getBasicType() == EbtUint16 || right.getBasicType() == EbtCoopmat; else if (getBasicType() == EbtInt || getBasicType() == EbtInt8 || getBasicType() == EbtInt16) @@ -2859,9 +2892,18 @@ class TType { if (isTensorViewNV()) { return right.isTensorViewNV() && right.typeParameters == nullptr && typeParameters != nullptr; } + if (isTensorARM()) { + return right.isTensorARM() && right.typeParameters == nullptr && typeParameters != nullptr; + } + return false; } + bool sameTensorBaseTypeARM(const TType &right) const { + return (typeParameters == nullptr || right.typeParameters == nullptr || + (tensorRankARM == right.tensorRankARM && getBasicType() == right.getBasicType())); + } + bool sameCoopVecBaseType(const TType &right) const { bool rv = false; @@ -3009,6 +3051,7 @@ class TType { bool coopmatKHRUseValid : 1; // True if coopmatKHRuse has been set bool coopvecNV : 1; bool tileAttachmentQCOM : 1; + uint32_t tensorRankARM : 4; // 0 means not a tensor; non-zero indicates the tensor rank. TQualifier qualifier; TArraySizes* arraySizes; // nullptr unless an array; can be shared across types diff --git a/libs/bgfx/3rdparty/glslang/glslang/Include/glslang_c_interface.h b/libs/bgfx/3rdparty/glslang/glslang/Include/glslang_c_interface.h index 0612021..4eec55b 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/Include/glslang_c_interface.h +++ b/libs/bgfx/3rdparty/glslang/glslang/Include/glslang_c_interface.h @@ -253,6 +253,8 @@ GLSLANG_EXPORT void glslang_finalize_process(void); GLSLANG_EXPORT glslang_shader_t* glslang_shader_create(const glslang_input_t* input); GLSLANG_EXPORT void glslang_shader_delete(glslang_shader_t* shader); GLSLANG_EXPORT void glslang_shader_set_preamble(glslang_shader_t* shader, const char* s); +GLSLANG_EXPORT void glslang_shader_set_entry_point(glslang_shader_t* shader, const char* s); +GLSLANG_EXPORT void glslang_shader_set_invert_y(glslang_shader_t* shader, bool y); GLSLANG_EXPORT void glslang_shader_shift_binding(glslang_shader_t* shader, glslang_resource_type_t res, unsigned int base); GLSLANG_EXPORT void glslang_shader_shift_binding_for_set(glslang_shader_t* shader, glslang_resource_type_t res, unsigned int base, unsigned int set); GLSLANG_EXPORT void glslang_shader_set_options(glslang_shader_t* shader, int options); // glslang_shader_options_t diff --git a/libs/bgfx/3rdparty/glslang/glslang/Include/glslang_c_shader_types.h b/libs/bgfx/3rdparty/glslang/glslang/Include/glslang_c_shader_types.h index 34bfbdb..ccba2fd 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/Include/glslang_c_shader_types.h +++ b/libs/bgfx/3rdparty/glslang/glslang/Include/glslang_c_shader_types.h @@ -224,6 +224,9 @@ typedef enum { GLSLANG_RESOURCE_TYPE_UBO, GLSLANG_RESOURCE_TYPE_SSBO, GLSLANG_RESOURCE_TYPE_UAV, + GLSLANG_RESOURCE_TYPE_COMBINED_SAMPLER, + GLSLANG_RESOURCE_TYPE_AS, + GLSLANG_RESOURCE_TYPE_TENSOR, LAST_ELEMENT_MARKER(GLSLANG_RESOURCE_TYPE_COUNT), } glslang_resource_type_t; diff --git a/libs/bgfx/3rdparty/glslang/glslang/Include/intermediate.h b/libs/bgfx/3rdparty/glslang/glslang/Include/intermediate.h index 2595bb1..9508ad7 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/Include/intermediate.h +++ b/libs/bgfx/3rdparty/glslang/glslang/Include/intermediate.h @@ -479,6 +479,10 @@ enum TOperator { EOpCooperativeVectorOuterProductAccumulateNV, EOpCooperativeVectorReduceSumAccumulateNV, + EOpTensorReadARM, + EOpTensorWriteARM, + EOpTensorSizeARM, + EOpBeginInvocationInterlock, // Fragment only EOpEndInvocationInterlock, // Fragment only @@ -615,6 +619,14 @@ enum TOperator { EOpConstructBF16Vec2, EOpConstructBF16Vec3, EOpConstructBF16Vec4, + EOpConstructFloatE5M2, + EOpConstructFloatE5M2Vec2, + EOpConstructFloatE5M2Vec3, + EOpConstructFloatE5M2Vec4, + EOpConstructFloatE4M3, + EOpConstructFloatE4M3Vec2, + EOpConstructFloatE4M3Vec3, + EOpConstructFloatE4M3Vec4, EOpConstructStruct, EOpConstructTextureSampler, EOpConstructNonuniform, // expected to be transformed away, not present in final AST @@ -623,6 +635,7 @@ enum TOperator { EOpConstructCooperativeMatrixKHR, EOpConstructCooperativeVectorNV, EOpConstructAccStruct, + EOpConstructSaturated, EOpConstructGuardEnd, // @@ -972,6 +985,12 @@ enum TOperator { EOpImageBlockMatchGatherSSDQCOM, EOpImageBlockMatchGatherSADQCOM, + // Cooperative Matrix Conversion + EOpBitCastArrayQCOM, + EOpExtractSubArrayQCOM, + EOpCompositeConstructCoopMatQCOM, + EOpCompositeExtractCoopMatQCOM, + // GL_NV_cluster_acceleration_structure EOpRayQueryGetIntersectionClusterIdNV, EOpHitObjectGetClusterIdNV, @@ -1095,6 +1114,7 @@ class TIntermTyped : public TIntermNode { virtual int getVectorSize() const { return type.getVectorSize(); } virtual int getMatrixCols() const { return type.getMatrixCols(); } virtual int getMatrixRows() const { return type.getMatrixRows(); } + virtual int getTensorRankARM() const { return type.getTensorRankARM(); } virtual bool isMatrix() const { return type.isMatrix(); } virtual bool isArray() const { return type.isArray(); } virtual bool isVector() const { return type.isVector(); } diff --git a/libs/bgfx/3rdparty/glslang/glslang/Include/visibility.h b/libs/bgfx/3rdparty/glslang/glslang/Include/visibility.h index 9bb8f3f..dd32351 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/Include/visibility.h +++ b/libs/bgfx/3rdparty/glslang/glslang/Include/visibility.h @@ -51,4 +51,8 @@ // Symbols marked with this macro are only meant for public use by the test suite // and do not appear in publicly installed headers. They are not considered to be // part of the glslang library ABI. -#define GLSLANG_EXPORT_FOR_TESTS GLSLANG_EXPORT +#ifdef GLSLANG_TEST_BUILD + #define GLSLANG_EXPORT_FOR_TESTS GLSLANG_EXPORT +#else + #define GLSLANG_EXPORT_FOR_TESTS +#endif diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Constant.cpp b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Constant.cpp index b076781..d6528b7 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Constant.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Constant.cpp @@ -152,6 +152,8 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TIntermTyped* right case EbtFloat: case EbtFloat16: case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: if (rightUnionArray[i].getDConst() != 0.0) newConstArray[i].setDConst(leftUnionArray[i].getDConst() / rightUnionArray[i].getDConst()); else if (leftUnionArray[i].getDConst() > 0.0) @@ -505,6 +507,8 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType) case EbtDouble: case EbtFloat16: case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: case EbtFloat: valf = unionArray[i].getDConst(); srcType = CONV_FLOAT; @@ -554,6 +558,8 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType) case EbtDouble: case EbtFloat16: case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: case EbtFloat: dstType = CONV_FLOAT; break; @@ -625,6 +631,8 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType) case EbtDouble: case EbtFloat16: case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: case EbtFloat: newConstArray[i].setDConst(valf); break; case EbtInt8: @@ -657,6 +665,8 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType) case EbtDouble: case EbtFloat16: case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: case EbtFloat: newConstArray[i].setDConst(-unionArray[i].getDConst()); break; // Note: avoid UBSAN error regarding negating 0x80000000 case EbtInt: newConstArray[i].setIConst( @@ -950,6 +960,8 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode) switch(children[0]->getAsTyped()->getBasicType()) { case EbtFloat16: case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: case EbtFloat: case EbtDouble: newConstArray[comp].setDConst(std::min(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst())); @@ -985,6 +997,8 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode) switch(children[0]->getAsTyped()->getBasicType()) { case EbtFloat16: case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: case EbtFloat: case EbtDouble: newConstArray[comp].setDConst(std::max(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst())); @@ -1020,6 +1034,8 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode) switch(children[0]->getAsTyped()->getBasicType()) { case EbtFloat16: case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: case EbtFloat: case EbtDouble: newConstArray[comp].setDConst(std::min(std::max(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst()), diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Initialize.cpp b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Initialize.cpp index 862f4ab..6242963 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Initialize.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Initialize.cpp @@ -4025,6 +4025,47 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV "bf16vec3 uintBitsToBFloat16EXT(u16vec3 value);" "bf16vec4 uintBitsToBFloat16EXT(u16vec4 value);" + "int8_t floate5m2BitsToIntEXT(floate5m2_t value);" + "i8vec2 floate5m2BitsToIntEXT(fe5m2vec2 value);" + "i8vec3 floate5m2BitsToIntEXT(fe5m2vec3 value);" + "i8vec4 floate5m2BitsToIntEXT(fe5m2vec4 value);" + + "uint8_t floate5m2BitsToUintEXT(floate5m2_t value);" + "u8vec2 floate5m2BitsToUintEXT(fe5m2vec2 value);" + "u8vec3 floate5m2BitsToUintEXT(fe5m2vec3 value);" + "u8vec4 floate5m2BitsToUintEXT(fe5m2vec4 value);" + + "floate5m2_t intBitsToFloate5m2EXT(int8_t value);" + "fe5m2vec2 intBitsToFloate5m2EXT(i8vec2 value);" + "fe5m2vec3 intBitsToFloate5m2EXT(i8vec3 value);" + "fe5m2vec4 intBitsToFloate5m2EXT(i8vec4 value);" + + "floate5m2_t uintBitsToFloate5m2EXT(uint8_t value);" + "fe5m2vec2 uintBitsToFloate5m2EXT(u8vec2 value);" + "fe5m2vec3 uintBitsToFloate5m2EXT(u8vec3 value);" + "fe5m2vec4 uintBitsToFloate5m2EXT(u8vec4 value);" + + "int8_t floate4m3BitsToIntEXT(floate4m3_t value);" + "i8vec2 floate4m3BitsToIntEXT(fe4m3vec2 value);" + "i8vec3 floate4m3BitsToIntEXT(fe4m3vec3 value);" + "i8vec4 floate4m3BitsToIntEXT(fe4m3vec4 value);" + + "uint8_t floate4m3BitsToUintEXT(floate4m3_t value);" + "u8vec2 floate4m3BitsToUintEXT(fe4m3vec2 value);" + "u8vec3 floate4m3BitsToUintEXT(fe4m3vec3 value);" + "u8vec4 floate4m3BitsToUintEXT(fe4m3vec4 value);" + + "floate4m3_t intBitsToFloate4m3EXT(int8_t value);" + "fe4m3vec2 intBitsToFloate4m3EXT(i8vec2 value);" + "fe4m3vec3 intBitsToFloate4m3EXT(i8vec3 value);" + "fe4m3vec4 intBitsToFloate4m3EXT(i8vec4 value);" + + "floate4m3_t uintBitsToFloate4m3EXT(uint8_t value);" + "fe4m3vec2 uintBitsToFloate4m3EXT(u8vec2 value);" + "fe4m3vec3 uintBitsToFloate4m3EXT(u8vec3 value);" + "fe4m3vec4 uintBitsToFloate4m3EXT(u8vec4 value);" + + "void saturatedConvertEXT();" "\n"); } @@ -4777,6 +4818,8 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV "float", "vec2", "vec4", "float16_t", "f16vec2", "f16vec4", "bfloat16_t", "bf16vec2", "bf16vec4", + "floate5m2_t", "fe5m2vec2", "fe5m2vec4", + "floate4m3_t", "fe4m3vec2", "fe4m3vec4", "double", "dvec2", "dvec4", "int8_t", "i8vec2", "i8vec4", "int16_t", "i16vec2", "i16vec4", @@ -4841,6 +4884,31 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV "\n" ); + { + std::stringstream coopMatConvFuncs; + + const std::string eltTypes[] = {"uint32_t", "uint", "int32_t", "int", "float32_t", "float", "float16_t"}; + + for (auto srcEltTy : eltTypes) { + for (auto dstEltTy : eltTypes) { + coopMatConvFuncs << "void bitcastQCOM(" << srcEltTy.c_str() << " SrcArr[], " << dstEltTy.c_str() + << " DstArr[]);\n"; + } + } + coopMatConvFuncs << "\n"; + + for (auto eltTy : {"float32_t", "float16_t", "int8_t", "uint8_t", "uint32_t", "uint", "int32_t", "int"}) { + coopMatConvFuncs << "void vectorToCoopmatQCOM(" << eltTy << " SrcVec[], coopmat CM);\n"; + coopMatConvFuncs << "void coopmatToVectorQCOM(coopmat CM, " << eltTy << " Dstvec[]);\n"; + } + + for (auto eltTy : {"uint32_t", "uint", "int32_t", "int", "float32_t", "float", "float16_t"}) { + coopMatConvFuncs << "void extractSubArrayQCOM(" << eltTy << " arr[], uint index, " << eltTy << " subarr[]);\n"; + } + + commonBuiltins.append(coopMatConvFuncs.str().c_str()); + } + commonBuiltins.append( "tensorLayoutNV createTensorLayoutNV(uint Dim);\n" "tensorLayoutNV createTensorLayoutNV(uint Dim, uint Mode);\n" @@ -4894,6 +4962,29 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV "tensorViewNV setTensorViewClipNV(tensorViewNV v, uint clipRowOffset, uint clipRowSpan, uint clipColOffset, uint clipColSpan);\n" "\n" ); + + // GL_ARM_tensors builtins. + static const char *tensorDataTypesARM[] = { + "bool", + "int8_t", "int16_t", "int32_t", "int64_t", + "uint8_t", "uint16_t", "uint32_t", "uint64_t", + "float16_t", "float32_t", "float64_t", + }; + std::ostringstream ostream; + for (auto t : tensorDataTypesARM) { + // Scalar + ostream << "void tensorReadARM(readonly tensorARM t, uint coords[], out " + << t << " data, uint tensorOperands = 0U, ...);\n"; + ostream << "void tensorWriteARM(writeonly tensorARM t, uint coords[], " + << t << " data, uint tensorOperands = 0U, ...);\n"; + // Array + ostream << "void tensorReadARM(readonly tensorARM t, uint coords[], " + << t << " data[], uint tensorOperands = 0U, ...);\n"; + ostream << "void tensorWriteARM(writeonly tensorARM t, uint coords[], " + << t << " data[], uint tensorOperands = 0U, ...);\n"; + } + ostream << "uint tensorSizeARM(readonly writeonly tensorARM t, uint dim);\n"; + commonBuiltins.append(ostream.str()); } if (profile != EEsProfile && version >= 450) { @@ -8285,6 +8376,12 @@ void TBuiltIns::initialize(const TBuiltInResource &resources, int version, EProf snprintf(builtInConstant, maxSize, "const int gl_MaxComputeTextureImageUnits = %d;", resources.maxComputeTextureImageUnits); s.append(builtInConstant); + // GL_ARM_tensors operands. + snprintf(builtInConstant, maxSize, "const uint gl_TensorOperandsNonTemporalARM = 0x1U;"); + s.append(builtInConstant); + snprintf(builtInConstant, maxSize, "const uint gl_TensorOperandsOutOfBoundsValueARM = 0x2U;"); + s.append(builtInConstant); + s.append("\n"); } @@ -9706,6 +9803,12 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.setFunctionExtensions("setTensorViewClipNV", 1, &E_GL_NV_cooperative_matrix2); } + { + symbolTable.setFunctionExtensions("tensorReadARM", 1, &E_GL_ARM_tensors); + symbolTable.setFunctionExtensions("tensorWriteARM", 1, &E_GL_ARM_tensors); + symbolTable.setFunctionExtensions("tensorSizeARM", 1, &E_GL_ARM_tensors); + } + { symbolTable.setFunctionExtensions("coopVecMatMulNV", 1, &E_GL_NV_cooperative_vector); symbolTable.setFunctionExtensions("coopVecMatMulAddNV", 1, &E_GL_NV_cooperative_vector); @@ -9713,6 +9816,13 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.setFunctionExtensions("coopVecReduceSumAccumulateNV", 1, &E_GL_NV_cooperative_vector); } + { + symbolTable.setFunctionExtensions("bitcastQCOM", 1, &E_GL_QCOM_cooperative_matrix_conversion); + symbolTable.setFunctionExtensions("extractSubArrayQCOM", 1, &E_GL_QCOM_cooperative_matrix_conversion); + symbolTable.setFunctionExtensions("vectorToCoopmatQCOM", 1, &E_GL_QCOM_cooperative_matrix_conversion); + symbolTable.setFunctionExtensions("coopmatToVectorQCOM", 1, &E_GL_QCOM_cooperative_matrix_conversion); + } + if ((profile != EEsProfile && version >= 450) || (profile == EEsProfile && version >= 320)) { symbolTable.setFunctionExtensions("dFdx", 1, &E_GL_NV_compute_shader_derivatives); symbolTable.setFunctionExtensions("dFdy", 1, &E_GL_NV_compute_shader_derivatives); @@ -9752,6 +9862,19 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.setFunctionExtensions("bfloat16BitsToUintEXT", 1, &E_GL_EXT_bfloat16); symbolTable.setFunctionExtensions("intBitsToBFloat16EXT", 1, &E_GL_EXT_bfloat16); symbolTable.setFunctionExtensions("uintBitsToBFloat16EXT", 1, &E_GL_EXT_bfloat16); + + symbolTable.setFunctionExtensions("floate5m2BitsToIntEXT", 1, &E_GL_EXT_float_e5m2); + symbolTable.setFunctionExtensions("floate5m2BitsToUintEXT", 1, &E_GL_EXT_float_e5m2); + symbolTable.setFunctionExtensions("intBitsToFloate5m2EXT", 1, &E_GL_EXT_float_e5m2); + symbolTable.setFunctionExtensions("uintBitsToFloate5m2EXT", 1, &E_GL_EXT_float_e5m2); + + symbolTable.setFunctionExtensions("floate4m3BitsToIntEXT", 1, &E_GL_EXT_float_e4m3); + symbolTable.setFunctionExtensions("floate4m3BitsToUintEXT", 1, &E_GL_EXT_float_e4m3); + symbolTable.setFunctionExtensions("intBitsToFloate4m3EXT", 1, &E_GL_EXT_float_e4m3); + symbolTable.setFunctionExtensions("uintBitsToFloate4m3EXT", 1, &E_GL_EXT_float_e4m3); + + const char *float8exts[] = {E_GL_EXT_float_e5m2, E_GL_EXT_float_e4m3}; + symbolTable.setFunctionExtensions("saturatedConvertEXT", 2, float8exts); } // E_SPV_QCOM_tile_shading @@ -10750,6 +10873,18 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.relateToOperator("bfloat16BitsToUintEXT", EOpFloatBitsToUint); symbolTable.relateToOperator("intBitsToBFloat16EXT", EOpIntBitsToFloat); symbolTable.relateToOperator("uintBitsToBFloat16EXT", EOpUintBitsToFloat); + + symbolTable.relateToOperator("floate5m2BitsToIntEXT", EOpFloatBitsToInt); + symbolTable.relateToOperator("floate5m2BitsToUintEXT", EOpFloatBitsToUint); + symbolTable.relateToOperator("intBitsToFloate5m2EXT", EOpIntBitsToFloat); + symbolTable.relateToOperator("uintBitsToFloate5m2EXT", EOpUintBitsToFloat); + + symbolTable.relateToOperator("floate4m3BitsToIntEXT", EOpFloatBitsToInt); + symbolTable.relateToOperator("floate4m3BitsToUintEXT", EOpFloatBitsToUint); + symbolTable.relateToOperator("intBitsToFloate4m3EXT", EOpIntBitsToFloat); + symbolTable.relateToOperator("uintBitsToFloate4m3EXT", EOpUintBitsToFloat); + + symbolTable.relateToOperator("saturatedConvertEXT", EOpConstructSaturated); } // GL_KHR_shader_subgroup @@ -10997,6 +11132,15 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion symbolTable.relateToOperator("setTensorViewStrideNV", EOpTensorViewSetStrideNV); symbolTable.relateToOperator("setTensorViewClipNV", EOpTensorViewSetClipNV); + symbolTable.relateToOperator("tensorReadARM", EOpTensorReadARM); + symbolTable.relateToOperator("tensorWriteARM", EOpTensorWriteARM); + symbolTable.relateToOperator("tensorSizeARM", EOpTensorSizeARM); + + symbolTable.relateToOperator("bitcastQCOM", EOpBitCastArrayQCOM); + symbolTable.relateToOperator("extractSubArrayQCOM", EOpExtractSubArrayQCOM); + symbolTable.relateToOperator("vectorToCoopmatQCOM", EOpCompositeConstructCoopMatQCOM); + symbolTable.relateToOperator("coopmatToVectorQCOM", EOpCompositeExtractCoopMatQCOM); + if (profile != EEsProfile && version >= 460) { symbolTable.relateToOperator("fetchMicroTriangleVertexPositionNV", EOpFetchMicroTriangleVertexPositionNV); symbolTable.relateToOperator("fetchMicroTriangleVertexBarycentricNV", EOpFetchMicroTriangleVertexBarycentricNV); diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp index 638f9c1..60116ef 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp @@ -400,6 +400,8 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child, case EOpConstructDouble: newType = EbtDouble; break; case EOpConstructFloat16: newType = EbtFloat16; break; case EOpConstructBFloat16: newType = EbtBFloat16; break; + case EOpConstructFloatE4M3: newType = EbtFloatE4M3; break; + case EOpConstructFloatE5M2: newType = EbtFloatE5M2; break; default: break; // some compilers want this } @@ -430,7 +432,9 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child, case EOpConstructFloat: case EOpConstructDouble: case EOpConstructFloat16: - case EOpConstructBFloat16: { + case EOpConstructBFloat16: + case EOpConstructFloatE5M2: + case EOpConstructFloatE4M3: { TIntermUnary* unary_node = child->getAsUnaryNode(); if (unary_node != nullptr) unary_node->updatePrecision(); @@ -571,9 +575,9 @@ bool TIntermediate::isConversionAllowed(TOperator op, TIntermTyped* node) const bool TIntermediate::buildConvertOp(TBasicType dst, TBasicType src, TOperator& newOp) const { - // bfloat16_t <-> bool not supported - if ((src == EbtBFloat16 && dst == EbtBool) || - (dst == EbtBFloat16 && src == EbtBool)) { + // (bfloat16_t,fp8) <-> bool not supported + if (((src == EbtBFloat16 || src == EbtFloatE5M2 || src == EbtFloatE4M3) && dst == EbtBool) || + ((dst == EbtBFloat16 || dst == EbtFloatE5M2 || dst == EbtFloatE4M3) && src == EbtBool)) { return false; } @@ -604,12 +608,15 @@ TIntermTyped* TIntermediate::createConversion(TBasicType convertTo, TIntermTyped node->getBasicType() == EbtInt || node->getBasicType() == EbtUint || node->getBasicType() == EbtInt64 || node->getBasicType() == EbtUint64); - bool convertToFloatTypes = (convertTo == EbtFloat16 || convertTo == EbtBFloat16 || convertTo == EbtFloat || convertTo == EbtDouble); + bool convertToFloatTypes = (convertTo == EbtFloat16 || convertTo == EbtBFloat16 || convertTo == EbtFloat || convertTo == EbtDouble || + convertTo == EbtFloatE5M2 || convertTo == EbtFloatE4M3); bool convertFromFloatTypes = (node->getBasicType() == EbtFloat16 || node->getBasicType() == EbtBFloat16 || node->getBasicType() == EbtFloat || - node->getBasicType() == EbtDouble); + node->getBasicType() == EbtDouble || + node->getBasicType() == EbtFloatE5M2 || + node->getBasicType() == EbtFloatE4M3); if (((convertTo == EbtInt8 || convertTo == EbtUint8) && ! convertFromIntTypes) || ((node->getBasicType() == EbtInt8 || node->getBasicType() == EbtUint8) && ! convertToIntTypes)) { @@ -832,7 +839,8 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt // Reject implicit conversions to cooperative matrix types if (node->getType().isCoopMat() && op != EOpConstructCooperativeMatrixNV && - op != EOpConstructCooperativeMatrixKHR) + op != EOpConstructCooperativeMatrixKHR && + op != glslang::EOpCompositeConstructCoopMatQCOM) return nullptr; if (node->getType().isTensorLayoutNV() || @@ -858,12 +866,15 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt case EOpConstructDouble: case EOpConstructFloat16: case EOpConstructBFloat16: + case EOpConstructFloatE5M2: + case EOpConstructFloatE4M3: case EOpConstructInt8: case EOpConstructUint8: case EOpConstructInt16: case EOpConstructUint16: case EOpConstructInt64: case EOpConstructUint64: + case EOpConstructSaturated: break; // @@ -965,6 +976,8 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt // - at the time of this writing (14-Aug-2020), no test results are changed by this. switch (op) { case EOpConstructBFloat16: + case EOpConstructFloatE5M2: + case EOpConstructFloatE4M3: canPromoteConstant = true; break; case EOpConstructFloat16: @@ -1270,6 +1283,8 @@ bool TIntermediate::isFPPromotion(TBasicType from, TBasicType to) const if (to == EbtDouble) { switch(from) { case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: case EbtFloat16: case EbtFloat: return true; @@ -1362,7 +1377,7 @@ bool TIntermediate::isIntegralConversion(TBasicType from, TBasicType to) const bool TIntermediate::isFPConversion(TBasicType from, TBasicType to) const { - if (to == EbtFloat && (from == EbtFloat16 || from == EbtBFloat16)) { + if (to == EbtFloat && (from == EbtFloat16 || from == EbtBFloat16 || from == EbtFloatE5M2 || from == EbtFloatE4M3)) { return true; } else { return false; @@ -1517,6 +1532,8 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat (numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types) || numericFeatures.contains(TNumericFeatures::gpu_shader_half_float)); case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: return true; case EbtInt8: case EbtUint8: @@ -1540,6 +1557,8 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types) || getSource() == EShSourceHlsl; case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: return true; case EbtInt8: case EbtUint8: @@ -1610,6 +1629,18 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat case EbtInt16: case EbtUint16: return numericFeatures.contains(TNumericFeatures::gpu_shader_int16); + case EbtFloatE5M2: + case EbtFloatE4M3: + return true; + default: + break; + } + return false; + case EbtBFloat16: + switch (from) { + case EbtFloatE5M2: + case EbtFloatE4M3: + return true; default: break; } @@ -2077,6 +2108,24 @@ TOperator TIntermediate::mapTypeToConstructorOp(const TType& type) const default: break; // some compilers want this } break; + case EbtFloatE5M2: + switch (type.getVectorSize()) { + case 1: op = EOpConstructFloatE5M2; break; + case 2: op = EOpConstructFloatE5M2Vec2; break; + case 3: op = EOpConstructFloatE5M2Vec3; break; + case 4: op = EOpConstructFloatE5M2Vec4; break; + default: break; // some compilers want this + } + break; + case EbtFloatE4M3: + switch (type.getVectorSize()) { + case 1: op = EOpConstructFloatE4M3; break; + case 2: op = EOpConstructFloatE4M3Vec2; break; + case 3: op = EOpConstructFloatE4M3Vec3; break; + case 4: op = EOpConstructFloatE4M3Vec4; break; + default: break; // some compilers want this + } + break; case EbtInt8: switch(type.getVectorSize()) { case 1: op = EOpConstructInt8; break; @@ -2486,7 +2535,7 @@ TIntermConstantUnion* TIntermediate::addConstantUnion(bool b, const TSourceLoc& TIntermConstantUnion* TIntermediate::addConstantUnion(double d, TBasicType baseType, const TSourceLoc& loc, bool literal) const { - assert(baseType == EbtFloat || baseType == EbtDouble || baseType == EbtFloat16 || baseType == EbtBFloat16); + assert(baseType == EbtFloat || baseType == EbtDouble || baseType == EbtFloat16 || baseType == EbtBFloat16 || baseType == EbtFloatE5M2 || baseType == EbtFloatE4M3); if (isEsProfile() && (baseType == EbtFloat || baseType == EbtFloat16)) { int exponent = 0; @@ -3741,6 +3790,8 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC #define TO_ALL(Get) \ switch (promoteTo) { \ case EbtBFloat16: PROMOTE(setDConst, double, Get); break; \ + case EbtFloatE5M2: PROMOTE(setDConst, double, Get); break; \ + case EbtFloatE4M3: PROMOTE(setDConst, double, Get); break; \ case EbtFloat16: PROMOTE(setDConst, double, Get); break; \ case EbtFloat: PROMOTE(setDConst, double, Get); break; \ case EbtDouble: PROMOTE(setDConst, double, Get); break; \ @@ -3763,6 +3814,8 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC case EbtBool: TO_ALL(getBConst); break; case EbtFloat16: TO_ALL(getDConst); break; case EbtBFloat16: TO_ALL(getDConst); break; + case EbtFloatE5M2: TO_ALL(getDConst); break; + case EbtFloatE4M3: TO_ALL(getDConst); break; case EbtDouble: TO_ALL(getDConst); break; case EbtInt8: TO_ALL(getI8Const); break; case EbtInt16: TO_ALL(getI16Const); break; @@ -3851,12 +3904,15 @@ void TIntermediate::performTextureUpgradeAndSamplerRemovalTransformation(TInterm const char* TIntermediate::getResourceName(TResourceType res) { switch (res) { - case EResSampler: return "shift-sampler-binding"; - case EResTexture: return "shift-texture-binding"; - case EResImage: return "shift-image-binding"; - case EResUbo: return "shift-UBO-binding"; - case EResSsbo: return "shift-ssbo-binding"; - case EResUav: return "shift-uav-binding"; + case EResSampler: return "shift-sampler-binding"; + case EResTexture: return "shift-texture-binding"; + case EResImage: return "shift-image-binding"; + case EResUbo: return "shift-ubo-binding"; + case EResSsbo: return "shift-ssbo-binding"; + case EResUav: return "shift-uav-binding"; + case EResCombinedSampler: return "shift-combined-sampler-binding"; + case EResAs: return "shift-as-binding"; + case EResTensor: return nullptr; default: assert(0); // internal error: should only be called with valid resource types. return nullptr; diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ParseContextBase.cpp b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ParseContextBase.cpp index 986b941..95c7f00 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ParseContextBase.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ParseContextBase.cpp @@ -424,7 +424,7 @@ const TFunction* TParseContextBase::selectFunction( // to even be a potential match, number of arguments must be >= the number of // fixed (non-default) parameters, and <= the total (including parameter with defaults). if (call.getParamCount() < candidate.getFixedParamCount() || - call.getParamCount() > candidate.getParamCount()) + (call.getParamCount() > candidate.getParamCount() && !candidate.isVariadic())) continue; // see if arguments are convertible @@ -463,7 +463,8 @@ const TFunction* TParseContextBase::selectFunction( const auto betterParam = [&call, &better](const TFunction& can1, const TFunction& can2) -> bool { // is call -> can2 better than call -> can1 for any parameter bool hasBetterParam = false; - for (int param = 0; param < call.getParamCount(); ++param) { + const int paramCount = std::min({call.getParamCount(), can1.getParamCount(), can2.getParamCount()}); + for (int param = 0; param < paramCount; ++param) { if (better(*call[param].type, *can1[param].type, *can2[param].type)) { hasBetterParam = true; break; @@ -474,7 +475,8 @@ const TFunction* TParseContextBase::selectFunction( const auto equivalentParams = [&call, &better](const TFunction& can1, const TFunction& can2) -> bool { // is call -> can2 equivalent to call -> can1 for all the call parameters? - for (int param = 0; param < call.getParamCount(); ++param) { + const int paramCount = std::min({call.getParamCount(), can1.getParamCount(), can2.getParamCount()}); + for (int param = 0; param < paramCount; ++param) { if (better(*call[param].type, *can1[param].type, *can2[param].type) || better(*call[param].type, *can2[param].type, *can1[param].type)) return false; diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp index 8ea6e2e..b9bd764 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp @@ -912,7 +912,8 @@ TIntermTyped* TParseContext::handleBinaryMath(const TSourceLoc& loc, const char* if (((left->getType().contains16BitFloat() || right->getType().contains16BitFloat()) && !float16Arithmetic()) || ((left->getType().contains16BitInt() || right->getType().contains16BitInt()) && !int16Arithmetic()) || ((left->getType().contains8BitInt() || right->getType().contains8BitInt()) && !int8Arithmetic()) || - (left->getType().containsBFloat16() || right->getType().containsBFloat16())) { + (left->getType().containsBFloat16() || right->getType().containsBFloat16()) || + (left->getType().contains8BitFloat() || right->getType().contains8BitFloat())) { allowed = false; } @@ -940,7 +941,8 @@ TIntermTyped* TParseContext::handleUnaryMath(const TSourceLoc& loc, const char* if ((childNode->getType().contains16BitFloat() && !float16Arithmetic()) || (childNode->getType().contains16BitInt() && !int16Arithmetic()) || (childNode->getType().contains8BitInt() && !int8Arithmetic()) || - (childNode->getType().containsBFloat16())) { + (childNode->getType().containsBFloat16()) || + (childNode->getType().contains8BitFloat())) { allowed = false; } @@ -1405,6 +1407,24 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction // At this early point there is a slight ambiguity between whether an aggregate 'arguments' // is the single argument itself or its children are the arguments. Only one argument // means take 'arguments' itself as the one argument. + if ((*fnCandidate)[i].defaultValue) { + if (!aggregate) { + // Only one argument was passed (rest are default arguments) so arguments isn't a TIntermAggregate. + // But the function takes at least one more argument, so a TIntermAggregate is needed. + aggregate = new TIntermAggregate; + aggregate->getSequence().push_back(arguments); + arguments = aggregate; + } + if (i >= static_cast(aggregate->getSequence().size())) { + // Append the default value if there are no more arguments left in the aggregate. + TIntermConstantUnion *defaultValue = nullptr; + if (const auto *constUnion = (*fnCandidate)[i].defaultValue->getAsConstantUnion()) { + defaultValue = new TIntermConstantUnion(constUnion->getConstArray(), constUnion->getType()); + } + assert(defaultValue && "unsupported default value construct"); + aggregate->getSequence().push_back(defaultValue); + } + } TIntermNode* arg = fnCandidate->getParamCount() == 1 ? arguments : (aggregate ? aggregate->getSequence()[i] : arguments); TQualifier& formalQualifier = (*fnCandidate)[i].type->getQualifier(); if (formalQualifier.isParamOutput()) { @@ -1520,6 +1540,8 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction handleCoopMat2FunctionCall(loc, fnCandidate, result, arguments); + handleVector2CoopMatConversionCall(loc, fnCandidate, result, arguments); + if (result->getAsTyped()->getType().isCoopVecNV() && !result->getAsTyped()->getType().isParameterized()) { if (auto unaryNode = result->getAsUnaryNode()) @@ -1527,6 +1549,11 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction else result->setType(result->getAsAggregate()->getSequence()[0]->getAsTyped()->getType()); } + + if (fnCandidate->getBuiltInOp() == EOpConstructSaturated) { + // result type is taken from the first parameter + result->setType(result->getAsAggregate()->getSequence()[0]->getAsTyped()->getType()); + } } } @@ -1756,6 +1783,297 @@ void TParseContext::handleCoopMat2FunctionCall(const TSourceLoc& loc, const TFun } } + +static const uint32_t spv_Scope_Subgroup = 3; + +void TParseContext::handleVector2CoopMatConversionCall(const TSourceLoc& loc, const TFunction* fnCandidate, + TIntermTyped*& result, TIntermNode* arguments) +{ + const int CM_MatrixUseA = 0; // == gl_MatrixUseA + const int CM_MatrixUseB = 1; // == gl_MatrixUseB + const int CM_MatrixUseAccumulator = 2; // == gl_MatrixUseAccumulator + + TOperator builtinOp = fnCandidate->getBuiltInOp(); + + if (!(builtinOp == EOpBitCastArrayQCOM || builtinOp == EOpExtractSubArrayQCOM || + builtinOp == EOpCompositeConstructCoopMatQCOM || builtinOp == EOpCompositeExtractCoopMatQCOM)) + return; + + TPublicType pubType{}; + auto* oldResult = result; + + if (builtinOp == EOpBitCastArrayQCOM) { + auto srcArr = arguments->getAsAggregate()->getSequence()[0]->getAsTyped(); + auto& srcTy = srcArr->getType(); + auto srcArrLen = srcTy.getArraySizes()->getDimSize(0); + auto srcLenAsNode = srcTy.getArraySizes()->getDimNode(0); + + auto dstArr = arguments->getAsAggregate()->getSequence()[1]->getAsTyped(); + auto& dstTy = dstArr->getType(); + auto dstArrLen = dstTy.getArraySizes()->getDimSize(0); + auto dstLenAsNode = dstTy.getArraySizes()->getDimNode(0); + + if (srcLenAsNode == nullptr && dstLenAsNode == nullptr) { + //do basic tests: + if ((srcArrLen * GetNumBits(srcTy.getBasicType())) != (dstArrLen * GetNumBits(dstTy.getBasicType()))) + error(loc, "source and target arrays have different bit sizes", "", ""); + } + + pubType.basicType = dstTy.getBasicType(); + pubType.vectorSize = 1u; + pubType.qualifier.precision = EpqNone; + pubType.coopmatNV = false; + pubType.coopmatKHR = false; + pubType.arraySizes = new TArraySizes; + pubType.arraySizes->addInnerSize(dstArrLen, dstLenAsNode); + pubType.typeParameters = nullptr; + } + + if (builtinOp == EOpExtractSubArrayQCOM) { + auto dstArr = arguments->getAsAggregate()->getSequence()[2]->getAsTyped(); + auto& dstTy = dstArr->getType(); + auto dstArrLen = dstTy.getArraySizes()->getDimSize(0); + auto dstLenAsNode = dstTy.getArraySizes()->getDimNode(0); + + if (dstLenAsNode == nullptr) { + if ((dstArrLen * GetNumBits(dstTy.getBasicType())) == 32) + error(loc, "the byte size of the target array must be 32", "", ""); + } + + pubType.basicType = dstTy.getBasicType(); + pubType.vectorSize = 1u; + pubType.qualifier.precision = EpqNone; + pubType.coopmatNV = false; + pubType.coopmatKHR = false; + pubType.arraySizes = new TArraySizes; + pubType.arraySizes->addInnerSize(dstArrLen, dstLenAsNode); + pubType.typeParameters = nullptr; + } + + if (builtinOp == EOpCompositeConstructCoopMatQCOM) { + + auto& srcType = arguments->getAsAggregate()->getSequence()[0]->getAsTyped()->getType(); + auto& dstType = arguments->getAsAggregate()->getSequence()[1]->getAsTyped()->getType(); + + glslang::TBasicType srcBasicType = srcType.getBasicType(); + glslang::TBasicType dstBasicType = dstType.getBasicType(); + + if (srcBasicType != EbtUint && srcBasicType != dstBasicType) + error(loc, "source and destination element types are not compatible", "", ""); + + uint32_t scope = spv_Scope_Subgroup; + uint32_t coopMatKHRuse = !0u; + uint32_t coopMatNumRows = !0u, coopMatNumCols = !0u; + TIntermTyped *nodeNumRows = nullptr, *nodeNumCols = nullptr; + const TTypeParameters* dstTypeParameters = dstType.getTypeParameters(); + if (dstTypeParameters->arraySizes == nullptr || dstTypeParameters->arraySizes->getNumDims() != 4) { + error(loc, "destination cooperative matrix has an unsupported type", "", ""); + } else { + auto arraySizes = dstTypeParameters->arraySizes; + scope = arraySizes->getDimSize(0); + coopMatNumRows = arraySizes->getDimSize(1); + nodeNumRows = arraySizes->getDimNode(1); + coopMatNumCols = arraySizes->getDimSize(2); + nodeNumCols = arraySizes->getDimNode(2); + coopMatKHRuse = arraySizes->getDimSize(3); + } + + if (scope != spv_Scope_Subgroup) { + scope = spv_Scope_Subgroup; + error(loc, "cooperative matrix has unsupported scope; gl_SubgroupScope is expected", "", ""); + } + + if (coopMatKHRuse < CM_MatrixUseA || coopMatKHRuse > CM_MatrixUseAccumulator) { + coopMatKHRuse = CM_MatrixUseA; + error(loc, "cooperative matrix use must be one of gl_MatrixUseA, gl_MatrixUseB, gl_MatrixUseAccumulator", + "", ""); + } + + uint32_t dstBasicTypeSize = GetNumBits(dstBasicType) / 8; + + unsigned numRows = coopMatNumRows; + TIntermTyped* specConstRows = nodeNumRows; + unsigned numCols = coopMatNumCols; + TIntermTyped* specConstCols = nodeNumCols; + + // input array type + const TType& type = arguments->getAsAggregate()->getSequence()[0]->getAsTyped()->getType(); + uint32_t arrayLen = type.getArraySizes()->getDimSize(0); + auto arrayDimNode = type.getArraySizes()->getDimNode(0); + + if (coopMatKHRuse == CM_MatrixUseA || coopMatKHRuse == CM_MatrixUseAccumulator) { + // update numCols + if (arrayDimNode == nullptr && specConstCols == nullptr) + numCols = arrayLen * (sizeof(uint32_t) / dstBasicTypeSize); + } else if (coopMatKHRuse == CM_MatrixUseB) { + // update numRows + if (arrayDimNode == nullptr && specConstRows == nullptr) { + numRows = arrayLen * (sizeof(uint32_t) / dstBasicTypeSize); + } + } + + // construct the type + TArraySizes* arraySizes = new TArraySizes; + + // add Scope + arraySizes->addInnerSize(scope); + + // add the row size + arraySizes->addInnerSize(numRows, specConstRows); // copy from source + // add the column size + arraySizes->addInnerSize(numCols, specConstCols); // copy from source + // add cooperative matrix use + arraySizes->addInnerSize(coopMatKHRuse); + + pubType.basicType = dstBasicType; + pubType.vectorSize = 1u; + pubType.qualifier = srcType.getQualifier(); + pubType.qualifier.precision = EpqNone; + pubType.coopmatNV = dstType.isCoopMatNV(); + pubType.coopmatKHR = dstType.isCoopMatKHR(); + pubType.arraySizes = nullptr; + pubType.typeParameters = const_cast(dstTypeParameters); + } + + if (builtinOp == EOpCompositeExtractCoopMatQCOM) { + auto& srcType = arguments->getAsAggregate()->getSequence()[0]->getAsTyped()->getType(); + auto& dstType = arguments->getAsAggregate()->getSequence()[1]->getAsTyped()->getType(); + + glslang::TBasicType srcBasicType = srcType.getBasicType(); + glslang::TBasicType dstBasicType = dstType.getBasicType(); + + if (dstBasicType != EbtUint && srcBasicType != dstBasicType) + error(loc, "source and destination element types are not compatible", "", ""); + + uint32_t scope = spv_Scope_Subgroup; + unsigned coopMatKHRuse = !0u; + const TTypeParameters* srcTypeParameters = srcType.getTypeParameters(); + if (srcTypeParameters->arraySizes == nullptr || srcTypeParameters->arraySizes->getNumDims() != 4) { + error(loc, "source cooperative matrix has an unsupported type", "", ""); + } else { + auto arraySizes = srcTypeParameters->arraySizes; + scope = arraySizes->getDimSize(0); + coopMatKHRuse = arraySizes->getDimSize(3); + } + + if (scope != spv_Scope_Subgroup) { + scope = spv_Scope_Subgroup; + error(loc, "cooperative matrix has unsupported scope; gl_SubgroupScope is expected", "", ""); + } + + if (coopMatKHRuse < CM_MatrixUseA || coopMatKHRuse > CM_MatrixUseAccumulator) { + coopMatKHRuse = CM_MatrixUseA; + error(loc, "cooperative matrix use must be one of gl_MatrixUseA, gl_MatrixUseB, gl_MatrixUseAccumulator", + "", ""); + } + + auto dstArrLen = dstType.getArraySizes()->getDimSize(0); + auto dstLenAsNode = dstType.getArraySizes()->getDimNode(0); + + if (dstLenAsNode == nullptr) { + bool ok = true; + switch (dstBasicType) { + case EbtUint: + case EbtInt: + case EbtFloat: + ok = (((coopMatKHRuse == CM_MatrixUseA || coopMatKHRuse == CM_MatrixUseB) && dstArrLen == 8) || + (coopMatKHRuse == + CM_MatrixUseAccumulator) /* && (dstArrLen == 64 || dstArrLen == 32 || dstArrLen == 16))*/); + break; + case EbtFloat16: + ok = (((coopMatKHRuse == CM_MatrixUseA || coopMatKHRuse == CM_MatrixUseB) && dstArrLen == 16) || + (coopMatKHRuse == + CM_MatrixUseAccumulator) /* && (dstArrLen == 64 || dstArrLen == 32 || dstArrLen == 16))*/); + break; + case EbtInt8: + case EbtUint8: + ok = (((coopMatKHRuse == CM_MatrixUseA || coopMatKHRuse == CM_MatrixUseB) && dstArrLen == 32) || + (coopMatKHRuse == + CM_MatrixUseAccumulator) /* && (dstArrLen == 64 || dstArrLen == 32 || dstArrLen == 16))*/); + break; + default: + error(loc, "unsupported element type", "", ""); + } + if (!ok) + error(loc, "unsupported destination array length", "", ""); + } + + pubType.basicType = dstBasicType; + pubType.vectorSize = 1u; + pubType.qualifier.precision = EpqNone; + pubType.coopmatNV = false; + pubType.coopmatKHR = false; + + pubType.arraySizes = new TArraySizes; + + { + //int coopMatKHRuse = srcTypeParameters->arraySizes->getDimSize(3); + uint32_t index = !0u; + if (coopMatKHRuse == CM_MatrixUseA) { + index = 2; + } else if (coopMatKHRuse == CM_MatrixUseB) { + index = 1; + } else if (coopMatKHRuse == CM_MatrixUseAccumulator) { + index = 2; + } else { + error(loc, "source cooperative matrix has an unexpected cooperative matrix use", "", ""); + } + int32_t numRowsOrCols = srcTypeParameters->arraySizes->getDimSize(index); + auto dimNode = srcTypeParameters->arraySizes->getDimNode(index); + if (dimNode != nullptr && dstLenAsNode == nullptr) { + numRowsOrCols = dstType.getArraySizes()->getDimSize(0); + dimNode = nullptr; + } + //int32_t dstArrLen = dstType.getArraySizes()->getDimSize(0); + pubType.arraySizes->addInnerSize(dstArrLen, dstLenAsNode); + if (dimNode == nullptr && dstLenAsNode == nullptr) { + const char* msg = nullptr; + if (coopMatKHRuse == CM_MatrixUseA && (numRowsOrCols != dstArrLen && dstArrLen != 8)) { + msg = "the source matrix's column is not compatible with the destination array"; + } else if (coopMatKHRuse == CM_MatrixUseB && (numRowsOrCols != dstArrLen && dstArrLen != 8)) { + msg = "the source matrix's row is not compatible with the destination array"; + } else if (coopMatKHRuse == CM_MatrixUseAccumulator && + (numRowsOrCols != dstArrLen && + (srcBasicType == EbtFloat16 && numRowsOrCols != 2 * dstArrLen))) { + msg = "the source matrix's column is not compatible with the destination array"; + } + if (msg != nullptr) + error(loc, msg, "", ""); + } + } + + pubType.typeParameters = nullptr; + } + + TType resultType(pubType); + if (pubType.typeParameters != nullptr) + resultType.copyTypeParameters(*pubType.typeParameters); + // need to make StorageQualifier temp + resultType.makeTemporary(); + result->setType(resultType); + + // the RHS of an assignment to be formed + auto rhs = result; + + // the LHS of an assignment to be formed; pick the last argument + int lhsIdx = (builtinOp == EOpExtractSubArrayQCOM ? 2 : 1); + auto lhs = arguments->getAsAggregate()->getSequence()[lhsIdx]->getAsTyped(); + // pop the last argument from the arguments sequence + arguments->getAsAggregate()->getSequence().pop_back(); + + // Create OpAssign + { + arrayObjectCheck(loc, lhs->getType(), "array assignment"); + storage16BitAssignmentCheck(loc, lhs->getType(), "="); + lValueErrorCheck(loc, "assign", lhs); + rValueErrorCheck(loc, "assign", rhs); + result = addAssign(loc, EOpAssign, lhs, rhs); + if (result == nullptr) + result = oldResult; + } +} + + TIntermTyped* TParseContext::handleBuiltInFunctionCall(TSourceLoc loc, TIntermNode* arguments, const TFunction& function) { @@ -1873,6 +2191,7 @@ void TParseContext::computeBuiltinPrecisions(TIntermTyped& node, const TFunction case EOpDebugPrintf: case EOpCooperativeMatrixPerElementOpNV: case EOpCooperativeMatrixReduceNV: + case EOpConstructSaturated: numArgs = 0; break; default: @@ -1881,6 +2200,8 @@ void TParseContext::computeBuiltinPrecisions(TIntermTyped& node, const TFunction // find the maximum precision from the arguments and parameters for (unsigned int arg = 0; arg < numArgs; ++arg) { operationPrecision = std::max(operationPrecision, sequence[arg]->getAsTyped()->getQualifier().precision); + } + for (int arg = 0; arg < function.getParamCount(); ++arg) { operationPrecision = std::max(operationPrecision, function[arg].type->getQualifier().precision); } // compute the result precision @@ -2077,7 +2398,10 @@ void TParseContext::addInputArgumentConversions(const TFunction& function, TInte TIntermTyped* arg = function.getParamCount() == 1 ? arguments->getAsTyped() : (aggregate ? aggregate->getSequence()[i]->getAsTyped() : arguments->getAsTyped()); if (*function[i].type != arg->getType()) { if (function[i].type->getQualifier().isParamInput() && - !function[i].type->isCoopMat()) { + !function[i].type->isCoopMat() && !function[i].type->isTensorARM() && + // tensor layout/view type declarations don't do conversions, so we can't convert these parameters either + (function.getName() != "createTensorLayoutNV") && + (function.getName() != "createTensorViewNV")) { // In-qualified arguments just need an extra node added above the argument to // convert to the correct type. arg = intermediate.addConversion(EOpFunctionCall, *function[i].type, arg); @@ -2204,6 +2528,9 @@ void TParseContext::memorySemanticsCheck(const TSourceLoc& loc, const TFunction& const int gl_StorageSemanticsImage = 0x800; const int gl_StorageSemanticsOutput = 0x1000; + const int nonRelaxedMemoryOrder = gl_SemanticsAcquire | + gl_SemanticsRelease | + gl_SemanticsAcquireRelease; unsigned int semantics = 0, storageClassSemantics = 0; unsigned int semantics2 = 0, storageClassSemantics2 = 0; @@ -2270,22 +2597,6 @@ void TParseContext::memorySemanticsCheck(const TSourceLoc& loc, const TFunction& break; } - if ((semantics & gl_SemanticsAcquire) && - (callNode.getOp() == EOpAtomicStore || callNode.getOp() == EOpImageAtomicStore)) { - error(loc, "gl_SemanticsAcquire must not be used with (image) atomic store", - fnCandidate.getName().c_str(), ""); - } - if ((semantics & gl_SemanticsRelease) && - (callNode.getOp() == EOpAtomicLoad || callNode.getOp() == EOpImageAtomicLoad)) { - error(loc, "gl_SemanticsRelease must not be used with (image) atomic load", - fnCandidate.getName().c_str(), ""); - } - if ((semantics & gl_SemanticsAcquireRelease) && - (callNode.getOp() == EOpAtomicStore || callNode.getOp() == EOpImageAtomicStore || - callNode.getOp() == EOpAtomicLoad || callNode.getOp() == EOpImageAtomicLoad)) { - error(loc, "gl_SemanticsAcquireRelease must not be used with (image) atomic load/store", - fnCandidate.getName().c_str(), ""); - } if (((semantics | semantics2) & ~(gl_SemanticsAcquire | gl_SemanticsRelease | gl_SemanticsAcquireRelease | @@ -2294,6 +2605,7 @@ void TParseContext::memorySemanticsCheck(const TSourceLoc& loc, const TFunction& gl_SemanticsVolatile))) { error(loc, "Invalid semantics value", fnCandidate.getName().c_str(), ""); } + if (((storageClassSemantics | storageClassSemantics2) & ~(gl_StorageSemanticsBuffer | gl_StorageSemanticsShared | gl_StorageSemanticsImage | @@ -2301,58 +2613,102 @@ void TParseContext::memorySemanticsCheck(const TSourceLoc& loc, const TFunction& error(loc, "Invalid storage class semantics value", fnCandidate.getName().c_str(), ""); } - if (callNode.getOp() == EOpMemoryBarrier) { - if (!IsPow2(semantics & (gl_SemanticsAcquire | gl_SemanticsRelease | gl_SemanticsAcquireRelease))) { - error(loc, "Semantics must include exactly one of gl_SemanticsRelease, gl_SemanticsAcquire, or " - "gl_SemanticsAcquireRelease", fnCandidate.getName().c_str(), ""); - } - } else { - if (semantics & (gl_SemanticsAcquire | gl_SemanticsRelease | gl_SemanticsAcquireRelease)) { - if (!IsPow2(semantics & (gl_SemanticsAcquire | gl_SemanticsRelease | gl_SemanticsAcquireRelease))) { - error(loc, "Semantics must not include multiple of gl_SemanticsRelease, gl_SemanticsAcquire, or " - "gl_SemanticsAcquireRelease", fnCandidate.getName().c_str(), ""); - } - } - if (semantics2 & (gl_SemanticsAcquire | gl_SemanticsRelease | gl_SemanticsAcquireRelease)) { - if (!IsPow2(semantics2 & (gl_SemanticsAcquire | gl_SemanticsRelease | gl_SemanticsAcquireRelease))) { - error(loc, "semUnequal must not include multiple of gl_SemanticsRelease, gl_SemanticsAcquire, or " - "gl_SemanticsAcquireRelease", fnCandidate.getName().c_str(), ""); - } - } - } - if (callNode.getOp() == EOpMemoryBarrier) { - if (storageClassSemantics == 0) { - error(loc, "Storage class semantics must not be zero", fnCandidate.getName().c_str(), ""); - } + if (((semantics & nonRelaxedMemoryOrder) && !IsPow2(semantics & nonRelaxedMemoryOrder)) || + ((semantics2 & nonRelaxedMemoryOrder) && !IsPow2(semantics2 & nonRelaxedMemoryOrder))) { + error(loc, + "Semantics must not include multiple of gl_SemanticsRelease, gl_SemanticsAcquire, or " + "gl_SemanticsAcquireRelease", + fnCandidate.getName().c_str(), ""); } - if (callNode.getOp() == EOpBarrier && semantics != 0 && storageClassSemantics == 0) { - error(loc, "Storage class semantics must not be zero", fnCandidate.getName().c_str(), ""); + + if (((semantics & nonRelaxedMemoryOrder) && !storageClassSemantics) || + ((semantics2 & nonRelaxedMemoryOrder) && !storageClassSemantics2)) { + error(loc, + "Storage class semantics must not be zero when used with gl_SemanticsRelease, " + "gl_SemanticsAcquire, or gl_SemanticsAcquireRelease", + fnCandidate.getName().c_str(), ""); } - if ((callNode.getOp() == EOpAtomicCompSwap || callNode.getOp() == EOpImageAtomicCompSwap) && - (semantics2 & (gl_SemanticsRelease | gl_SemanticsAcquireRelease))) { - error(loc, "semUnequal must not be gl_SemanticsRelease or gl_SemanticsAcquireRelease", + + if ((storageClassSemantics && !(semantics & nonRelaxedMemoryOrder)) || + (storageClassSemantics2 && !(semantics2 & nonRelaxedMemoryOrder))) { + error(loc, + "Semantics must be gl_SemanticsRelease, gl_SemanticsAcquire, or gl_SemanticsAcquireRelease when used " + "with non-zero storage class semantics", fnCandidate.getName().c_str(), ""); } - if ((semantics & gl_SemanticsMakeAvailable) && - !(semantics & (gl_SemanticsRelease | gl_SemanticsAcquireRelease))) { + + if (((semantics & gl_SemanticsMakeAvailable) && + !(semantics & (gl_SemanticsRelease | gl_SemanticsAcquireRelease))) || + ((semantics2 & gl_SemanticsMakeAvailable) && + !(semantics2 & (gl_SemanticsRelease | gl_SemanticsAcquireRelease)))) { error(loc, "gl_SemanticsMakeAvailable requires gl_SemanticsRelease or gl_SemanticsAcquireRelease", fnCandidate.getName().c_str(), ""); } - if ((semantics & gl_SemanticsMakeVisible) && - !(semantics & (gl_SemanticsAcquire | gl_SemanticsAcquireRelease))) { + + if (((semantics & gl_SemanticsMakeVisible) && !(semantics & (gl_SemanticsAcquire | gl_SemanticsAcquireRelease))) || + ((semantics2 & gl_SemanticsMakeVisible) && + !(semantics2 & (gl_SemanticsAcquire | gl_SemanticsAcquireRelease)))) { error(loc, "gl_SemanticsMakeVisible requires gl_SemanticsAcquire or gl_SemanticsAcquireRelease", fnCandidate.getName().c_str(), ""); } - if ((semantics & gl_SemanticsVolatile) && - (callNode.getOp() == EOpMemoryBarrier || callNode.getOp() == EOpBarrier)) { - error(loc, "gl_SemanticsVolatile must not be used with memoryBarrier or controlBarrier", + + if ((callNode.getOp() == EOpAtomicStore || callNode.getOp() == EOpImageAtomicStore) && + (semantics & gl_SemanticsAcquire)) { + error(loc, "gl_SemanticsAcquire must not be used with (image) atomic store", fnCandidate.getName().c_str(), ""); + } + + if ((callNode.getOp() == EOpAtomicLoad || callNode.getOp() == EOpImageAtomicLoad) && + (semantics & gl_SemanticsRelease)) { + error(loc, "gl_SemanticsRelease must not be used with (image) atomic load", fnCandidate.getName().c_str(), ""); + } + + if ((callNode.getOp() == EOpAtomicStore || callNode.getOp() == EOpImageAtomicStore || + callNode.getOp() == EOpAtomicLoad || callNode.getOp() == EOpImageAtomicLoad) && + (semantics & gl_SemanticsAcquireRelease)) { + error(loc, "gl_SemanticsAcquireRelease must not be used with (image) atomic load/store", + fnCandidate.getName().c_str(), ""); + } + + if (callNode.getOp() == EOpMemoryBarrier && + !(semantics & (gl_SemanticsAcquire | gl_SemanticsRelease | gl_SemanticsAcquireRelease))) { + error(loc, + "Semantics must include exactly one of gl_SemanticsRelease, gl_SemanticsAcquire, or " + "gl_SemanticsAcquireRelease when used with memoryBarrier", fnCandidate.getName().c_str(), ""); } - if ((callNode.getOp() == EOpAtomicCompSwap || callNode.getOp() == EOpImageAtomicCompSwap) && - ((semantics ^ semantics2) & gl_SemanticsVolatile)) { - error(loc, "semEqual and semUnequal must either both include gl_SemanticsVolatile or neither", + + if ((callNode.getOp() == EOpMemoryBarrier || callNode.getOp() == EOpBarrier) && + (semantics & gl_SemanticsVolatile)) { + error(loc, "gl_SemanticsVolatile must not be used with memoryBarrier or controlBarrier", fnCandidate.getName().c_str(), ""); } + + if (callNode.getOp() == EOpAtomicCompSwap || callNode.getOp() == EOpImageAtomicCompSwap) { + if (semantics2 & (gl_SemanticsRelease | gl_SemanticsAcquireRelease)) { + error(loc, "semUnequal must not be gl_SemanticsRelease or gl_SemanticsAcquireRelease", + fnCandidate.getName().c_str(), ""); + } + if ((semantics2 & gl_SemanticsAcquire) && !(semantics & (gl_SemanticsAcquire | gl_SemanticsAcquireRelease))) { + error(loc, + "semUnequal must not be gl_SemanticsAcquire unless semEqual is gl_SemanticsAcquire " + "or gl_SemanticsAcquireRelease", + fnCandidate.getName().c_str(), ""); + } + if ((semantics2 & gl_SemanticsMakeVisible) && !(semantics & gl_SemanticsMakeVisible)) { + error(loc, + "semUnequal must not include gl_SemanticsMakeVisible unless semEqual also includes " + "gl_SemanticsMakeVisible", + fnCandidate.getName().c_str(), ""); + } + if (storageClassSemantics2 & ~(storageClassSemantics)) { + error(loc, "semStorageUnequal must not include any option that is not present in semStorageEqual", + fnCandidate.getName().c_str(), ""); + } + if ((semantics ^ semantics2) & gl_SemanticsVolatile) { + error(loc, "semEqual and semUnequal must either both include gl_SemanticsVolatile or neither", + fnCandidate.getName().c_str(), ""); + } + } } // @@ -2426,7 +2782,7 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan if (! fnCandidate[0].type->getSampler().shadow) compArg = 3; // check for constant offsets - if (! (*argp)[fnCandidate[0].type->getSampler().shadow ? 3 : 2]->getAsConstantUnion() + if (! (*argp)[fnCandidate[0].type->getSampler().shadow ? 3 : 2]->getAsConstantUnion() // NV_gpu_shader5 relaxes this limitation and allows for non-constant offsets && !extensionTurnedOn(E_GL_NV_gpu_shader5)) error(loc, "must be a compile-time constant:", feature, "offsets argument"); @@ -3123,6 +3479,30 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan if (!(*argp)[6]->getAsTyped()->getType().getQualifier().isConstant()) error(loc, "argument must be compile-time constant", "matrixInterpretation", ""); break; + + case EOpCooperativeMatrixLoad: + case EOpCooperativeMatrixLoadNV: + case EOpCooperativeMatrixLoadTensorNV: + case EOpCooperativeMatrixStore: + case EOpCooperativeMatrixStoreNV: + case EOpCooperativeMatrixStoreTensorNV: + { + const TIntermTyped *arg1 = (*argp)[1]->getAsTyped(); + const TIntermTyped* base = TIntermediate::traverseLValueBase(arg1, true, true); + const char* errMsg = "Only l-values corresponding to storage block or shared variables can be used with " + "cooperative matrix load/store functions."; + if (base) { + const TType* refType = (base->getType().isReference()) ? base->getType().getReferentType() : nullptr; + const TQualifier& qualifier = + (refType != nullptr) ? refType->getQualifier() : base->getType().getQualifier(); + if (qualifier.storage != EvqShared && qualifier.storage != EvqBuffer) + error(loc, errMsg, fnCandidate.getName().c_str(), ""); + } else { + error(loc, errMsg, fnCandidate.getName().c_str(), ""); + } + } + break; + default: break; } @@ -3148,6 +3528,102 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan break; } + case EOpConstructSaturated: + { + auto &sequence = callNode.getAsAggregate()->getSequence(); + if (sequence.size() != 2) { + error(loc, "requires exactly two parameters", "", ""); + } + auto &op0Type = sequence[0]->getAsTyped()->getType(); + auto &op1Type = sequence[1]->getAsTyped()->getType(); + if (op0Type.getBasicType() != EbtFloatE5M2 && op0Type.getBasicType() != EbtFloatE4M3) { + error(loc, "first parameter must have floate5m2 or floate4m3 basic type", "", ""); + } + if (op1Type.getBasicType() == EbtFloatE5M2 || op1Type.getBasicType() == EbtFloatE4M3) { + error(loc, "second parameter must not have floate5m2 or floate4m3 basic type", "", ""); + } + + if (!(op0Type.isScalar() || op0Type.isVector() || op0Type.isCoopMatKHR())) { + error(loc, "first parameter must be scalar, vector, or cooperative matrix", "", ""); + } + if (!(op1Type.isScalar() || op1Type.isVector() || op1Type.isCoopMatKHR())) { + error(loc, "second parameter must be scalar, vector, or cooperative matrix", "", ""); + } + if (!(op0Type.sameElementShape(op1Type) || op0Type.sameCoopMatShape(op1Type))) { + error(loc, "types must match other than scalar type and coopmat Use", "", ""); + } + break; + } + case EOpTensorReadARM: + case EOpTensorWriteARM: + { + const TType &tensorType = (*argp)[0]->getAsTyped()->getType(); + + // Check that coordinates argument length matches rank of tensor argument. + int tensorRank = tensorType.getTensorRankARM(); + const TArraySizes *coordArgArrayTy = (*argp)[1]->getAsTyped()->getType().getArraySizes(); + assert(coordArgArrayTy->getNumDims() == 1 && "expecting 1D coordinate array"); + if (coordArgArrayTy->getDimSize(0) != tensorRank) { + error(loc, "number of coordinates does not match tensor rank", "coord", ""); + } + + // Check that tensor element type matches data argument. + TBasicType eltTy = tensorType.getBasicType(); + TBasicType argTy = (*argp)[2]->getAsTyped()->getType().getBasicType(); + if (eltTy != argTy) { + error(loc, "", "data", "data argument type (%s) does not match tensor element type (%s)", + TType::getBasicString(argTy), TType::getBasicString(eltTy)); + } + + // Check optional tensor operands. + if (argp->size() > 3) { + const TIntermConstantUnion* opArg = (*argp)[3]->getAsConstantUnion(); + if (!opArg) { + error(loc, "tensor operands argument must be a constant integral expression", "tensorOps", ""); + } + const unsigned int ops = opArg ? opArg->getConstArray()[0].getUConst() : 0; + const int gl_TensorOperandsOutOfBoundsValueARM = 0x2; + if (ops & gl_TensorOperandsOutOfBoundsValueARM) { + // Out-of-bounds values can only be used with reads. + if (callNode.getOp() != EOpTensorReadARM) { + error(loc, "out-of-bounds value is only valid with tensorReadARM", "tensorOps", ""); + } + // Check that an out-of-bounds value is present. + if (argp->size() == 4) { + error(loc, "expecting out-of-bounds value as next argument", "tensorOps", ""); + } else { + // Check constantness of out-of-bounds value. + const TIntermConstantUnion* oobArg = (*argp)[4]->getAsConstantUnion(); + if (!oobArg) { + error(loc, "argument following gl_TensorOperandsOutOfBoundsValueARM must be constant", "vararg", + ""); + } else if (oobArg->getType().getBasicType() != tensorType.getBasicType()) { + // The type of the OOB value does not match the tensor type. + error(loc, "", "vararg", + "out-of-bounds value type (%s) does not match tensor element type (%s)", + TType::getBasicString(oobArg->getBasicType()), TType::getBasicString(eltTy)); + + } + } + } + } + break; + } + + case EOpTensorSizeARM: + { + unsigned int tensorRank = (*argp)[0]->getAsTyped()->getType().getTensorRankARM(); + const TIntermConstantUnion *dimArg = (*argp)[1]->getAsConstantUnion(); + if (dimArg) { + if (dimArg->getConstArray()[0].getUConst() >= tensorRank) { + error(loc, "dimension argument exceeds tensor rank", "dim", ""); + } + } else { + error(loc, "dimension argument must be constant", "dim", ""); + } + break; + } + default: break; } @@ -4268,6 +4744,9 @@ void TParseContext::samplerCheck(const TSourceLoc& loc, const TType& type, const error(loc, "sampler/image types can only be used in uniform variables or function parameters:", type.getBasicTypeString().c_str(), identifier.c_str()); } } + else if (type.isTensorARM() && type.getQualifier().storage != EvqUniform) { + error(loc, "tensorARM types can only be used in uniform variables or function parameters:", "tensorARM", identifier.c_str()); + } } void TParseContext::atomicUintCheck(const TSourceLoc& loc, const TType& type, const TString& identifier) @@ -4424,7 +4903,7 @@ void TParseContext::globalQualifierTypeCheck(const TSourceLoc& loc, const TQuali if (! symbolTable.atGlobalLevel()) return; - if (!(publicType.userDef && publicType.userDef->isReference()) && !parsingBuiltins) { + if (!(publicType.userDef && publicType.userDef->isReference()) && !publicType.isTensorARM() && !parsingBuiltins) { if (qualifier.isMemoryQualifierImageAndSSBOOnly() && ! publicType.isImage() && publicType.qualifier.storage != EvqBuffer) { error(loc, "memory qualifiers cannot be used on this type", "", ""); } else if (qualifier.isMemory() && (publicType.basicType != EbtSampler) && !publicType.qualifier.isUniformOrBuffer()) { @@ -4450,11 +4929,6 @@ void TParseContext::globalQualifierTypeCheck(const TSourceLoc& loc, const TQuali // now, knowing it is a shader in/out, do all the in/out semantic checks - if (publicType.basicType == EbtBool && !parsingBuiltins) { - error(loc, "cannot be bool", GetStorageQualifierString(qualifier.storage), ""); - return; - } - if (isTypeInt(publicType.basicType) || publicType.basicType == EbtDouble) { profileRequires(loc, EEsProfile, 300, nullptr, "non-float shader input/output"); profileRequires(loc, ~EEsProfile, 130, nullptr, "non-float shader input/output"); @@ -4775,7 +5249,7 @@ TPrecisionQualifier TParseContext::getDefaultPrecision(TPublicType& publicType) return defaultPrecision[publicType.basicType]; } -void TParseContext::precisionQualifierCheck(const TSourceLoc& loc, TBasicType baseType, TQualifier& qualifier, bool isCoopMatOrVec) +void TParseContext::precisionQualifierCheck(const TSourceLoc& loc, TBasicType baseType, TQualifier& qualifier, bool hasTypeParameter) { // Built-in symbols are allowed some ambiguous precisions, to be pinned down // later by context. @@ -4785,7 +5259,7 @@ void TParseContext::precisionQualifierCheck(const TSourceLoc& loc, TBasicType ba if (baseType == EbtAtomicUint && qualifier.precision != EpqNone && qualifier.precision != EpqHigh) error(loc, "atomic counters can only be highp", "atomic_uint", ""); - if (isCoopMatOrVec) + if (hasTypeParameter) return; if (baseType == EbtFloat || baseType == EbtUint || baseType == EbtInt || baseType == EbtSampler || baseType == EbtAtomicUint) { @@ -6943,6 +7417,22 @@ void TParseContext::layoutObjectCheck(const TSourceLoc& loc, const TSymbol& symb break; } } + + // Check that an in/out variable or block doesn't contain a boolean member + // Don't enforce if redeclaring a builtin, which are allowed to contain bool + if (!parsingBuiltins && type.containsBasicType(EbtBool) && !builtInName(symbol.getName())) { + switch(qualifier.storage) { + case EvqVaryingIn: + case EvqVaryingOut: + { + const char *reason = type.getBasicType() == EbtBool ? "cannot be bool" : "cannot contain bool"; + error(loc, reason, GetStorageQualifierString(qualifier.storage), ""); + break; + } + default: + break; + } + } } // "For some blocks declared as arrays, the location can only be applied at the block level: @@ -7214,6 +7704,8 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type) case EbtDouble: case EbtFloat16: case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: break; default: error(loc, "cannot be applied to this type", "constant_id", ""); @@ -7498,6 +7990,12 @@ const TFunction* TParseContext::findFunction(const TSourceLoc& loc, const TFunct return symbol->getAsFunction(); } + if (call.getName() == "saturatedConvertEXT") { + TSymbol* symbol = symbolTable.find("saturatedConvertEXT(", &builtIn); + if (symbol) + return symbol->getAsFunction(); + } + bool explicitTypesEnabled = extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) || extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int8) || extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int16) || @@ -7682,8 +8180,7 @@ const TFunction* TParseContext::findFunction400(const TSourceLoc& loc, const TFu TType toElementType(to, 0); // Load/store tensor functions allow any element type for the pointer if ((op == EOpCooperativeMatrixLoadTensorNV || op == EOpCooperativeMatrixStoreTensorNV) && - param == 1 && - (from.getQualifier().storage == EvqBuffer || from.getQualifier().storage == EvqShared)) { + param == 1) { return true; } if (fromElementType == toElementType) @@ -7695,6 +8192,8 @@ const TFunction* TParseContext::findFunction400(const TSourceLoc& loc, const TFu return from.sameCoopMatBaseType(to); if (from.isCoopVecNV() && to.isCoopVecNV()) return from.sameCoopVecBaseType(to); + if (from.isTensorARM() && to.isTensorARM()) + return from.sameTensorBaseTypeARM(to); return intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType()); }; @@ -7757,7 +8256,7 @@ const TFunction* TParseContext::findFunction400(const TSourceLoc& loc, const TFu // "To determine whether the conversion for a single argument in one match // is better than that for another match, the conversion is assigned of the // three ranks ordered from best to worst: -// 1. Exact match: no conversion. +// 1. Exact match: no conversion. // 2. Promotion: integral or floating-point promotion. // 3. Conversion: integral conversion, floating-point conversion, // floating-integral conversion. @@ -7794,8 +8293,7 @@ const TFunction* TParseContext::findFunctionExplicitTypes(const TSourceLoc& loc, TType toElementType(to, 0); // Load/store tensor functions allow any element type for the pointer if ((op == EOpCooperativeMatrixLoadTensorNV || op == EOpCooperativeMatrixStoreTensorNV) && - param == 1 && - (from.getQualifier().storage == EvqBuffer || from.getQualifier().storage == EvqShared)) { + param == 1) { return true; } if (fromElementType == toElementType) @@ -7807,6 +8305,8 @@ const TFunction* TParseContext::findFunctionExplicitTypes(const TSourceLoc& loc, return from.sameCoopMatBaseType(to); if (from.isCoopVecNV() && to.isCoopVecNV()) return from.sameCoopVecBaseType(to); + if (from.isTensorARM() && to.isTensorARM()) + return from.sameTensorBaseTypeARM(to); return intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType()); }; @@ -7955,6 +8455,8 @@ void TParseContext::typeParametersCheck(const TSourceLoc& loc, const TPublicType case EbtFloat: case EbtFloat16: case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: case EbtInt: case EbtInt8: case EbtInt16: @@ -8011,6 +8513,24 @@ void TParseContext::typeParametersCheck(const TSourceLoc& loc, const TPublicType } } } + if (publicType.isTensorARM()) { + if (publicType.typeParameters == nullptr) { + error(loc, "tensor type is missing type parameters", "", ""); + return; + } + if (publicType.typeParameters->arraySizes == nullptr) { + error(loc, "tensor type is missing rank information", "", ""); + return; + } + if (publicType.typeParameters->arraySizes->getNumDims() != 1) { + error(loc, "tensor type requires exactly 1 rank specifier", "", ""); + return; + } + if (publicType.typeParameters->arraySizes->getDimSize(0) < 1) { + error(loc, "tensor rank must be greater than or equal to 1", "", ""); + return; + } + } } bool TParseContext::vkRelaxedRemapUniformVariable(const TSourceLoc& loc, TString& identifier, const TPublicType& publicType, @@ -8106,12 +8626,15 @@ static void ForEachOpaque(const TType& type, const TString& path, Function callb ++flatIndex) { TString subscriptPath = path; - for (size_t dimIndex = 0; dimIndex < indices.size(); ++dimIndex) + if (path != "") { - int index = indices[dimIndex]; - subscriptPath.append("["); - subscriptPath.append(String(index)); - subscriptPath.append("]"); + for (size_t dimIndex = 0; dimIndex < indices.size(); ++dimIndex) + { + int index = indices[dimIndex]; + subscriptPath.append("["); + subscriptPath.append(String(index)); + subscriptPath.append("]"); + } } recursion(type, subscriptPath, true, recursion); @@ -8119,7 +8642,7 @@ static void ForEachOpaque(const TType& type, const TString& path, Function callb for (size_t dimIndex = 0; dimIndex < indices.size(); ++dimIndex) { ++indices[dimIndex]; - if (indices[dimIndex] < type.getArraySizes()->getDimSize(dimIndex)) + if (indices[dimIndex] < type.getArraySizes()->getDimSize(static_cast(dimIndex))) break; else indices[dimIndex] = 0; @@ -8133,8 +8656,11 @@ static void ForEachOpaque(const TType& type, const TString& path, Function callb for (const TTypeLoc& typeLoc : types) { TString nextPath = path; - nextPath.append("."); - nextPath.append(typeLoc.type->getFieldName()); + if (path != "") + { + nextPath.append("."); + nextPath.append(typeLoc.type->getFieldName()); + } recursion(*(typeLoc.type), nextPath, false, recursion); } @@ -8192,9 +8718,13 @@ void TParseContext::vkRelaxedRemapFunctionParameter(TFunction* function, TParame if (!param.type->isStruct() || !param.type->containsOpaque()) return; - ForEachOpaque(*param.type, (param.name ? *param.name : param.type->getFieldName()), + TString fieldName = param.name + ? *param.name + : param.type->hasFieldName() ? param.type->getFieldName() : ""; + + ForEachOpaque(*param.type, fieldName, [function, param, newParams](const TType& type, const TString& path) { - TString* memberName = NewPoolTString(path.c_str()); + TString* memberName = path != "" ? NewPoolTString(path.c_str()) : nullptr; TType* memberType = new TType(); memberType->shallowCopy(type); @@ -8433,6 +8963,29 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden } else if (publicType.typeParameters->arraySizes->getDimSize(0) <= 0) { error(loc, "expected positive number of components", identifier.c_str(), ""); } + } else if (type.isTensorARM()) { + intermediate.setUseStorageBuffer(); + + if (!publicType.typeParameters || publicType.typeParameters->arraySizes->getNumDims() != 1) { + error(loc, "expected two type parameters", identifier.c_str(), ""); + } + if (publicType.typeParameters) { + if (publicType.typeParameters->basicType != EbtBool && + publicType.typeParameters->basicType != EbtInt8 && + publicType.typeParameters->basicType != EbtInt16 && + publicType.typeParameters->basicType != EbtInt && + publicType.typeParameters->basicType != EbtInt64 && + publicType.typeParameters->basicType != EbtUint8 && + publicType.typeParameters->basicType != EbtUint16 && + publicType.typeParameters->basicType != EbtUint && + publicType.typeParameters->basicType != EbtUint64 && + publicType.typeParameters->basicType != EbtFloat16 && + publicType.typeParameters->basicType != EbtFloat && + publicType.typeParameters->basicType != EbtDouble) { + error(loc, "expected bool, integer or floating point type parameter", identifier.c_str(), ""); + } + + } } else { if (publicType.typeParameters && publicType.typeParameters->arraySizes->getNumDims() != 0) { error(loc, "unexpected type parameters", identifier.c_str(), ""); @@ -8469,6 +9022,10 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden (type.getQualifier().storage == EvqVaryingIn || type.getQualifier().storage == EvqVaryingOut)) error(loc, "qualifier", "bfloat16 types not allowed as input/output", ""); + if ((type.getBasicType() == EbtFloatE5M2 || type.getBasicType() == EbtFloatE4M3) && + (type.getQualifier().storage == EvqVaryingIn || type.getQualifier().storage == EvqVaryingOut)) + error(loc, "qualifier", "fp8 types not allowed as input/output", ""); + if (type.getQualifier().storage == EvqtaskPayloadSharedEXT) intermediate.addTaskPayloadEXTCount(); if (type.getQualifier().storage == EvqShared && type.containsCoopMat()) @@ -9145,6 +9702,20 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T basicOp = EOpConstructBFloat16; break; + case EOpConstructFloatE5M2Vec2: + case EOpConstructFloatE5M2Vec3: + case EOpConstructFloatE5M2Vec4: + case EOpConstructFloatE5M2: + basicOp = EOpConstructFloatE5M2; + break; + + case EOpConstructFloatE4M3Vec2: + case EOpConstructFloatE4M3Vec3: + case EOpConstructFloatE4M3Vec4: + case EOpConstructFloatE4M3: + basicOp = EOpConstructFloatE4M3; + break; + case EOpConstructI8Vec2: case EOpConstructI8Vec3: case EOpConstructI8Vec4: @@ -9370,6 +9941,34 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T return intermediate.setAggregateOperator(newNode, op, type, loc); } +void TParseContext::makeVariadic(TFunction *F, const TSourceLoc &loc) { + if (parsingBuiltins) { + F->setVariadic(); + } else { + error(loc, "variadic argument specifier is only available for builtins", "...", ""); + } +} + +TParameter TParseContext::getParamWithDefault(const TPublicType& ty, TString* identifier, TIntermTyped* initializer, + const TSourceLoc& loc) +{ + if (!parsingBuiltins) { + error(loc, "default argument values are only available for builtins", "=", ""); + initializer = nullptr; + } + if (ty.arraySizes) { + error(loc, "array arguments cannot be default-initialized", identifier->c_str(), ""); + initializer = nullptr; + } + if (ty.basicType == EbtVoid) { + error(loc, "illegal use of type 'void'", identifier->c_str(), ""); + initializer = nullptr; + } + reservedErrorCheck(loc, *identifier); + TParameter param = {identifier, new TType(ty), initializer}; + return param; +} + // This function tests for the type of the parameters to the structure or array constructor. Raises // an error message if the expected type does not match the parameter passed to the constructor. // diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.h b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.h index 47a7299..2bb82eb 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.h +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ParseHelper.h @@ -407,7 +407,7 @@ class TParseContext : public TParseContextBase { void setDefaultPrecision(const TSourceLoc&, TPublicType&, TPrecisionQualifier); int computeSamplerTypeIndex(TSampler&); TPrecisionQualifier getDefaultPrecision(TPublicType&); - void precisionQualifierCheck(const TSourceLoc&, TBasicType, TQualifier&, bool isCoopMatOrVec); + void precisionQualifierCheck(const TSourceLoc&, TBasicType, TQualifier&, bool hasTypeParameter); void parameterTypeCheck(const TSourceLoc&, TStorageQualifier qualifier, const TType& type); bool containsFieldWithBasicType(const TType& type ,TBasicType basicType); TSymbol* redeclareBuiltinVariable(const TSourceLoc&, const TString&, const TQualifier&, const TShaderQualifiers&); @@ -450,6 +450,9 @@ class TParseContext : public TParseContextBase { TIntermTyped* addConstructor(const TSourceLoc&, TIntermNode*, const TType&); TIntermTyped* constructAggregate(TIntermNode*, const TType&, int, const TSourceLoc&); TIntermTyped* constructBuiltIn(const TType&, TOperator, TIntermTyped*, const TSourceLoc&, bool subset); + void makeVariadic(TFunction *F, const TSourceLoc &loc); + TParameter getParamWithDefault(const TPublicType& ty, TString* identifier, TIntermTyped* initializer, + const TSourceLoc& loc); void inheritMemoryQualifiers(const TQualifier& from, TQualifier& to); void declareBlock(const TSourceLoc&, TTypeList& typeList, const TString* instanceName = nullptr, TArraySizes* arraySizes = nullptr); void blockStorageRemap(const TSourceLoc&, const TString*, TQualifier&); @@ -510,6 +513,7 @@ class TParseContext : public TParseContextBase { TIntermTyped* convertInitializerList(const TSourceLoc&, const TType&, TIntermTyped* initializer); void finish() override; void handleCoopMat2FunctionCall(const TSourceLoc& loc, const TFunction* fnCandidate, TIntermTyped* result, TIntermNode* arguments); + void handleVector2CoopMatConversionCall(const TSourceLoc& loc, const TFunction* fnCandidate, TIntermTyped* &result, TIntermNode* arguments); virtual const char* getGlobalUniformBlockName() const override; virtual void finalizeGlobalUniformBlockLayout(TVariable&) override; diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Scan.cpp b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Scan.cpp index 4705d93..28b1fe1 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Scan.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Scan.cpp @@ -542,6 +542,16 @@ const std::unordered_map KeywordMap { {"bf16vec3",BF16VEC3}, {"bf16vec4",BF16VEC4}, + {"floate5m2_t",FLOATE5M2_T}, + {"fe5m2vec2",FE5M2VEC2}, + {"fe5m2vec3",FE5M2VEC3}, + {"fe5m2vec4",FE5M2VEC4}, + + {"floate4m3_t",FLOATE4M3_T}, + {"fe4m3vec2",FE4M3VEC2}, + {"fe4m3vec3",FE4M3VEC3}, + {"fe4m3vec4",FE4M3VEC4}, + {"float32_t",FLOAT32_T}, {"f32vec2",F32VEC2}, {"f32vec3",F32VEC3}, @@ -759,6 +769,8 @@ const std::unordered_map KeywordMap { {"hitObjectNV",HITOBJECTNV}, {"hitObjectAttributeNV",HITOBJECTATTRNV}, + {"tensorARM",TENSORARM}, + {"__function",FUNCTION}, {"tensorLayoutNV",TENSORLAYOUTNV}, {"tensorViewNV",TENSORVIEWNV}, @@ -824,12 +836,22 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token) loc = ppToken.loc; parserToken->sType.lex.loc = loc; switch (token) { - case ';': afterType = false; afterBuffer = false; return SEMICOLON; - case ',': afterType = false; return COMMA; + case ';': afterType = false; afterBuffer = false; inDeclaratorList = false; afterDeclarator = false; angleBracketDepth = 0; squareBracketDepth = 0; parenDepth = 0; return SEMICOLON; + case ',': + // If we just processed a declarator (identifier after a type), this comma + // indicates that we're in a declarator list. Note that 'afterDeclarator' is + // only set when we are not inside a template parameter list, array expression, + // or function parameter list. + if (afterDeclarator) { + inDeclaratorList = true; + } + afterType = false; + afterDeclarator = false; + return COMMA; case ':': return COLON; - case '=': afterType = false; return EQUAL; - case '(': afterType = false; return LEFT_PAREN; - case ')': afterType = false; return RIGHT_PAREN; + case '=': afterType = false; inDeclaratorList = false; afterDeclarator = false; return EQUAL; + case '(': afterType = false; inDeclaratorList = false; afterDeclarator = false; parenDepth++; return LEFT_PAREN; + case ')': afterType = false; inDeclaratorList = false; afterDeclarator = false; if (parenDepth > 0) parenDepth--; return RIGHT_PAREN; case '.': field = true; return DOT; case '!': return BANG; case '-': return DASH; @@ -838,16 +860,16 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token) case '*': return STAR; case '/': return SLASH; case '%': return PERCENT; - case '<': return LEFT_ANGLE; - case '>': return RIGHT_ANGLE; + case '<': angleBracketDepth++; return LEFT_ANGLE; + case '>': if (angleBracketDepth > 0) angleBracketDepth--; return RIGHT_ANGLE; case '|': return VERTICAL_BAR; case '^': return CARET; case '&': return AMPERSAND; case '?': return QUESTION; - case '[': return LEFT_BRACKET; - case ']': return RIGHT_BRACKET; - case '{': afterStruct = false; afterBuffer = false; return LEFT_BRACE; - case '}': return RIGHT_BRACE; + case '[': squareBracketDepth++; return LEFT_BRACKET; + case ']': if (squareBracketDepth > 0) squareBracketDepth--; return RIGHT_BRACKET; + case '{': afterStruct = false; afterBuffer = false; inDeclaratorList = false; afterDeclarator = false; angleBracketDepth = 0; squareBracketDepth = 0; parenDepth = 0; return LEFT_BRACE; + case '}': inDeclaratorList = false; afterDeclarator = false; angleBracketDepth = 0; squareBracketDepth = 0; parenDepth = 0; return RIGHT_BRACE; case '\\': parseContext.error(loc, "illegal use of escape character", "\\", ""); break; @@ -1494,6 +1516,28 @@ int TScanContext::tokenizeIdentifier() return identifierOrType(); + case FLOATE5M2_T: + case FE5M2VEC2: + case FE5M2VEC3: + case FE5M2VEC4: + afterType = true; + if (parseContext.symbolTable.atBuiltInLevel() || + parseContext.extensionTurnedOn(E_GL_EXT_float_e5m2)) + return keyword; + + return identifierOrType(); + + case FLOATE4M3_T: + case FE4M3VEC2: + case FE4M3VEC3: + case FE4M3VEC4: + afterType = true; + if (parseContext.symbolTable.atBuiltInLevel() || + parseContext.extensionTurnedOn(E_GL_EXT_float_e4m3)) + return keyword; + + return identifierOrType(); + case SAMPLERCUBEARRAY: case SAMPLERCUBEARRAYSHADOW: case ISAMPLERCUBEARRAY: @@ -1824,6 +1868,12 @@ int TScanContext::tokenizeIdentifier() parseContext.extensionTurnedOn(E_GL_NV_integer_cooperative_matrix)) return keyword; return identifierOrType(); + case TENSORARM: + afterType = true; + if (parseContext.symbolTable.atBuiltInLevel() || + parseContext.extensionTurnedOn(E_GL_ARM_tensors)) + return keyword; + return identifierOrType(); case COOPMAT: afterType = true; @@ -1895,14 +1945,29 @@ int TScanContext::identifierOrType() if (field) return IDENTIFIER; + // If we see an identifier right after a type, this might be a declarator. + // But not in template parameters (inside angle brackets), array expressions (inside square brackets), + // or function parameters (inside parentheses) + if (afterType && angleBracketDepth == 0 && squareBracketDepth == 0 && parenDepth == 0) { + afterDeclarator = true; + afterType = false; + return IDENTIFIER; + } + parserToken->sType.lex.symbol = parseContext.symbolTable.find(*parserToken->sType.lex.string); if ((afterType == false && afterStruct == false) && parserToken->sType.lex.symbol != nullptr) { if (const TVariable* variable = parserToken->sType.lex.symbol->getAsVariable()) { if (variable->isUserType() && // treat redeclaration of forward-declared buffer/uniform reference as an identifier !(variable->getType().isReference() && afterBuffer)) { - afterType = true; + // If we're in a declarator list (like "float a, B;"), treat struct names as IDENTIFIER + // to fix GitHub issue #3931 + if (inDeclaratorList) { + return IDENTIFIER; + } + + afterType = true; return TYPE_NAME; } } diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ScanContext.h b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ScanContext.h index 74b2b3c..ce2145e 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ScanContext.h +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/ScanContext.h @@ -53,7 +53,7 @@ class TScanContext { explicit TScanContext(TParseContextBase& pc) : parseContext(pc), afterType(false), afterStruct(false), - field(false), afterBuffer(false) { } + field(false), afterBuffer(false), inDeclaratorList(false), afterDeclarator(false), angleBracketDepth(0), squareBracketDepth(0), parenDepth(0) { } virtual ~TScanContext() { } static void fillInKeywordMap(); @@ -82,6 +82,11 @@ class TScanContext { bool afterStruct; // true if we've recognized the STRUCT keyword, so can only be looking for an identifier bool field; // true if we're on a field, right after a '.' bool afterBuffer; // true if we've recognized the BUFFER keyword + bool inDeclaratorList; // true if we detected we're in a declarator list like "float a, b;" + bool afterDeclarator; // true if we just saw an identifier after a type (potential declarator) + int angleBracketDepth; // track nesting level of < > to detect template parameters + int squareBracketDepth; // track nesting level of [ ] to detect array expressions + int parenDepth; // track nesting level of ( ) to detect function parameters TSourceLoc loc; TParserToken* parserToken; TPpToken* ppToken; diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.cpp b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.cpp index fcfa5df..dbcd575 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.cpp @@ -55,7 +55,9 @@ namespace glslang { // void TType::buildMangledName(TString& mangledName) const { - if (isMatrix()) + if (isTensorARM()) + mangledName += 'T'; + else if (isMatrix()) mangledName += 'm'; else if (isVector()) mangledName += 'v'; @@ -71,6 +73,8 @@ void TType::buildMangledName(TString& mangledName) const case EbtDouble: mangledName += 'd'; break; case EbtFloat16: mangledName += "f16"; break; case EbtBFloat16: mangledName += "bf16"; break; + case EbtFloatE5M2: mangledName += "fe5m2"; break; + case EbtFloatE4M3: mangledName += "fe4m3"; break; case EbtInt8: mangledName += "i8"; break; case EbtUint8: mangledName += "u8"; break; case EbtInt16: mangledName += "i16"; break; @@ -421,6 +425,7 @@ TFunction::TFunction(const TFunction& copyOf) : TSymbol(copyOf) defined = copyOf.defined; prototyped = copyOf.prototyped; implicitThis = copyOf.implicitThis; + variadic = copyOf.variadic; illegalImplicitThis = copyOf.illegalImplicitThis; defaultParamCount = copyOf.defaultParamCount; spirvInst = copyOf.spirvInst; diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.h b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.h index 6d1a0c8..c2f5ccf 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.h +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/SymbolTable.h @@ -232,6 +232,13 @@ struct TParameter { name = nullptr; type = param.type->clone(); defaultValue = param.defaultValue; + if (defaultValue) { + // The defaultValue of a builtin is created in a TPoolAllocator that no longer exists + // when parsing the user program, so make a deep copy. + if (const auto *constUnion = defaultValue->getAsConstantUnion()) { + defaultValue = new TIntermConstantUnion(*constUnion->getConstArray().clone(), constUnion->getType()); + } + } return *this; } TBuiltInVariable getDeclaredBuiltIn() const { return type->getQualifier().declaredBuiltIn; } @@ -245,12 +252,12 @@ class TFunction : public TSymbol { explicit TFunction(TOperator o) : TSymbol(nullptr), op(o), - defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), defaultParamCount(0) { } + defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), variadic(false), defaultParamCount(0) { } TFunction(const TString *name, const TType& retType, TOperator tOp = EOpNull) : TSymbol(name), mangledName(*name + '('), op(tOp), - defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), defaultParamCount(0), + defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), variadic(false), defaultParamCount(0), linkType(ELinkNone) { returnType.shallowCopy(retType); @@ -268,6 +275,7 @@ class TFunction : public TSymbol { virtual void addParameter(TParameter& p) { assert(writable); + assert(!variadic && "cannot add more parameters if function is marked variadic"); parameters.push_back(p); p.type->appendMangledName(mangledName); @@ -310,6 +318,13 @@ class TFunction : public TSymbol { virtual bool hasImplicitThis() const { return implicitThis; } virtual void setIllegalImplicitThis() { assert(writable); illegalImplicitThis = true; } virtual bool hasIllegalImplicitThis() const { return illegalImplicitThis; } + virtual void setVariadic() { + assert(writable); + assert(!variadic && "function was already marked variadic"); + variadic = true; + mangledName += 'z'; + } + virtual bool isVariadic() const { return variadic; } // Return total number of parameters virtual int getParamCount() const { return static_cast(parameters.size()); } @@ -352,6 +367,7 @@ class TFunction : public TSymbol { // even if it finds member variables in the symbol table. // This is important for a static member function that has member variables in scope, // but is not allowed to use them, or see hidden symbols instead. + bool variadic; int defaultParamCount; TSpirvInstruction spirvInst; // SPIR-V instruction qualifiers diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Versions.cpp b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Versions.cpp index 63ad51a..59628b7 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Versions.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Versions.cpp @@ -319,11 +319,13 @@ void TParseVersions::initializeExtensionBehavior() // ARM extensionBehavior[E_GL_ARM_shader_core_builtins] = EBhDisable; + extensionBehavior[E_GL_ARM_tensors] = EBhDisable; // QCOM extensionBehavior[E_GL_QCOM_image_processing] = EBhDisable; extensionBehavior[E_GL_QCOM_image_processing2] = EBhDisable; extensionBehavior[E_GL_QCOM_tile_shading] = EBhDisable; + extensionBehavior[E_GL_QCOM_cooperative_matrix_conversion] = EBhDisable; // AEP extensionBehavior[E_GL_ANDROID_extension_pack_es31a] = EBhDisable; @@ -381,6 +383,8 @@ void TParseVersions::initializeExtensionBehavior() extensionBehavior[E_GL_EXT_texture_offset_non_const] = EBhDisable; extensionBehavior[E_GL_EXT_nontemporal_keyword] = EBhDisable; extensionBehavior[E_GL_EXT_bfloat16] = EBhDisable; + extensionBehavior[E_GL_EXT_float_e4m3] = EBhDisable; + extensionBehavior[E_GL_EXT_float_e5m2] = EBhDisable; // OVR extensions extensionBehavior[E_GL_OVR_multiview] = EBhDisable; @@ -462,6 +466,7 @@ void TParseVersions::getPreamble(std::string& preamble) "#define GL_QCOM_image_processing 1\n" "#define GL_QCOM_image_processing2 1\n" "#define GL_QCOM_tile_shading 1\n" + "#define GL_QCOM_cooperative_matrix_conversion 1\n" ; if (version >= 300) { @@ -593,6 +598,7 @@ void TParseVersions::getPreamble(std::string& preamble) "#define GL_QCOM_image_processing 1\n" "#define GL_QCOM_image_processing2 1\n" "#define GL_QCOM_tile_shading 1\n" + "#define GL_QCOM_cooperative_matrix_conversion 1\n" "#define GL_EXT_shader_explicit_arithmetic_types 1\n" "#define GL_EXT_shader_explicit_arithmetic_types_int8 1\n" @@ -619,6 +625,8 @@ void TParseVersions::getPreamble(std::string& preamble) "#define GL_EXT_integer_dot_product 1\n" "#define GL_EXT_bfloat16 1\n" + "#define GL_EXT_float_e5m2 1\n" + "#define GL_EXT_float_e4m3 1\n" ; if (spvVersion.spv == 0) { @@ -1303,6 +1311,26 @@ void TParseVersions::bfloat16ScalarVectorCheck(const TSourceLoc& loc, const char } } +void TParseVersions::floate5m2ScalarVectorCheck(const TSourceLoc& loc, const char* op, bool builtIn) +{ + if (!builtIn) { + const char* const extensions[] = { + E_GL_EXT_float_e5m2, + }; + requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op); + } +} + +void TParseVersions::floate4m3ScalarVectorCheck(const TSourceLoc& loc, const char* op, bool builtIn) +{ + if (!builtIn) { + const char* const extensions[] = { + E_GL_EXT_float_e4m3, + }; + requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op); + } +} + // Call for any operation needing GLSL float32 data-type support. void TParseVersions::explicitFloat32Check(const TSourceLoc& loc, const char* op, bool builtIn) { @@ -1439,6 +1467,14 @@ void TParseVersions::coopmatCheck(const TSourceLoc& loc, const char* op, bool bu } } +void TParseVersions::coopmatConverisonCheckQCOM(const TSourceLoc& loc, const char* op, bool builtIn) +{ + if (!builtIn) { + const char* const extensions[] = {E_GL_KHR_cooperative_matrix}; + requireExtensions(loc, sizeof(extensions) / sizeof(extensions[0]), extensions, op); + } +} + void TParseVersions::tensorLayoutViewCheck(const TSourceLoc& loc, const char* op, bool builtIn) { if (!builtIn) { @@ -1463,6 +1499,14 @@ void TParseVersions::intattachmentCheck(const TSourceLoc& loc, const char* op, b } } +void TParseVersions::tensorCheckARM(const TSourceLoc& loc, const char* op, bool builtIn) +{ + if (!builtIn) { + const char* const extensions[] = {E_GL_ARM_tensors}; + requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op); + } +} + // Call for any operation removed because SPIR-V is in use. void TParseVersions::spvRemoved(const TSourceLoc& loc, const char* op) { diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Versions.h b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Versions.h index bf7bfc0..8bc4f71 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Versions.h +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/Versions.h @@ -293,6 +293,7 @@ const char* const E_GL_NV_gpu_shader5 = "GL_NV_gpu_sha // ARM const char* const E_GL_ARM_shader_core_builtins = "GL_ARM_shader_core_builtins"; +const char* const E_GL_ARM_tensors = "GL_ARM_tensors"; // Arrays of extensions for the above viewportEXTs duplications @@ -303,6 +304,7 @@ const int Num_viewportEXTs = sizeof(viewportEXTs) / sizeof(viewportEXTs[0]); const char* const E_GL_QCOM_image_processing = "GL_QCOM_image_processing"; const char* const E_GL_QCOM_image_processing2 = "GL_QCOM_image_processing2"; const char* const E_GL_QCOM_tile_shading = "GL_QCOM_tile_shading"; +const char* const E_GL_QCOM_cooperative_matrix_conversion = "GL_QCOM_cooperative_matrix_conversion"; // AEP const char* const E_GL_ANDROID_extension_pack_es31a = "GL_ANDROID_extension_pack_es31a"; @@ -359,6 +361,8 @@ const char* const E_GL_EXT_texture_shadow_lod = "GL_EXT_texture_shadow_lod"; const char* const E_GL_EXT_integer_dot_product = "GL_EXT_integer_dot_product"; const char* const E_GL_EXT_bfloat16 = "GL_EXT_bfloat16"; +const char* const E_GL_EXT_float_e5m2 = "GL_EXT_float_e5m2"; +const char* const E_GL_EXT_float_e4m3 = "GL_EXT_float_e4m3"; // Arrays of extensions for the above AEP duplications diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/glslang.y b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/glslang.y index 006ca16..e9b1aac 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/glslang.y +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/glslang.y @@ -146,7 +146,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %token UTEXTURE2D UTEXTURE3D UTEXTURECUBE UTEXTURE2DARRAY %token ATTRIBUTE VARYING -%token BFLOAT16_T FLOAT16_T FLOAT32_T DOUBLE FLOAT64_T +%token FLOATE5M2_T FLOATE4M3_T BFLOAT16_T FLOAT16_T FLOAT32_T DOUBLE FLOAT64_T %token INT64_T UINT64_T INT32_T UINT32_T INT16_T UINT16_T INT8_T UINT8_T %token I64VEC2 I64VEC3 I64VEC4 %token U64VEC2 U64VEC3 U64VEC4 @@ -158,6 +158,8 @@ extern int yylex(YYSTYPE*, TParseContext&); %token U8VEC2 U8VEC3 U8VEC4 %token DVEC2 DVEC3 DVEC4 DMAT2 DMAT3 DMAT4 %token BF16VEC2 BF16VEC3 BF16VEC4 +%token FE5M2VEC2 FE5M2VEC3 FE5M2VEC4 +%token FE4M3VEC2 FE4M3VEC3 FE4M3VEC4 %token F16VEC2 F16VEC3 F16VEC4 F16MAT2 F16MAT3 F16MAT4 %token F32VEC2 F32VEC3 F32VEC4 F32MAT2 F32MAT3 F32MAT4 %token F64VEC2 F64VEC3 F64VEC4 F64MAT2 F64MAT3 F64MAT4 @@ -182,6 +184,7 @@ extern int yylex(YYSTYPE*, TParseContext&); %token COOPVECNV %token HITOBJECTNV HITOBJECTATTRNV %token TENSORLAYOUTNV TENSORVIEWNV +%token TENSORARM // combined image/sampler %token SAMPLERCUBEARRAY SAMPLERCUBEARRAYSHADOW @@ -925,15 +928,9 @@ declaration parseContext.updateStandaloneQualifierDefaults($1.loc, $1); $$ = 0; } - | type_qualifier IDENTIFIER SEMICOLON { + | type_qualifier identifier_list SEMICOLON { parseContext.checkNoShaderLayouts($1.loc, $1.shaderQualifiers); - parseContext.addQualifierToExisting($1.loc, $1.qualifier, *$2.string); - $$ = 0; - } - | type_qualifier IDENTIFIER identifier_list SEMICOLON { - parseContext.checkNoShaderLayouts($1.loc, $1.shaderQualifiers); - $3->push_back($2.string); - parseContext.addQualifierToExisting($1.loc, $1.qualifier, *$3); + parseContext.addQualifierToExisting($1.loc, $1.qualifier, *$2); $$ = 0; } ; @@ -950,9 +947,9 @@ block_structure } identifier_list - : COMMA IDENTIFIER { + : IDENTIFIER { $$ = new TIdentifierList; - $$->push_back($2.string); + $$->push_back($1.string); } | identifier_list COMMA IDENTIFIER { $$ = $1; @@ -1037,6 +1034,10 @@ function_header_with_parameters parseContext.vkRelaxedRemapFunctionParameter($1, $3.param); } } + | function_header_with_parameters COMMA DOT DOT DOT { + $$ = $1; + parseContext.makeVariadic($1, $3.loc); + } ; function_header @@ -1097,6 +1098,11 @@ parameter_declarator $$.loc = $2.loc; $$.param = param; } + | type_specifier IDENTIFIER EQUAL initializer { + TParameter param = parseContext.getParamWithDefault($1, $2.string, $4, $3.loc); + $$.loc = $2.loc; + $$.param = param; + } ; parameter_declaration @@ -1107,7 +1113,7 @@ parameter_declaration $$ = $2; if ($1.qualifier.precision != EpqNone) $$.param.type->getQualifier().precision = $1.qualifier.precision; - parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMatOrVec()); + parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->hasTypeParameter()); parseContext.checkNoShaderLayouts($1.loc, $1.shaderQualifiers); parseContext.parameterTypeCheck($2.loc, $1.qualifier.storage, *$$.param.type); @@ -1119,7 +1125,7 @@ parameter_declaration parseContext.parameterTypeCheck($1.loc, EvqIn, *$1.param.type); parseContext.paramCheckFixStorage($1.loc, EvqTemporary, *$$.param.type); - parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMatOrVec()); + parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->hasTypeParameter()); } // // Without name @@ -1128,7 +1134,7 @@ parameter_declaration $$ = $2; if ($1.qualifier.precision != EpqNone) $$.param.type->getQualifier().precision = $1.qualifier.precision; - parseContext.precisionQualifierCheck($1.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMatOrVec()); + parseContext.precisionQualifierCheck($1.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->hasTypeParameter()); parseContext.checkNoShaderLayouts($1.loc, $1.shaderQualifiers); parseContext.parameterTypeCheck($2.loc, $1.qualifier.storage, *$$.param.type); @@ -1139,7 +1145,7 @@ parameter_declaration parseContext.parameterTypeCheck($1.loc, EvqIn, *$1.param.type); parseContext.paramCheckFixStorage($1.loc, EvqTemporary, *$$.param.type); - parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMatOrVec()); + parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->hasTypeParameter()); } ; @@ -1214,7 +1220,7 @@ fully_specified_type parseContext.profileRequires($1.loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); parseContext.profileRequires($1.loc, EEsProfile, 300, 0, "arrayed type"); } - parseContext.precisionQualifierCheck($$.loc, $$.basicType, $$.qualifier, $$.isCoopmatOrvec()); + parseContext.precisionQualifierCheck($$.loc, $$.basicType, $$.qualifier, $$.hasTypeParameter()); } | type_qualifier type_specifier { parseContext.globalQualifierFixCheck($1.loc, $1.qualifier, false, &$2); @@ -1231,7 +1237,7 @@ fully_specified_type parseContext.checkNoShaderLayouts($2.loc, $1.shaderQualifiers); $2.shaderQualifiers.merge($1.shaderQualifiers); parseContext.mergeQualifiers($2.loc, $2.qualifier, $1.qualifier, true); - parseContext.precisionQualifierCheck($2.loc, $2.basicType, $2.qualifier, $2.isCoopmatOrvec()); + parseContext.precisionQualifierCheck($2.loc, $2.basicType, $2.qualifier, $2.hasTypeParameter()); $$ = $2; @@ -1943,6 +1949,16 @@ type_specifier_nonarray $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); $$.basicType = EbtBFloat16; } + | FLOATE5M2_T { + parseContext.floate5m2ScalarVectorCheck($1.loc, "floate5m2_t", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtFloatE5M2; + } + | FLOATE4M3_T { + parseContext.floate4m3ScalarVectorCheck($1.loc, "floate4m3_t", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtFloatE4M3; + } | FLOAT16_T { parseContext.float16ScalarVectorCheck($1.loc, "float16_t", parseContext.symbolTable.atBuiltInLevel()); $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); @@ -2040,6 +2056,42 @@ type_specifier_nonarray $$.basicType = EbtBFloat16; $$.setVector(4); } + | FE5M2VEC2 { + parseContext.floate5m2ScalarVectorCheck($1.loc, "fe5m2 vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtFloatE5M2; + $$.setVector(2); + } + | FE5M2VEC3 { + parseContext.floate5m2ScalarVectorCheck($1.loc, "fe5m2 vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtFloatE5M2; + $$.setVector(3); + } + | FE5M2VEC4 { + parseContext.floate5m2ScalarVectorCheck($1.loc, "fe5m2 vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtFloatE5M2; + $$.setVector(4); + } + | FE4M3VEC2 { + parseContext.floate4m3ScalarVectorCheck($1.loc, "fe4m3 vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtFloatE4M3; + $$.setVector(2); + } + | FE4M3VEC3 { + parseContext.floate4m3ScalarVectorCheck($1.loc, "fe4m3 vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtFloatE4M3; + $$.setVector(3); + } + | FE4M3VEC4 { + parseContext.floate4m3ScalarVectorCheck($1.loc, "fe4m3 vector", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.basicType = EbtFloatE4M3; + $$.setVector(4); + } | F16VEC2 { parseContext.float16ScalarVectorCheck($1.loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); @@ -3585,6 +3637,12 @@ type_specifier_nonarray $$.basicType = EbtCoopvecNV; $$.coopvecNV = true; } + | TENSORARM { + parseContext.tensorCheckARM($1.loc, "tensorARM", parseContext.symbolTable.atBuiltInLevel()); + $$.init($1.loc, parseContext.symbolTable.atGlobalLevel()); + $$.tensorRankARM = 1; // placeholder value + $$.basicType = EbtTensorARM; + } | spirv_type_specifier { parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier"); $$ = $1; @@ -3686,7 +3744,7 @@ struct_declaration $$ = $2; parseContext.voidErrorCheck($1.loc, (*$2)[0].type->getFieldName(), $1.basicType); - parseContext.precisionQualifierCheck($1.loc, $1.basicType, $1.qualifier, $1.isCoopmatOrvec()); + parseContext.precisionQualifierCheck($1.loc, $1.basicType, $1.qualifier, $1.hasTypeParameter()); for (unsigned int i = 0; i < $$->size(); ++i) { TType type($1); @@ -3710,7 +3768,7 @@ struct_declaration parseContext.memberQualifierCheck($1); parseContext.voidErrorCheck($2.loc, (*$3)[0].type->getFieldName(), $2.basicType); parseContext.mergeQualifiers($2.loc, $2.qualifier, $1.qualifier, true); - parseContext.precisionQualifierCheck($2.loc, $2.basicType, $2.qualifier, $2.isCoopmatOrvec()); + parseContext.precisionQualifierCheck($2.loc, $2.basicType, $2.qualifier, $2.hasTypeParameter()); for (unsigned int i = 0; i < $$->size(); ++i) { TType type($2); diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp index 9cc9ac9..a08410b 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp @@ -184,549 +184,558 @@ enum yysymbol_kind_t YYSYMBOL_UTEXTURE2DARRAY = 60, /* UTEXTURE2DARRAY */ YYSYMBOL_ATTRIBUTE = 61, /* ATTRIBUTE */ YYSYMBOL_VARYING = 62, /* VARYING */ - YYSYMBOL_BFLOAT16_T = 63, /* BFLOAT16_T */ - YYSYMBOL_FLOAT16_T = 64, /* FLOAT16_T */ - YYSYMBOL_FLOAT32_T = 65, /* FLOAT32_T */ - YYSYMBOL_DOUBLE = 66, /* DOUBLE */ - YYSYMBOL_FLOAT64_T = 67, /* FLOAT64_T */ - YYSYMBOL_INT64_T = 68, /* INT64_T */ - YYSYMBOL_UINT64_T = 69, /* UINT64_T */ - YYSYMBOL_INT32_T = 70, /* INT32_T */ - YYSYMBOL_UINT32_T = 71, /* UINT32_T */ - YYSYMBOL_INT16_T = 72, /* INT16_T */ - YYSYMBOL_UINT16_T = 73, /* UINT16_T */ - YYSYMBOL_INT8_T = 74, /* INT8_T */ - YYSYMBOL_UINT8_T = 75, /* UINT8_T */ - YYSYMBOL_I64VEC2 = 76, /* I64VEC2 */ - YYSYMBOL_I64VEC3 = 77, /* I64VEC3 */ - YYSYMBOL_I64VEC4 = 78, /* I64VEC4 */ - YYSYMBOL_U64VEC2 = 79, /* U64VEC2 */ - YYSYMBOL_U64VEC3 = 80, /* U64VEC3 */ - YYSYMBOL_U64VEC4 = 81, /* U64VEC4 */ - YYSYMBOL_I32VEC2 = 82, /* I32VEC2 */ - YYSYMBOL_I32VEC3 = 83, /* I32VEC3 */ - YYSYMBOL_I32VEC4 = 84, /* I32VEC4 */ - YYSYMBOL_U32VEC2 = 85, /* U32VEC2 */ - YYSYMBOL_U32VEC3 = 86, /* U32VEC3 */ - YYSYMBOL_U32VEC4 = 87, /* U32VEC4 */ - YYSYMBOL_I16VEC2 = 88, /* I16VEC2 */ - YYSYMBOL_I16VEC3 = 89, /* I16VEC3 */ - YYSYMBOL_I16VEC4 = 90, /* I16VEC4 */ - YYSYMBOL_U16VEC2 = 91, /* U16VEC2 */ - YYSYMBOL_U16VEC3 = 92, /* U16VEC3 */ - YYSYMBOL_U16VEC4 = 93, /* U16VEC4 */ - YYSYMBOL_I8VEC2 = 94, /* I8VEC2 */ - YYSYMBOL_I8VEC3 = 95, /* I8VEC3 */ - YYSYMBOL_I8VEC4 = 96, /* I8VEC4 */ - YYSYMBOL_U8VEC2 = 97, /* U8VEC2 */ - YYSYMBOL_U8VEC3 = 98, /* U8VEC3 */ - YYSYMBOL_U8VEC4 = 99, /* U8VEC4 */ - YYSYMBOL_DVEC2 = 100, /* DVEC2 */ - YYSYMBOL_DVEC3 = 101, /* DVEC3 */ - YYSYMBOL_DVEC4 = 102, /* DVEC4 */ - YYSYMBOL_DMAT2 = 103, /* DMAT2 */ - YYSYMBOL_DMAT3 = 104, /* DMAT3 */ - YYSYMBOL_DMAT4 = 105, /* DMAT4 */ - YYSYMBOL_BF16VEC2 = 106, /* BF16VEC2 */ - YYSYMBOL_BF16VEC3 = 107, /* BF16VEC3 */ - YYSYMBOL_BF16VEC4 = 108, /* BF16VEC4 */ - YYSYMBOL_F16VEC2 = 109, /* F16VEC2 */ - YYSYMBOL_F16VEC3 = 110, /* F16VEC3 */ - YYSYMBOL_F16VEC4 = 111, /* F16VEC4 */ - YYSYMBOL_F16MAT2 = 112, /* F16MAT2 */ - YYSYMBOL_F16MAT3 = 113, /* F16MAT3 */ - YYSYMBOL_F16MAT4 = 114, /* F16MAT4 */ - YYSYMBOL_F32VEC2 = 115, /* F32VEC2 */ - YYSYMBOL_F32VEC3 = 116, /* F32VEC3 */ - YYSYMBOL_F32VEC4 = 117, /* F32VEC4 */ - YYSYMBOL_F32MAT2 = 118, /* F32MAT2 */ - YYSYMBOL_F32MAT3 = 119, /* F32MAT3 */ - YYSYMBOL_F32MAT4 = 120, /* F32MAT4 */ - YYSYMBOL_F64VEC2 = 121, /* F64VEC2 */ - YYSYMBOL_F64VEC3 = 122, /* F64VEC3 */ - YYSYMBOL_F64VEC4 = 123, /* F64VEC4 */ - YYSYMBOL_F64MAT2 = 124, /* F64MAT2 */ - YYSYMBOL_F64MAT3 = 125, /* F64MAT3 */ - YYSYMBOL_F64MAT4 = 126, /* F64MAT4 */ - YYSYMBOL_DMAT2X2 = 127, /* DMAT2X2 */ - YYSYMBOL_DMAT2X3 = 128, /* DMAT2X3 */ - YYSYMBOL_DMAT2X4 = 129, /* DMAT2X4 */ - YYSYMBOL_DMAT3X2 = 130, /* DMAT3X2 */ - YYSYMBOL_DMAT3X3 = 131, /* DMAT3X3 */ - YYSYMBOL_DMAT3X4 = 132, /* DMAT3X4 */ - YYSYMBOL_DMAT4X2 = 133, /* DMAT4X2 */ - YYSYMBOL_DMAT4X3 = 134, /* DMAT4X3 */ - YYSYMBOL_DMAT4X4 = 135, /* DMAT4X4 */ - YYSYMBOL_F16MAT2X2 = 136, /* F16MAT2X2 */ - YYSYMBOL_F16MAT2X3 = 137, /* F16MAT2X3 */ - YYSYMBOL_F16MAT2X4 = 138, /* F16MAT2X4 */ - YYSYMBOL_F16MAT3X2 = 139, /* F16MAT3X2 */ - YYSYMBOL_F16MAT3X3 = 140, /* F16MAT3X3 */ - YYSYMBOL_F16MAT3X4 = 141, /* F16MAT3X4 */ - YYSYMBOL_F16MAT4X2 = 142, /* F16MAT4X2 */ - YYSYMBOL_F16MAT4X3 = 143, /* F16MAT4X3 */ - YYSYMBOL_F16MAT4X4 = 144, /* F16MAT4X4 */ - YYSYMBOL_F32MAT2X2 = 145, /* F32MAT2X2 */ - YYSYMBOL_F32MAT2X3 = 146, /* F32MAT2X3 */ - YYSYMBOL_F32MAT2X4 = 147, /* F32MAT2X4 */ - YYSYMBOL_F32MAT3X2 = 148, /* F32MAT3X2 */ - YYSYMBOL_F32MAT3X3 = 149, /* F32MAT3X3 */ - YYSYMBOL_F32MAT3X4 = 150, /* F32MAT3X4 */ - YYSYMBOL_F32MAT4X2 = 151, /* F32MAT4X2 */ - YYSYMBOL_F32MAT4X3 = 152, /* F32MAT4X3 */ - YYSYMBOL_F32MAT4X4 = 153, /* F32MAT4X4 */ - YYSYMBOL_F64MAT2X2 = 154, /* F64MAT2X2 */ - YYSYMBOL_F64MAT2X3 = 155, /* F64MAT2X3 */ - YYSYMBOL_F64MAT2X4 = 156, /* F64MAT2X4 */ - YYSYMBOL_F64MAT3X2 = 157, /* F64MAT3X2 */ - YYSYMBOL_F64MAT3X3 = 158, /* F64MAT3X3 */ - YYSYMBOL_F64MAT3X4 = 159, /* F64MAT3X4 */ - YYSYMBOL_F64MAT4X2 = 160, /* F64MAT4X2 */ - YYSYMBOL_F64MAT4X3 = 161, /* F64MAT4X3 */ - YYSYMBOL_F64MAT4X4 = 162, /* F64MAT4X4 */ - YYSYMBOL_ATOMIC_UINT = 163, /* ATOMIC_UINT */ - YYSYMBOL_ACCSTRUCTNV = 164, /* ACCSTRUCTNV */ - YYSYMBOL_ACCSTRUCTEXT = 165, /* ACCSTRUCTEXT */ - YYSYMBOL_RAYQUERYEXT = 166, /* RAYQUERYEXT */ - YYSYMBOL_FCOOPMATNV = 167, /* FCOOPMATNV */ - YYSYMBOL_ICOOPMATNV = 168, /* ICOOPMATNV */ - YYSYMBOL_UCOOPMATNV = 169, /* UCOOPMATNV */ - YYSYMBOL_COOPMAT = 170, /* COOPMAT */ - YYSYMBOL_COOPVECNV = 171, /* COOPVECNV */ - YYSYMBOL_HITOBJECTNV = 172, /* HITOBJECTNV */ - YYSYMBOL_HITOBJECTATTRNV = 173, /* HITOBJECTATTRNV */ - YYSYMBOL_TENSORLAYOUTNV = 174, /* TENSORLAYOUTNV */ - YYSYMBOL_TENSORVIEWNV = 175, /* TENSORVIEWNV */ - YYSYMBOL_SAMPLERCUBEARRAY = 176, /* SAMPLERCUBEARRAY */ - YYSYMBOL_SAMPLERCUBEARRAYSHADOW = 177, /* SAMPLERCUBEARRAYSHADOW */ - YYSYMBOL_ISAMPLERCUBEARRAY = 178, /* ISAMPLERCUBEARRAY */ - YYSYMBOL_USAMPLERCUBEARRAY = 179, /* USAMPLERCUBEARRAY */ - YYSYMBOL_SAMPLER1D = 180, /* SAMPLER1D */ - YYSYMBOL_SAMPLER1DARRAY = 181, /* SAMPLER1DARRAY */ - YYSYMBOL_SAMPLER1DARRAYSHADOW = 182, /* SAMPLER1DARRAYSHADOW */ - YYSYMBOL_ISAMPLER1D = 183, /* ISAMPLER1D */ - YYSYMBOL_SAMPLER1DSHADOW = 184, /* SAMPLER1DSHADOW */ - YYSYMBOL_SAMPLER2DRECT = 185, /* SAMPLER2DRECT */ - YYSYMBOL_SAMPLER2DRECTSHADOW = 186, /* SAMPLER2DRECTSHADOW */ - YYSYMBOL_ISAMPLER2DRECT = 187, /* ISAMPLER2DRECT */ - YYSYMBOL_USAMPLER2DRECT = 188, /* USAMPLER2DRECT */ - YYSYMBOL_SAMPLERBUFFER = 189, /* SAMPLERBUFFER */ - YYSYMBOL_ISAMPLERBUFFER = 190, /* ISAMPLERBUFFER */ - YYSYMBOL_USAMPLERBUFFER = 191, /* USAMPLERBUFFER */ - YYSYMBOL_SAMPLER2DMS = 192, /* SAMPLER2DMS */ - YYSYMBOL_ISAMPLER2DMS = 193, /* ISAMPLER2DMS */ - YYSYMBOL_USAMPLER2DMS = 194, /* USAMPLER2DMS */ - YYSYMBOL_SAMPLER2DMSARRAY = 195, /* SAMPLER2DMSARRAY */ - YYSYMBOL_ISAMPLER2DMSARRAY = 196, /* ISAMPLER2DMSARRAY */ - YYSYMBOL_USAMPLER2DMSARRAY = 197, /* USAMPLER2DMSARRAY */ - YYSYMBOL_SAMPLEREXTERNALOES = 198, /* SAMPLEREXTERNALOES */ - YYSYMBOL_SAMPLEREXTERNAL2DY2YEXT = 199, /* SAMPLEREXTERNAL2DY2YEXT */ - YYSYMBOL_ISAMPLER1DARRAY = 200, /* ISAMPLER1DARRAY */ - YYSYMBOL_USAMPLER1D = 201, /* USAMPLER1D */ - YYSYMBOL_USAMPLER1DARRAY = 202, /* USAMPLER1DARRAY */ - YYSYMBOL_F16SAMPLER1D = 203, /* F16SAMPLER1D */ - YYSYMBOL_F16SAMPLER2D = 204, /* F16SAMPLER2D */ - YYSYMBOL_F16SAMPLER3D = 205, /* F16SAMPLER3D */ - YYSYMBOL_F16SAMPLER2DRECT = 206, /* F16SAMPLER2DRECT */ - YYSYMBOL_F16SAMPLERCUBE = 207, /* F16SAMPLERCUBE */ - YYSYMBOL_F16SAMPLER1DARRAY = 208, /* F16SAMPLER1DARRAY */ - YYSYMBOL_F16SAMPLER2DARRAY = 209, /* F16SAMPLER2DARRAY */ - YYSYMBOL_F16SAMPLERCUBEARRAY = 210, /* F16SAMPLERCUBEARRAY */ - YYSYMBOL_F16SAMPLERBUFFER = 211, /* F16SAMPLERBUFFER */ - YYSYMBOL_F16SAMPLER2DMS = 212, /* F16SAMPLER2DMS */ - YYSYMBOL_F16SAMPLER2DMSARRAY = 213, /* F16SAMPLER2DMSARRAY */ - YYSYMBOL_F16SAMPLER1DSHADOW = 214, /* F16SAMPLER1DSHADOW */ - YYSYMBOL_F16SAMPLER2DSHADOW = 215, /* F16SAMPLER2DSHADOW */ - YYSYMBOL_F16SAMPLER1DARRAYSHADOW = 216, /* F16SAMPLER1DARRAYSHADOW */ - YYSYMBOL_F16SAMPLER2DARRAYSHADOW = 217, /* F16SAMPLER2DARRAYSHADOW */ - YYSYMBOL_F16SAMPLER2DRECTSHADOW = 218, /* F16SAMPLER2DRECTSHADOW */ - YYSYMBOL_F16SAMPLERCUBESHADOW = 219, /* F16SAMPLERCUBESHADOW */ - YYSYMBOL_F16SAMPLERCUBEARRAYSHADOW = 220, /* F16SAMPLERCUBEARRAYSHADOW */ - YYSYMBOL_IMAGE1D = 221, /* IMAGE1D */ - YYSYMBOL_IIMAGE1D = 222, /* IIMAGE1D */ - YYSYMBOL_UIMAGE1D = 223, /* UIMAGE1D */ - YYSYMBOL_IMAGE2D = 224, /* IMAGE2D */ - YYSYMBOL_IIMAGE2D = 225, /* IIMAGE2D */ - YYSYMBOL_UIMAGE2D = 226, /* UIMAGE2D */ - YYSYMBOL_IMAGE3D = 227, /* IMAGE3D */ - YYSYMBOL_IIMAGE3D = 228, /* IIMAGE3D */ - YYSYMBOL_UIMAGE3D = 229, /* UIMAGE3D */ - YYSYMBOL_IMAGE2DRECT = 230, /* IMAGE2DRECT */ - YYSYMBOL_IIMAGE2DRECT = 231, /* IIMAGE2DRECT */ - YYSYMBOL_UIMAGE2DRECT = 232, /* UIMAGE2DRECT */ - YYSYMBOL_IMAGECUBE = 233, /* IMAGECUBE */ - YYSYMBOL_IIMAGECUBE = 234, /* IIMAGECUBE */ - YYSYMBOL_UIMAGECUBE = 235, /* UIMAGECUBE */ - YYSYMBOL_IMAGEBUFFER = 236, /* IMAGEBUFFER */ - YYSYMBOL_IIMAGEBUFFER = 237, /* IIMAGEBUFFER */ - YYSYMBOL_UIMAGEBUFFER = 238, /* UIMAGEBUFFER */ - YYSYMBOL_IMAGE1DARRAY = 239, /* IMAGE1DARRAY */ - YYSYMBOL_IIMAGE1DARRAY = 240, /* IIMAGE1DARRAY */ - YYSYMBOL_UIMAGE1DARRAY = 241, /* UIMAGE1DARRAY */ - YYSYMBOL_IMAGE2DARRAY = 242, /* IMAGE2DARRAY */ - YYSYMBOL_IIMAGE2DARRAY = 243, /* IIMAGE2DARRAY */ - YYSYMBOL_UIMAGE2DARRAY = 244, /* UIMAGE2DARRAY */ - YYSYMBOL_IMAGECUBEARRAY = 245, /* IMAGECUBEARRAY */ - YYSYMBOL_IIMAGECUBEARRAY = 246, /* IIMAGECUBEARRAY */ - YYSYMBOL_UIMAGECUBEARRAY = 247, /* UIMAGECUBEARRAY */ - YYSYMBOL_IMAGE2DMS = 248, /* IMAGE2DMS */ - YYSYMBOL_IIMAGE2DMS = 249, /* IIMAGE2DMS */ - YYSYMBOL_UIMAGE2DMS = 250, /* UIMAGE2DMS */ - YYSYMBOL_IMAGE2DMSARRAY = 251, /* IMAGE2DMSARRAY */ - YYSYMBOL_IIMAGE2DMSARRAY = 252, /* IIMAGE2DMSARRAY */ - YYSYMBOL_UIMAGE2DMSARRAY = 253, /* UIMAGE2DMSARRAY */ - YYSYMBOL_F16IMAGE1D = 254, /* F16IMAGE1D */ - YYSYMBOL_F16IMAGE2D = 255, /* F16IMAGE2D */ - YYSYMBOL_F16IMAGE3D = 256, /* F16IMAGE3D */ - YYSYMBOL_F16IMAGE2DRECT = 257, /* F16IMAGE2DRECT */ - YYSYMBOL_F16IMAGECUBE = 258, /* F16IMAGECUBE */ - YYSYMBOL_F16IMAGE1DARRAY = 259, /* F16IMAGE1DARRAY */ - YYSYMBOL_F16IMAGE2DARRAY = 260, /* F16IMAGE2DARRAY */ - YYSYMBOL_F16IMAGECUBEARRAY = 261, /* F16IMAGECUBEARRAY */ - YYSYMBOL_F16IMAGEBUFFER = 262, /* F16IMAGEBUFFER */ - YYSYMBOL_F16IMAGE2DMS = 263, /* F16IMAGE2DMS */ - YYSYMBOL_F16IMAGE2DMSARRAY = 264, /* F16IMAGE2DMSARRAY */ - YYSYMBOL_I64IMAGE1D = 265, /* I64IMAGE1D */ - YYSYMBOL_U64IMAGE1D = 266, /* U64IMAGE1D */ - YYSYMBOL_I64IMAGE2D = 267, /* I64IMAGE2D */ - YYSYMBOL_U64IMAGE2D = 268, /* U64IMAGE2D */ - YYSYMBOL_I64IMAGE3D = 269, /* I64IMAGE3D */ - YYSYMBOL_U64IMAGE3D = 270, /* U64IMAGE3D */ - YYSYMBOL_I64IMAGE2DRECT = 271, /* I64IMAGE2DRECT */ - YYSYMBOL_U64IMAGE2DRECT = 272, /* U64IMAGE2DRECT */ - YYSYMBOL_I64IMAGECUBE = 273, /* I64IMAGECUBE */ - YYSYMBOL_U64IMAGECUBE = 274, /* U64IMAGECUBE */ - YYSYMBOL_I64IMAGEBUFFER = 275, /* I64IMAGEBUFFER */ - YYSYMBOL_U64IMAGEBUFFER = 276, /* U64IMAGEBUFFER */ - YYSYMBOL_I64IMAGE1DARRAY = 277, /* I64IMAGE1DARRAY */ - YYSYMBOL_U64IMAGE1DARRAY = 278, /* U64IMAGE1DARRAY */ - YYSYMBOL_I64IMAGE2DARRAY = 279, /* I64IMAGE2DARRAY */ - YYSYMBOL_U64IMAGE2DARRAY = 280, /* U64IMAGE2DARRAY */ - YYSYMBOL_I64IMAGECUBEARRAY = 281, /* I64IMAGECUBEARRAY */ - YYSYMBOL_U64IMAGECUBEARRAY = 282, /* U64IMAGECUBEARRAY */ - YYSYMBOL_I64IMAGE2DMS = 283, /* I64IMAGE2DMS */ - YYSYMBOL_U64IMAGE2DMS = 284, /* U64IMAGE2DMS */ - YYSYMBOL_I64IMAGE2DMSARRAY = 285, /* I64IMAGE2DMSARRAY */ - YYSYMBOL_U64IMAGE2DMSARRAY = 286, /* U64IMAGE2DMSARRAY */ - YYSYMBOL_TEXTURECUBEARRAY = 287, /* TEXTURECUBEARRAY */ - YYSYMBOL_ITEXTURECUBEARRAY = 288, /* ITEXTURECUBEARRAY */ - YYSYMBOL_UTEXTURECUBEARRAY = 289, /* UTEXTURECUBEARRAY */ - YYSYMBOL_TEXTURE1D = 290, /* TEXTURE1D */ - YYSYMBOL_ITEXTURE1D = 291, /* ITEXTURE1D */ - YYSYMBOL_UTEXTURE1D = 292, /* UTEXTURE1D */ - YYSYMBOL_TEXTURE1DARRAY = 293, /* TEXTURE1DARRAY */ - YYSYMBOL_ITEXTURE1DARRAY = 294, /* ITEXTURE1DARRAY */ - YYSYMBOL_UTEXTURE1DARRAY = 295, /* UTEXTURE1DARRAY */ - YYSYMBOL_TEXTURE2DRECT = 296, /* TEXTURE2DRECT */ - YYSYMBOL_ITEXTURE2DRECT = 297, /* ITEXTURE2DRECT */ - YYSYMBOL_UTEXTURE2DRECT = 298, /* UTEXTURE2DRECT */ - YYSYMBOL_TEXTUREBUFFER = 299, /* TEXTUREBUFFER */ - YYSYMBOL_ITEXTUREBUFFER = 300, /* ITEXTUREBUFFER */ - YYSYMBOL_UTEXTUREBUFFER = 301, /* UTEXTUREBUFFER */ - YYSYMBOL_TEXTURE2DMS = 302, /* TEXTURE2DMS */ - YYSYMBOL_ITEXTURE2DMS = 303, /* ITEXTURE2DMS */ - YYSYMBOL_UTEXTURE2DMS = 304, /* UTEXTURE2DMS */ - YYSYMBOL_TEXTURE2DMSARRAY = 305, /* TEXTURE2DMSARRAY */ - YYSYMBOL_ITEXTURE2DMSARRAY = 306, /* ITEXTURE2DMSARRAY */ - YYSYMBOL_UTEXTURE2DMSARRAY = 307, /* UTEXTURE2DMSARRAY */ - YYSYMBOL_F16TEXTURE1D = 308, /* F16TEXTURE1D */ - YYSYMBOL_F16TEXTURE2D = 309, /* F16TEXTURE2D */ - YYSYMBOL_F16TEXTURE3D = 310, /* F16TEXTURE3D */ - YYSYMBOL_F16TEXTURE2DRECT = 311, /* F16TEXTURE2DRECT */ - YYSYMBOL_F16TEXTURECUBE = 312, /* F16TEXTURECUBE */ - YYSYMBOL_F16TEXTURE1DARRAY = 313, /* F16TEXTURE1DARRAY */ - YYSYMBOL_F16TEXTURE2DARRAY = 314, /* F16TEXTURE2DARRAY */ - YYSYMBOL_F16TEXTURECUBEARRAY = 315, /* F16TEXTURECUBEARRAY */ - YYSYMBOL_F16TEXTUREBUFFER = 316, /* F16TEXTUREBUFFER */ - YYSYMBOL_F16TEXTURE2DMS = 317, /* F16TEXTURE2DMS */ - YYSYMBOL_F16TEXTURE2DMSARRAY = 318, /* F16TEXTURE2DMSARRAY */ - YYSYMBOL_SUBPASSINPUT = 319, /* SUBPASSINPUT */ - YYSYMBOL_SUBPASSINPUTMS = 320, /* SUBPASSINPUTMS */ - YYSYMBOL_ISUBPASSINPUT = 321, /* ISUBPASSINPUT */ - YYSYMBOL_ISUBPASSINPUTMS = 322, /* ISUBPASSINPUTMS */ - YYSYMBOL_USUBPASSINPUT = 323, /* USUBPASSINPUT */ - YYSYMBOL_USUBPASSINPUTMS = 324, /* USUBPASSINPUTMS */ - YYSYMBOL_F16SUBPASSINPUT = 325, /* F16SUBPASSINPUT */ - YYSYMBOL_F16SUBPASSINPUTMS = 326, /* F16SUBPASSINPUTMS */ - YYSYMBOL_SPIRV_INSTRUCTION = 327, /* SPIRV_INSTRUCTION */ - YYSYMBOL_SPIRV_EXECUTION_MODE = 328, /* SPIRV_EXECUTION_MODE */ - YYSYMBOL_SPIRV_EXECUTION_MODE_ID = 329, /* SPIRV_EXECUTION_MODE_ID */ - YYSYMBOL_SPIRV_DECORATE = 330, /* SPIRV_DECORATE */ - YYSYMBOL_SPIRV_DECORATE_ID = 331, /* SPIRV_DECORATE_ID */ - YYSYMBOL_SPIRV_DECORATE_STRING = 332, /* SPIRV_DECORATE_STRING */ - YYSYMBOL_SPIRV_TYPE = 333, /* SPIRV_TYPE */ - YYSYMBOL_SPIRV_STORAGE_CLASS = 334, /* SPIRV_STORAGE_CLASS */ - YYSYMBOL_SPIRV_BY_REFERENCE = 335, /* SPIRV_BY_REFERENCE */ - YYSYMBOL_SPIRV_LITERAL = 336, /* SPIRV_LITERAL */ - YYSYMBOL_ATTACHMENTEXT = 337, /* ATTACHMENTEXT */ - YYSYMBOL_IATTACHMENTEXT = 338, /* IATTACHMENTEXT */ - YYSYMBOL_UATTACHMENTEXT = 339, /* UATTACHMENTEXT */ - YYSYMBOL_LEFT_OP = 340, /* LEFT_OP */ - YYSYMBOL_RIGHT_OP = 341, /* RIGHT_OP */ - YYSYMBOL_INC_OP = 342, /* INC_OP */ - YYSYMBOL_DEC_OP = 343, /* DEC_OP */ - YYSYMBOL_LE_OP = 344, /* LE_OP */ - YYSYMBOL_GE_OP = 345, /* GE_OP */ - YYSYMBOL_EQ_OP = 346, /* EQ_OP */ - YYSYMBOL_NE_OP = 347, /* NE_OP */ - YYSYMBOL_AND_OP = 348, /* AND_OP */ - YYSYMBOL_OR_OP = 349, /* OR_OP */ - YYSYMBOL_XOR_OP = 350, /* XOR_OP */ - YYSYMBOL_MUL_ASSIGN = 351, /* MUL_ASSIGN */ - YYSYMBOL_DIV_ASSIGN = 352, /* DIV_ASSIGN */ - YYSYMBOL_ADD_ASSIGN = 353, /* ADD_ASSIGN */ - YYSYMBOL_MOD_ASSIGN = 354, /* MOD_ASSIGN */ - YYSYMBOL_LEFT_ASSIGN = 355, /* LEFT_ASSIGN */ - YYSYMBOL_RIGHT_ASSIGN = 356, /* RIGHT_ASSIGN */ - YYSYMBOL_AND_ASSIGN = 357, /* AND_ASSIGN */ - YYSYMBOL_XOR_ASSIGN = 358, /* XOR_ASSIGN */ - YYSYMBOL_OR_ASSIGN = 359, /* OR_ASSIGN */ - YYSYMBOL_SUB_ASSIGN = 360, /* SUB_ASSIGN */ - YYSYMBOL_STRING_LITERAL = 361, /* STRING_LITERAL */ - YYSYMBOL_LEFT_PAREN = 362, /* LEFT_PAREN */ - YYSYMBOL_RIGHT_PAREN = 363, /* RIGHT_PAREN */ - YYSYMBOL_LEFT_BRACKET = 364, /* LEFT_BRACKET */ - YYSYMBOL_RIGHT_BRACKET = 365, /* RIGHT_BRACKET */ - YYSYMBOL_LEFT_BRACE = 366, /* LEFT_BRACE */ - YYSYMBOL_RIGHT_BRACE = 367, /* RIGHT_BRACE */ - YYSYMBOL_DOT = 368, /* DOT */ - YYSYMBOL_COMMA = 369, /* COMMA */ - YYSYMBOL_COLON = 370, /* COLON */ - YYSYMBOL_EQUAL = 371, /* EQUAL */ - YYSYMBOL_SEMICOLON = 372, /* SEMICOLON */ - YYSYMBOL_BANG = 373, /* BANG */ - YYSYMBOL_DASH = 374, /* DASH */ - YYSYMBOL_TILDE = 375, /* TILDE */ - YYSYMBOL_PLUS = 376, /* PLUS */ - YYSYMBOL_STAR = 377, /* STAR */ - YYSYMBOL_SLASH = 378, /* SLASH */ - YYSYMBOL_PERCENT = 379, /* PERCENT */ - YYSYMBOL_LEFT_ANGLE = 380, /* LEFT_ANGLE */ - YYSYMBOL_RIGHT_ANGLE = 381, /* RIGHT_ANGLE */ - YYSYMBOL_VERTICAL_BAR = 382, /* VERTICAL_BAR */ - YYSYMBOL_CARET = 383, /* CARET */ - YYSYMBOL_AMPERSAND = 384, /* AMPERSAND */ - YYSYMBOL_QUESTION = 385, /* QUESTION */ - YYSYMBOL_INVARIANT = 386, /* INVARIANT */ - YYSYMBOL_HIGH_PRECISION = 387, /* HIGH_PRECISION */ - YYSYMBOL_MEDIUM_PRECISION = 388, /* MEDIUM_PRECISION */ - YYSYMBOL_LOW_PRECISION = 389, /* LOW_PRECISION */ - YYSYMBOL_PRECISION = 390, /* PRECISION */ - YYSYMBOL_PACKED = 391, /* PACKED */ - YYSYMBOL_RESOURCE = 392, /* RESOURCE */ - YYSYMBOL_SUPERP = 393, /* SUPERP */ - YYSYMBOL_FLOATCONSTANT = 394, /* FLOATCONSTANT */ - YYSYMBOL_INTCONSTANT = 395, /* INTCONSTANT */ - YYSYMBOL_UINTCONSTANT = 396, /* UINTCONSTANT */ - YYSYMBOL_BOOLCONSTANT = 397, /* BOOLCONSTANT */ - YYSYMBOL_IDENTIFIER = 398, /* IDENTIFIER */ - YYSYMBOL_TYPE_NAME = 399, /* TYPE_NAME */ - YYSYMBOL_CENTROID = 400, /* CENTROID */ - YYSYMBOL_IN = 401, /* IN */ - YYSYMBOL_OUT = 402, /* OUT */ - YYSYMBOL_INOUT = 403, /* INOUT */ - YYSYMBOL_STRUCT = 404, /* STRUCT */ - YYSYMBOL_VOID = 405, /* VOID */ - YYSYMBOL_WHILE = 406, /* WHILE */ - YYSYMBOL_BREAK = 407, /* BREAK */ - YYSYMBOL_CONTINUE = 408, /* CONTINUE */ - YYSYMBOL_DO = 409, /* DO */ - YYSYMBOL_ELSE = 410, /* ELSE */ - YYSYMBOL_FOR = 411, /* FOR */ - YYSYMBOL_IF = 412, /* IF */ - YYSYMBOL_DISCARD = 413, /* DISCARD */ - YYSYMBOL_RETURN = 414, /* RETURN */ - YYSYMBOL_SWITCH = 415, /* SWITCH */ - YYSYMBOL_CASE = 416, /* CASE */ - YYSYMBOL_DEFAULT = 417, /* DEFAULT */ - YYSYMBOL_TERMINATE_INVOCATION = 418, /* TERMINATE_INVOCATION */ - YYSYMBOL_TERMINATE_RAY = 419, /* TERMINATE_RAY */ - YYSYMBOL_IGNORE_INTERSECTION = 420, /* IGNORE_INTERSECTION */ - YYSYMBOL_UNIFORM = 421, /* UNIFORM */ - YYSYMBOL_SHARED = 422, /* SHARED */ - YYSYMBOL_BUFFER = 423, /* BUFFER */ - YYSYMBOL_TILEIMAGEEXT = 424, /* TILEIMAGEEXT */ - YYSYMBOL_FLAT = 425, /* FLAT */ - YYSYMBOL_SMOOTH = 426, /* SMOOTH */ - YYSYMBOL_LAYOUT = 427, /* LAYOUT */ - YYSYMBOL_DOUBLECONSTANT = 428, /* DOUBLECONSTANT */ - YYSYMBOL_INT16CONSTANT = 429, /* INT16CONSTANT */ - YYSYMBOL_UINT16CONSTANT = 430, /* UINT16CONSTANT */ - YYSYMBOL_FLOAT16CONSTANT = 431, /* FLOAT16CONSTANT */ - YYSYMBOL_INT32CONSTANT = 432, /* INT32CONSTANT */ - YYSYMBOL_UINT32CONSTANT = 433, /* UINT32CONSTANT */ - YYSYMBOL_INT64CONSTANT = 434, /* INT64CONSTANT */ - YYSYMBOL_UINT64CONSTANT = 435, /* UINT64CONSTANT */ - YYSYMBOL_SUBROUTINE = 436, /* SUBROUTINE */ - YYSYMBOL_DEMOTE = 437, /* DEMOTE */ - YYSYMBOL_FUNCTION = 438, /* FUNCTION */ - YYSYMBOL_PAYLOADNV = 439, /* PAYLOADNV */ - YYSYMBOL_PAYLOADINNV = 440, /* PAYLOADINNV */ - YYSYMBOL_HITATTRNV = 441, /* HITATTRNV */ - YYSYMBOL_CALLDATANV = 442, /* CALLDATANV */ - YYSYMBOL_CALLDATAINNV = 443, /* CALLDATAINNV */ - YYSYMBOL_PAYLOADEXT = 444, /* PAYLOADEXT */ - YYSYMBOL_PAYLOADINEXT = 445, /* PAYLOADINEXT */ - YYSYMBOL_HITATTREXT = 446, /* HITATTREXT */ - YYSYMBOL_CALLDATAEXT = 447, /* CALLDATAEXT */ - YYSYMBOL_CALLDATAINEXT = 448, /* CALLDATAINEXT */ - YYSYMBOL_PATCH = 449, /* PATCH */ - YYSYMBOL_SAMPLE = 450, /* SAMPLE */ - YYSYMBOL_NONUNIFORM = 451, /* NONUNIFORM */ - YYSYMBOL_COHERENT = 452, /* COHERENT */ - YYSYMBOL_VOLATILE = 453, /* VOLATILE */ - YYSYMBOL_RESTRICT = 454, /* RESTRICT */ - YYSYMBOL_READONLY = 455, /* READONLY */ - YYSYMBOL_WRITEONLY = 456, /* WRITEONLY */ - YYSYMBOL_NONTEMPORAL = 457, /* NONTEMPORAL */ - YYSYMBOL_DEVICECOHERENT = 458, /* DEVICECOHERENT */ - YYSYMBOL_QUEUEFAMILYCOHERENT = 459, /* QUEUEFAMILYCOHERENT */ - YYSYMBOL_WORKGROUPCOHERENT = 460, /* WORKGROUPCOHERENT */ - YYSYMBOL_SUBGROUPCOHERENT = 461, /* SUBGROUPCOHERENT */ - YYSYMBOL_NONPRIVATE = 462, /* NONPRIVATE */ - YYSYMBOL_SHADERCALLCOHERENT = 463, /* SHADERCALLCOHERENT */ - YYSYMBOL_NOPERSPECTIVE = 464, /* NOPERSPECTIVE */ - YYSYMBOL_EXPLICITINTERPAMD = 465, /* EXPLICITINTERPAMD */ - YYSYMBOL_PERVERTEXEXT = 466, /* PERVERTEXEXT */ - YYSYMBOL_PERVERTEXNV = 467, /* PERVERTEXNV */ - YYSYMBOL_PERPRIMITIVENV = 468, /* PERPRIMITIVENV */ - YYSYMBOL_PERVIEWNV = 469, /* PERVIEWNV */ - YYSYMBOL_PERTASKNV = 470, /* PERTASKNV */ - YYSYMBOL_PERPRIMITIVEEXT = 471, /* PERPRIMITIVEEXT */ - YYSYMBOL_TASKPAYLOADWORKGROUPEXT = 472, /* TASKPAYLOADWORKGROUPEXT */ - YYSYMBOL_PRECISE = 473, /* PRECISE */ - YYSYMBOL_YYACCEPT = 474, /* $accept */ - YYSYMBOL_variable_identifier = 475, /* variable_identifier */ - YYSYMBOL_primary_expression = 476, /* primary_expression */ - YYSYMBOL_postfix_expression = 477, /* postfix_expression */ - YYSYMBOL_integer_expression = 478, /* integer_expression */ - YYSYMBOL_function_call = 479, /* function_call */ - YYSYMBOL_function_call_or_method = 480, /* function_call_or_method */ - YYSYMBOL_function_call_generic = 481, /* function_call_generic */ - YYSYMBOL_function_call_header_no_parameters = 482, /* function_call_header_no_parameters */ - YYSYMBOL_function_call_header_with_parameters = 483, /* function_call_header_with_parameters */ - YYSYMBOL_function_call_header = 484, /* function_call_header */ - YYSYMBOL_function_identifier = 485, /* function_identifier */ - YYSYMBOL_unary_expression = 486, /* unary_expression */ - YYSYMBOL_unary_operator = 487, /* unary_operator */ - YYSYMBOL_multiplicative_expression = 488, /* multiplicative_expression */ - YYSYMBOL_additive_expression = 489, /* additive_expression */ - YYSYMBOL_shift_expression = 490, /* shift_expression */ - YYSYMBOL_relational_expression = 491, /* relational_expression */ - YYSYMBOL_equality_expression = 492, /* equality_expression */ - YYSYMBOL_and_expression = 493, /* and_expression */ - YYSYMBOL_exclusive_or_expression = 494, /* exclusive_or_expression */ - YYSYMBOL_inclusive_or_expression = 495, /* inclusive_or_expression */ - YYSYMBOL_logical_and_expression = 496, /* logical_and_expression */ - YYSYMBOL_logical_xor_expression = 497, /* logical_xor_expression */ - YYSYMBOL_logical_or_expression = 498, /* logical_or_expression */ - YYSYMBOL_conditional_expression = 499, /* conditional_expression */ - YYSYMBOL_500_1 = 500, /* $@1 */ - YYSYMBOL_assignment_expression = 501, /* assignment_expression */ - YYSYMBOL_assignment_operator = 502, /* assignment_operator */ - YYSYMBOL_expression = 503, /* expression */ - YYSYMBOL_constant_expression = 504, /* constant_expression */ - YYSYMBOL_declaration = 505, /* declaration */ - YYSYMBOL_block_structure = 506, /* block_structure */ - YYSYMBOL_507_2 = 507, /* $@2 */ - YYSYMBOL_identifier_list = 508, /* identifier_list */ - YYSYMBOL_function_prototype = 509, /* function_prototype */ - YYSYMBOL_function_declarator = 510, /* function_declarator */ - YYSYMBOL_function_header_with_parameters = 511, /* function_header_with_parameters */ - YYSYMBOL_function_header = 512, /* function_header */ - YYSYMBOL_parameter_declarator = 513, /* parameter_declarator */ - YYSYMBOL_parameter_declaration = 514, /* parameter_declaration */ - YYSYMBOL_parameter_type_specifier = 515, /* parameter_type_specifier */ - YYSYMBOL_init_declarator_list = 516, /* init_declarator_list */ - YYSYMBOL_single_declaration = 517, /* single_declaration */ - YYSYMBOL_fully_specified_type = 518, /* fully_specified_type */ - YYSYMBOL_invariant_qualifier = 519, /* invariant_qualifier */ - YYSYMBOL_interpolation_qualifier = 520, /* interpolation_qualifier */ - YYSYMBOL_layout_qualifier = 521, /* layout_qualifier */ - YYSYMBOL_layout_qualifier_id_list = 522, /* layout_qualifier_id_list */ - YYSYMBOL_layout_qualifier_id = 523, /* layout_qualifier_id */ - YYSYMBOL_precise_qualifier = 524, /* precise_qualifier */ - YYSYMBOL_type_qualifier = 525, /* type_qualifier */ - YYSYMBOL_single_type_qualifier = 526, /* single_type_qualifier */ - YYSYMBOL_storage_qualifier = 527, /* storage_qualifier */ - YYSYMBOL_non_uniform_qualifier = 528, /* non_uniform_qualifier */ - YYSYMBOL_type_name_list = 529, /* type_name_list */ - YYSYMBOL_type_specifier = 530, /* type_specifier */ - YYSYMBOL_array_specifier = 531, /* array_specifier */ - YYSYMBOL_type_parameter_specifier_opt = 532, /* type_parameter_specifier_opt */ - YYSYMBOL_type_parameter_specifier = 533, /* type_parameter_specifier */ - YYSYMBOL_type_parameter_specifier_list = 534, /* type_parameter_specifier_list */ - YYSYMBOL_type_specifier_nonarray = 535, /* type_specifier_nonarray */ - YYSYMBOL_precision_qualifier = 536, /* precision_qualifier */ - YYSYMBOL_struct_specifier = 537, /* struct_specifier */ - YYSYMBOL_538_3 = 538, /* $@3 */ - YYSYMBOL_539_4 = 539, /* $@4 */ - YYSYMBOL_struct_declaration_list = 540, /* struct_declaration_list */ - YYSYMBOL_struct_declaration = 541, /* struct_declaration */ - YYSYMBOL_struct_declarator_list = 542, /* struct_declarator_list */ - YYSYMBOL_struct_declarator = 543, /* struct_declarator */ - YYSYMBOL_initializer = 544, /* initializer */ - YYSYMBOL_initializer_list = 545, /* initializer_list */ - YYSYMBOL_declaration_statement = 546, /* declaration_statement */ - YYSYMBOL_statement = 547, /* statement */ - YYSYMBOL_simple_statement = 548, /* simple_statement */ - YYSYMBOL_demote_statement = 549, /* demote_statement */ - YYSYMBOL_compound_statement = 550, /* compound_statement */ - YYSYMBOL_551_5 = 551, /* $@5 */ - YYSYMBOL_552_6 = 552, /* $@6 */ - YYSYMBOL_statement_no_new_scope = 553, /* statement_no_new_scope */ - YYSYMBOL_statement_scoped = 554, /* statement_scoped */ - YYSYMBOL_555_7 = 555, /* $@7 */ - YYSYMBOL_556_8 = 556, /* $@8 */ - YYSYMBOL_compound_statement_no_new_scope = 557, /* compound_statement_no_new_scope */ - YYSYMBOL_statement_list = 558, /* statement_list */ - YYSYMBOL_expression_statement = 559, /* expression_statement */ - YYSYMBOL_selection_statement = 560, /* selection_statement */ - YYSYMBOL_selection_statement_nonattributed = 561, /* selection_statement_nonattributed */ - YYSYMBOL_selection_rest_statement = 562, /* selection_rest_statement */ - YYSYMBOL_condition = 563, /* condition */ - YYSYMBOL_switch_statement = 564, /* switch_statement */ - YYSYMBOL_switch_statement_nonattributed = 565, /* switch_statement_nonattributed */ - YYSYMBOL_566_9 = 566, /* $@9 */ - YYSYMBOL_switch_statement_list = 567, /* switch_statement_list */ - YYSYMBOL_case_label = 568, /* case_label */ - YYSYMBOL_iteration_statement = 569, /* iteration_statement */ - YYSYMBOL_iteration_statement_nonattributed = 570, /* iteration_statement_nonattributed */ - YYSYMBOL_571_10 = 571, /* $@10 */ - YYSYMBOL_572_11 = 572, /* $@11 */ - YYSYMBOL_573_12 = 573, /* $@12 */ - YYSYMBOL_for_init_statement = 574, /* for_init_statement */ - YYSYMBOL_conditionopt = 575, /* conditionopt */ - YYSYMBOL_for_rest_statement = 576, /* for_rest_statement */ - YYSYMBOL_jump_statement = 577, /* jump_statement */ - YYSYMBOL_translation_unit = 578, /* translation_unit */ - YYSYMBOL_external_declaration = 579, /* external_declaration */ - YYSYMBOL_function_definition = 580, /* function_definition */ - YYSYMBOL_581_13 = 581, /* $@13 */ - YYSYMBOL_attribute = 582, /* attribute */ - YYSYMBOL_attribute_list = 583, /* attribute_list */ - YYSYMBOL_single_attribute = 584, /* single_attribute */ - YYSYMBOL_spirv_requirements_list = 585, /* spirv_requirements_list */ - YYSYMBOL_spirv_requirements_parameter = 586, /* spirv_requirements_parameter */ - YYSYMBOL_spirv_extension_list = 587, /* spirv_extension_list */ - YYSYMBOL_spirv_capability_list = 588, /* spirv_capability_list */ - YYSYMBOL_spirv_execution_mode_qualifier = 589, /* spirv_execution_mode_qualifier */ - YYSYMBOL_spirv_execution_mode_parameter_list = 590, /* spirv_execution_mode_parameter_list */ - YYSYMBOL_spirv_execution_mode_parameter = 591, /* spirv_execution_mode_parameter */ - YYSYMBOL_spirv_execution_mode_id_parameter_list = 592, /* spirv_execution_mode_id_parameter_list */ - YYSYMBOL_spirv_storage_class_qualifier = 593, /* spirv_storage_class_qualifier */ - YYSYMBOL_spirv_decorate_qualifier = 594, /* spirv_decorate_qualifier */ - YYSYMBOL_spirv_decorate_parameter_list = 595, /* spirv_decorate_parameter_list */ - YYSYMBOL_spirv_decorate_parameter = 596, /* spirv_decorate_parameter */ - YYSYMBOL_spirv_decorate_id_parameter_list = 597, /* spirv_decorate_id_parameter_list */ - YYSYMBOL_spirv_decorate_id_parameter = 598, /* spirv_decorate_id_parameter */ - YYSYMBOL_spirv_decorate_string_parameter_list = 599, /* spirv_decorate_string_parameter_list */ - YYSYMBOL_spirv_type_specifier = 600, /* spirv_type_specifier */ - YYSYMBOL_spirv_type_parameter_list = 601, /* spirv_type_parameter_list */ - YYSYMBOL_spirv_type_parameter = 602, /* spirv_type_parameter */ - YYSYMBOL_spirv_instruction_qualifier = 603, /* spirv_instruction_qualifier */ - YYSYMBOL_spirv_instruction_qualifier_list = 604, /* spirv_instruction_qualifier_list */ - YYSYMBOL_spirv_instruction_qualifier_id = 605 /* spirv_instruction_qualifier_id */ + YYSYMBOL_FLOATE5M2_T = 63, /* FLOATE5M2_T */ + YYSYMBOL_FLOATE4M3_T = 64, /* FLOATE4M3_T */ + YYSYMBOL_BFLOAT16_T = 65, /* BFLOAT16_T */ + YYSYMBOL_FLOAT16_T = 66, /* FLOAT16_T */ + YYSYMBOL_FLOAT32_T = 67, /* FLOAT32_T */ + YYSYMBOL_DOUBLE = 68, /* DOUBLE */ + YYSYMBOL_FLOAT64_T = 69, /* FLOAT64_T */ + YYSYMBOL_INT64_T = 70, /* INT64_T */ + YYSYMBOL_UINT64_T = 71, /* UINT64_T */ + YYSYMBOL_INT32_T = 72, /* INT32_T */ + YYSYMBOL_UINT32_T = 73, /* UINT32_T */ + YYSYMBOL_INT16_T = 74, /* INT16_T */ + YYSYMBOL_UINT16_T = 75, /* UINT16_T */ + YYSYMBOL_INT8_T = 76, /* INT8_T */ + YYSYMBOL_UINT8_T = 77, /* UINT8_T */ + YYSYMBOL_I64VEC2 = 78, /* I64VEC2 */ + YYSYMBOL_I64VEC3 = 79, /* I64VEC3 */ + YYSYMBOL_I64VEC4 = 80, /* I64VEC4 */ + YYSYMBOL_U64VEC2 = 81, /* U64VEC2 */ + YYSYMBOL_U64VEC3 = 82, /* U64VEC3 */ + YYSYMBOL_U64VEC4 = 83, /* U64VEC4 */ + YYSYMBOL_I32VEC2 = 84, /* I32VEC2 */ + YYSYMBOL_I32VEC3 = 85, /* I32VEC3 */ + YYSYMBOL_I32VEC4 = 86, /* I32VEC4 */ + YYSYMBOL_U32VEC2 = 87, /* U32VEC2 */ + YYSYMBOL_U32VEC3 = 88, /* U32VEC3 */ + YYSYMBOL_U32VEC4 = 89, /* U32VEC4 */ + YYSYMBOL_I16VEC2 = 90, /* I16VEC2 */ + YYSYMBOL_I16VEC3 = 91, /* I16VEC3 */ + YYSYMBOL_I16VEC4 = 92, /* I16VEC4 */ + YYSYMBOL_U16VEC2 = 93, /* U16VEC2 */ + YYSYMBOL_U16VEC3 = 94, /* U16VEC3 */ + YYSYMBOL_U16VEC4 = 95, /* U16VEC4 */ + YYSYMBOL_I8VEC2 = 96, /* I8VEC2 */ + YYSYMBOL_I8VEC3 = 97, /* I8VEC3 */ + YYSYMBOL_I8VEC4 = 98, /* I8VEC4 */ + YYSYMBOL_U8VEC2 = 99, /* U8VEC2 */ + YYSYMBOL_U8VEC3 = 100, /* U8VEC3 */ + YYSYMBOL_U8VEC4 = 101, /* U8VEC4 */ + YYSYMBOL_DVEC2 = 102, /* DVEC2 */ + YYSYMBOL_DVEC3 = 103, /* DVEC3 */ + YYSYMBOL_DVEC4 = 104, /* DVEC4 */ + YYSYMBOL_DMAT2 = 105, /* DMAT2 */ + YYSYMBOL_DMAT3 = 106, /* DMAT3 */ + YYSYMBOL_DMAT4 = 107, /* DMAT4 */ + YYSYMBOL_BF16VEC2 = 108, /* BF16VEC2 */ + YYSYMBOL_BF16VEC3 = 109, /* BF16VEC3 */ + YYSYMBOL_BF16VEC4 = 110, /* BF16VEC4 */ + YYSYMBOL_FE5M2VEC2 = 111, /* FE5M2VEC2 */ + YYSYMBOL_FE5M2VEC3 = 112, /* FE5M2VEC3 */ + YYSYMBOL_FE5M2VEC4 = 113, /* FE5M2VEC4 */ + YYSYMBOL_FE4M3VEC2 = 114, /* FE4M3VEC2 */ + YYSYMBOL_FE4M3VEC3 = 115, /* FE4M3VEC3 */ + YYSYMBOL_FE4M3VEC4 = 116, /* FE4M3VEC4 */ + YYSYMBOL_F16VEC2 = 117, /* F16VEC2 */ + YYSYMBOL_F16VEC3 = 118, /* F16VEC3 */ + YYSYMBOL_F16VEC4 = 119, /* F16VEC4 */ + YYSYMBOL_F16MAT2 = 120, /* F16MAT2 */ + YYSYMBOL_F16MAT3 = 121, /* F16MAT3 */ + YYSYMBOL_F16MAT4 = 122, /* F16MAT4 */ + YYSYMBOL_F32VEC2 = 123, /* F32VEC2 */ + YYSYMBOL_F32VEC3 = 124, /* F32VEC3 */ + YYSYMBOL_F32VEC4 = 125, /* F32VEC4 */ + YYSYMBOL_F32MAT2 = 126, /* F32MAT2 */ + YYSYMBOL_F32MAT3 = 127, /* F32MAT3 */ + YYSYMBOL_F32MAT4 = 128, /* F32MAT4 */ + YYSYMBOL_F64VEC2 = 129, /* F64VEC2 */ + YYSYMBOL_F64VEC3 = 130, /* F64VEC3 */ + YYSYMBOL_F64VEC4 = 131, /* F64VEC4 */ + YYSYMBOL_F64MAT2 = 132, /* F64MAT2 */ + YYSYMBOL_F64MAT3 = 133, /* F64MAT3 */ + YYSYMBOL_F64MAT4 = 134, /* F64MAT4 */ + YYSYMBOL_DMAT2X2 = 135, /* DMAT2X2 */ + YYSYMBOL_DMAT2X3 = 136, /* DMAT2X3 */ + YYSYMBOL_DMAT2X4 = 137, /* DMAT2X4 */ + YYSYMBOL_DMAT3X2 = 138, /* DMAT3X2 */ + YYSYMBOL_DMAT3X3 = 139, /* DMAT3X3 */ + YYSYMBOL_DMAT3X4 = 140, /* DMAT3X4 */ + YYSYMBOL_DMAT4X2 = 141, /* DMAT4X2 */ + YYSYMBOL_DMAT4X3 = 142, /* DMAT4X3 */ + YYSYMBOL_DMAT4X4 = 143, /* DMAT4X4 */ + YYSYMBOL_F16MAT2X2 = 144, /* F16MAT2X2 */ + YYSYMBOL_F16MAT2X3 = 145, /* F16MAT2X3 */ + YYSYMBOL_F16MAT2X4 = 146, /* F16MAT2X4 */ + YYSYMBOL_F16MAT3X2 = 147, /* F16MAT3X2 */ + YYSYMBOL_F16MAT3X3 = 148, /* F16MAT3X3 */ + YYSYMBOL_F16MAT3X4 = 149, /* F16MAT3X4 */ + YYSYMBOL_F16MAT4X2 = 150, /* F16MAT4X2 */ + YYSYMBOL_F16MAT4X3 = 151, /* F16MAT4X3 */ + YYSYMBOL_F16MAT4X4 = 152, /* F16MAT4X4 */ + YYSYMBOL_F32MAT2X2 = 153, /* F32MAT2X2 */ + YYSYMBOL_F32MAT2X3 = 154, /* F32MAT2X3 */ + YYSYMBOL_F32MAT2X4 = 155, /* F32MAT2X4 */ + YYSYMBOL_F32MAT3X2 = 156, /* F32MAT3X2 */ + YYSYMBOL_F32MAT3X3 = 157, /* F32MAT3X3 */ + YYSYMBOL_F32MAT3X4 = 158, /* F32MAT3X4 */ + YYSYMBOL_F32MAT4X2 = 159, /* F32MAT4X2 */ + YYSYMBOL_F32MAT4X3 = 160, /* F32MAT4X3 */ + YYSYMBOL_F32MAT4X4 = 161, /* F32MAT4X4 */ + YYSYMBOL_F64MAT2X2 = 162, /* F64MAT2X2 */ + YYSYMBOL_F64MAT2X3 = 163, /* F64MAT2X3 */ + YYSYMBOL_F64MAT2X4 = 164, /* F64MAT2X4 */ + YYSYMBOL_F64MAT3X2 = 165, /* F64MAT3X2 */ + YYSYMBOL_F64MAT3X3 = 166, /* F64MAT3X3 */ + YYSYMBOL_F64MAT3X4 = 167, /* F64MAT3X4 */ + YYSYMBOL_F64MAT4X2 = 168, /* F64MAT4X2 */ + YYSYMBOL_F64MAT4X3 = 169, /* F64MAT4X3 */ + YYSYMBOL_F64MAT4X4 = 170, /* F64MAT4X4 */ + YYSYMBOL_ATOMIC_UINT = 171, /* ATOMIC_UINT */ + YYSYMBOL_ACCSTRUCTNV = 172, /* ACCSTRUCTNV */ + YYSYMBOL_ACCSTRUCTEXT = 173, /* ACCSTRUCTEXT */ + YYSYMBOL_RAYQUERYEXT = 174, /* RAYQUERYEXT */ + YYSYMBOL_FCOOPMATNV = 175, /* FCOOPMATNV */ + YYSYMBOL_ICOOPMATNV = 176, /* ICOOPMATNV */ + YYSYMBOL_UCOOPMATNV = 177, /* UCOOPMATNV */ + YYSYMBOL_COOPMAT = 178, /* COOPMAT */ + YYSYMBOL_COOPVECNV = 179, /* COOPVECNV */ + YYSYMBOL_HITOBJECTNV = 180, /* HITOBJECTNV */ + YYSYMBOL_HITOBJECTATTRNV = 181, /* HITOBJECTATTRNV */ + YYSYMBOL_TENSORLAYOUTNV = 182, /* TENSORLAYOUTNV */ + YYSYMBOL_TENSORVIEWNV = 183, /* TENSORVIEWNV */ + YYSYMBOL_TENSORARM = 184, /* TENSORARM */ + YYSYMBOL_SAMPLERCUBEARRAY = 185, /* SAMPLERCUBEARRAY */ + YYSYMBOL_SAMPLERCUBEARRAYSHADOW = 186, /* SAMPLERCUBEARRAYSHADOW */ + YYSYMBOL_ISAMPLERCUBEARRAY = 187, /* ISAMPLERCUBEARRAY */ + YYSYMBOL_USAMPLERCUBEARRAY = 188, /* USAMPLERCUBEARRAY */ + YYSYMBOL_SAMPLER1D = 189, /* SAMPLER1D */ + YYSYMBOL_SAMPLER1DARRAY = 190, /* SAMPLER1DARRAY */ + YYSYMBOL_SAMPLER1DARRAYSHADOW = 191, /* SAMPLER1DARRAYSHADOW */ + YYSYMBOL_ISAMPLER1D = 192, /* ISAMPLER1D */ + YYSYMBOL_SAMPLER1DSHADOW = 193, /* SAMPLER1DSHADOW */ + YYSYMBOL_SAMPLER2DRECT = 194, /* SAMPLER2DRECT */ + YYSYMBOL_SAMPLER2DRECTSHADOW = 195, /* SAMPLER2DRECTSHADOW */ + YYSYMBOL_ISAMPLER2DRECT = 196, /* ISAMPLER2DRECT */ + YYSYMBOL_USAMPLER2DRECT = 197, /* USAMPLER2DRECT */ + YYSYMBOL_SAMPLERBUFFER = 198, /* SAMPLERBUFFER */ + YYSYMBOL_ISAMPLERBUFFER = 199, /* ISAMPLERBUFFER */ + YYSYMBOL_USAMPLERBUFFER = 200, /* USAMPLERBUFFER */ + YYSYMBOL_SAMPLER2DMS = 201, /* SAMPLER2DMS */ + YYSYMBOL_ISAMPLER2DMS = 202, /* ISAMPLER2DMS */ + YYSYMBOL_USAMPLER2DMS = 203, /* USAMPLER2DMS */ + YYSYMBOL_SAMPLER2DMSARRAY = 204, /* SAMPLER2DMSARRAY */ + YYSYMBOL_ISAMPLER2DMSARRAY = 205, /* ISAMPLER2DMSARRAY */ + YYSYMBOL_USAMPLER2DMSARRAY = 206, /* USAMPLER2DMSARRAY */ + YYSYMBOL_SAMPLEREXTERNALOES = 207, /* SAMPLEREXTERNALOES */ + YYSYMBOL_SAMPLEREXTERNAL2DY2YEXT = 208, /* SAMPLEREXTERNAL2DY2YEXT */ + YYSYMBOL_ISAMPLER1DARRAY = 209, /* ISAMPLER1DARRAY */ + YYSYMBOL_USAMPLER1D = 210, /* USAMPLER1D */ + YYSYMBOL_USAMPLER1DARRAY = 211, /* USAMPLER1DARRAY */ + YYSYMBOL_F16SAMPLER1D = 212, /* F16SAMPLER1D */ + YYSYMBOL_F16SAMPLER2D = 213, /* F16SAMPLER2D */ + YYSYMBOL_F16SAMPLER3D = 214, /* F16SAMPLER3D */ + YYSYMBOL_F16SAMPLER2DRECT = 215, /* F16SAMPLER2DRECT */ + YYSYMBOL_F16SAMPLERCUBE = 216, /* F16SAMPLERCUBE */ + YYSYMBOL_F16SAMPLER1DARRAY = 217, /* F16SAMPLER1DARRAY */ + YYSYMBOL_F16SAMPLER2DARRAY = 218, /* F16SAMPLER2DARRAY */ + YYSYMBOL_F16SAMPLERCUBEARRAY = 219, /* F16SAMPLERCUBEARRAY */ + YYSYMBOL_F16SAMPLERBUFFER = 220, /* F16SAMPLERBUFFER */ + YYSYMBOL_F16SAMPLER2DMS = 221, /* F16SAMPLER2DMS */ + YYSYMBOL_F16SAMPLER2DMSARRAY = 222, /* F16SAMPLER2DMSARRAY */ + YYSYMBOL_F16SAMPLER1DSHADOW = 223, /* F16SAMPLER1DSHADOW */ + YYSYMBOL_F16SAMPLER2DSHADOW = 224, /* F16SAMPLER2DSHADOW */ + YYSYMBOL_F16SAMPLER1DARRAYSHADOW = 225, /* F16SAMPLER1DARRAYSHADOW */ + YYSYMBOL_F16SAMPLER2DARRAYSHADOW = 226, /* F16SAMPLER2DARRAYSHADOW */ + YYSYMBOL_F16SAMPLER2DRECTSHADOW = 227, /* F16SAMPLER2DRECTSHADOW */ + YYSYMBOL_F16SAMPLERCUBESHADOW = 228, /* F16SAMPLERCUBESHADOW */ + YYSYMBOL_F16SAMPLERCUBEARRAYSHADOW = 229, /* F16SAMPLERCUBEARRAYSHADOW */ + YYSYMBOL_IMAGE1D = 230, /* IMAGE1D */ + YYSYMBOL_IIMAGE1D = 231, /* IIMAGE1D */ + YYSYMBOL_UIMAGE1D = 232, /* UIMAGE1D */ + YYSYMBOL_IMAGE2D = 233, /* IMAGE2D */ + YYSYMBOL_IIMAGE2D = 234, /* IIMAGE2D */ + YYSYMBOL_UIMAGE2D = 235, /* UIMAGE2D */ + YYSYMBOL_IMAGE3D = 236, /* IMAGE3D */ + YYSYMBOL_IIMAGE3D = 237, /* IIMAGE3D */ + YYSYMBOL_UIMAGE3D = 238, /* UIMAGE3D */ + YYSYMBOL_IMAGE2DRECT = 239, /* IMAGE2DRECT */ + YYSYMBOL_IIMAGE2DRECT = 240, /* IIMAGE2DRECT */ + YYSYMBOL_UIMAGE2DRECT = 241, /* UIMAGE2DRECT */ + YYSYMBOL_IMAGECUBE = 242, /* IMAGECUBE */ + YYSYMBOL_IIMAGECUBE = 243, /* IIMAGECUBE */ + YYSYMBOL_UIMAGECUBE = 244, /* UIMAGECUBE */ + YYSYMBOL_IMAGEBUFFER = 245, /* IMAGEBUFFER */ + YYSYMBOL_IIMAGEBUFFER = 246, /* IIMAGEBUFFER */ + YYSYMBOL_UIMAGEBUFFER = 247, /* UIMAGEBUFFER */ + YYSYMBOL_IMAGE1DARRAY = 248, /* IMAGE1DARRAY */ + YYSYMBOL_IIMAGE1DARRAY = 249, /* IIMAGE1DARRAY */ + YYSYMBOL_UIMAGE1DARRAY = 250, /* UIMAGE1DARRAY */ + YYSYMBOL_IMAGE2DARRAY = 251, /* IMAGE2DARRAY */ + YYSYMBOL_IIMAGE2DARRAY = 252, /* IIMAGE2DARRAY */ + YYSYMBOL_UIMAGE2DARRAY = 253, /* UIMAGE2DARRAY */ + YYSYMBOL_IMAGECUBEARRAY = 254, /* IMAGECUBEARRAY */ + YYSYMBOL_IIMAGECUBEARRAY = 255, /* IIMAGECUBEARRAY */ + YYSYMBOL_UIMAGECUBEARRAY = 256, /* UIMAGECUBEARRAY */ + YYSYMBOL_IMAGE2DMS = 257, /* IMAGE2DMS */ + YYSYMBOL_IIMAGE2DMS = 258, /* IIMAGE2DMS */ + YYSYMBOL_UIMAGE2DMS = 259, /* UIMAGE2DMS */ + YYSYMBOL_IMAGE2DMSARRAY = 260, /* IMAGE2DMSARRAY */ + YYSYMBOL_IIMAGE2DMSARRAY = 261, /* IIMAGE2DMSARRAY */ + YYSYMBOL_UIMAGE2DMSARRAY = 262, /* UIMAGE2DMSARRAY */ + YYSYMBOL_F16IMAGE1D = 263, /* F16IMAGE1D */ + YYSYMBOL_F16IMAGE2D = 264, /* F16IMAGE2D */ + YYSYMBOL_F16IMAGE3D = 265, /* F16IMAGE3D */ + YYSYMBOL_F16IMAGE2DRECT = 266, /* F16IMAGE2DRECT */ + YYSYMBOL_F16IMAGECUBE = 267, /* F16IMAGECUBE */ + YYSYMBOL_F16IMAGE1DARRAY = 268, /* F16IMAGE1DARRAY */ + YYSYMBOL_F16IMAGE2DARRAY = 269, /* F16IMAGE2DARRAY */ + YYSYMBOL_F16IMAGECUBEARRAY = 270, /* F16IMAGECUBEARRAY */ + YYSYMBOL_F16IMAGEBUFFER = 271, /* F16IMAGEBUFFER */ + YYSYMBOL_F16IMAGE2DMS = 272, /* F16IMAGE2DMS */ + YYSYMBOL_F16IMAGE2DMSARRAY = 273, /* F16IMAGE2DMSARRAY */ + YYSYMBOL_I64IMAGE1D = 274, /* I64IMAGE1D */ + YYSYMBOL_U64IMAGE1D = 275, /* U64IMAGE1D */ + YYSYMBOL_I64IMAGE2D = 276, /* I64IMAGE2D */ + YYSYMBOL_U64IMAGE2D = 277, /* U64IMAGE2D */ + YYSYMBOL_I64IMAGE3D = 278, /* I64IMAGE3D */ + YYSYMBOL_U64IMAGE3D = 279, /* U64IMAGE3D */ + YYSYMBOL_I64IMAGE2DRECT = 280, /* I64IMAGE2DRECT */ + YYSYMBOL_U64IMAGE2DRECT = 281, /* U64IMAGE2DRECT */ + YYSYMBOL_I64IMAGECUBE = 282, /* I64IMAGECUBE */ + YYSYMBOL_U64IMAGECUBE = 283, /* U64IMAGECUBE */ + YYSYMBOL_I64IMAGEBUFFER = 284, /* I64IMAGEBUFFER */ + YYSYMBOL_U64IMAGEBUFFER = 285, /* U64IMAGEBUFFER */ + YYSYMBOL_I64IMAGE1DARRAY = 286, /* I64IMAGE1DARRAY */ + YYSYMBOL_U64IMAGE1DARRAY = 287, /* U64IMAGE1DARRAY */ + YYSYMBOL_I64IMAGE2DARRAY = 288, /* I64IMAGE2DARRAY */ + YYSYMBOL_U64IMAGE2DARRAY = 289, /* U64IMAGE2DARRAY */ + YYSYMBOL_I64IMAGECUBEARRAY = 290, /* I64IMAGECUBEARRAY */ + YYSYMBOL_U64IMAGECUBEARRAY = 291, /* U64IMAGECUBEARRAY */ + YYSYMBOL_I64IMAGE2DMS = 292, /* I64IMAGE2DMS */ + YYSYMBOL_U64IMAGE2DMS = 293, /* U64IMAGE2DMS */ + YYSYMBOL_I64IMAGE2DMSARRAY = 294, /* I64IMAGE2DMSARRAY */ + YYSYMBOL_U64IMAGE2DMSARRAY = 295, /* U64IMAGE2DMSARRAY */ + YYSYMBOL_TEXTURECUBEARRAY = 296, /* TEXTURECUBEARRAY */ + YYSYMBOL_ITEXTURECUBEARRAY = 297, /* ITEXTURECUBEARRAY */ + YYSYMBOL_UTEXTURECUBEARRAY = 298, /* UTEXTURECUBEARRAY */ + YYSYMBOL_TEXTURE1D = 299, /* TEXTURE1D */ + YYSYMBOL_ITEXTURE1D = 300, /* ITEXTURE1D */ + YYSYMBOL_UTEXTURE1D = 301, /* UTEXTURE1D */ + YYSYMBOL_TEXTURE1DARRAY = 302, /* TEXTURE1DARRAY */ + YYSYMBOL_ITEXTURE1DARRAY = 303, /* ITEXTURE1DARRAY */ + YYSYMBOL_UTEXTURE1DARRAY = 304, /* UTEXTURE1DARRAY */ + YYSYMBOL_TEXTURE2DRECT = 305, /* TEXTURE2DRECT */ + YYSYMBOL_ITEXTURE2DRECT = 306, /* ITEXTURE2DRECT */ + YYSYMBOL_UTEXTURE2DRECT = 307, /* UTEXTURE2DRECT */ + YYSYMBOL_TEXTUREBUFFER = 308, /* TEXTUREBUFFER */ + YYSYMBOL_ITEXTUREBUFFER = 309, /* ITEXTUREBUFFER */ + YYSYMBOL_UTEXTUREBUFFER = 310, /* UTEXTUREBUFFER */ + YYSYMBOL_TEXTURE2DMS = 311, /* TEXTURE2DMS */ + YYSYMBOL_ITEXTURE2DMS = 312, /* ITEXTURE2DMS */ + YYSYMBOL_UTEXTURE2DMS = 313, /* UTEXTURE2DMS */ + YYSYMBOL_TEXTURE2DMSARRAY = 314, /* TEXTURE2DMSARRAY */ + YYSYMBOL_ITEXTURE2DMSARRAY = 315, /* ITEXTURE2DMSARRAY */ + YYSYMBOL_UTEXTURE2DMSARRAY = 316, /* UTEXTURE2DMSARRAY */ + YYSYMBOL_F16TEXTURE1D = 317, /* F16TEXTURE1D */ + YYSYMBOL_F16TEXTURE2D = 318, /* F16TEXTURE2D */ + YYSYMBOL_F16TEXTURE3D = 319, /* F16TEXTURE3D */ + YYSYMBOL_F16TEXTURE2DRECT = 320, /* F16TEXTURE2DRECT */ + YYSYMBOL_F16TEXTURECUBE = 321, /* F16TEXTURECUBE */ + YYSYMBOL_F16TEXTURE1DARRAY = 322, /* F16TEXTURE1DARRAY */ + YYSYMBOL_F16TEXTURE2DARRAY = 323, /* F16TEXTURE2DARRAY */ + YYSYMBOL_F16TEXTURECUBEARRAY = 324, /* F16TEXTURECUBEARRAY */ + YYSYMBOL_F16TEXTUREBUFFER = 325, /* F16TEXTUREBUFFER */ + YYSYMBOL_F16TEXTURE2DMS = 326, /* F16TEXTURE2DMS */ + YYSYMBOL_F16TEXTURE2DMSARRAY = 327, /* F16TEXTURE2DMSARRAY */ + YYSYMBOL_SUBPASSINPUT = 328, /* SUBPASSINPUT */ + YYSYMBOL_SUBPASSINPUTMS = 329, /* SUBPASSINPUTMS */ + YYSYMBOL_ISUBPASSINPUT = 330, /* ISUBPASSINPUT */ + YYSYMBOL_ISUBPASSINPUTMS = 331, /* ISUBPASSINPUTMS */ + YYSYMBOL_USUBPASSINPUT = 332, /* USUBPASSINPUT */ + YYSYMBOL_USUBPASSINPUTMS = 333, /* USUBPASSINPUTMS */ + YYSYMBOL_F16SUBPASSINPUT = 334, /* F16SUBPASSINPUT */ + YYSYMBOL_F16SUBPASSINPUTMS = 335, /* F16SUBPASSINPUTMS */ + YYSYMBOL_SPIRV_INSTRUCTION = 336, /* SPIRV_INSTRUCTION */ + YYSYMBOL_SPIRV_EXECUTION_MODE = 337, /* SPIRV_EXECUTION_MODE */ + YYSYMBOL_SPIRV_EXECUTION_MODE_ID = 338, /* SPIRV_EXECUTION_MODE_ID */ + YYSYMBOL_SPIRV_DECORATE = 339, /* SPIRV_DECORATE */ + YYSYMBOL_SPIRV_DECORATE_ID = 340, /* SPIRV_DECORATE_ID */ + YYSYMBOL_SPIRV_DECORATE_STRING = 341, /* SPIRV_DECORATE_STRING */ + YYSYMBOL_SPIRV_TYPE = 342, /* SPIRV_TYPE */ + YYSYMBOL_SPIRV_STORAGE_CLASS = 343, /* SPIRV_STORAGE_CLASS */ + YYSYMBOL_SPIRV_BY_REFERENCE = 344, /* SPIRV_BY_REFERENCE */ + YYSYMBOL_SPIRV_LITERAL = 345, /* SPIRV_LITERAL */ + YYSYMBOL_ATTACHMENTEXT = 346, /* ATTACHMENTEXT */ + YYSYMBOL_IATTACHMENTEXT = 347, /* IATTACHMENTEXT */ + YYSYMBOL_UATTACHMENTEXT = 348, /* UATTACHMENTEXT */ + YYSYMBOL_LEFT_OP = 349, /* LEFT_OP */ + YYSYMBOL_RIGHT_OP = 350, /* RIGHT_OP */ + YYSYMBOL_INC_OP = 351, /* INC_OP */ + YYSYMBOL_DEC_OP = 352, /* DEC_OP */ + YYSYMBOL_LE_OP = 353, /* LE_OP */ + YYSYMBOL_GE_OP = 354, /* GE_OP */ + YYSYMBOL_EQ_OP = 355, /* EQ_OP */ + YYSYMBOL_NE_OP = 356, /* NE_OP */ + YYSYMBOL_AND_OP = 357, /* AND_OP */ + YYSYMBOL_OR_OP = 358, /* OR_OP */ + YYSYMBOL_XOR_OP = 359, /* XOR_OP */ + YYSYMBOL_MUL_ASSIGN = 360, /* MUL_ASSIGN */ + YYSYMBOL_DIV_ASSIGN = 361, /* DIV_ASSIGN */ + YYSYMBOL_ADD_ASSIGN = 362, /* ADD_ASSIGN */ + YYSYMBOL_MOD_ASSIGN = 363, /* MOD_ASSIGN */ + YYSYMBOL_LEFT_ASSIGN = 364, /* LEFT_ASSIGN */ + YYSYMBOL_RIGHT_ASSIGN = 365, /* RIGHT_ASSIGN */ + YYSYMBOL_AND_ASSIGN = 366, /* AND_ASSIGN */ + YYSYMBOL_XOR_ASSIGN = 367, /* XOR_ASSIGN */ + YYSYMBOL_OR_ASSIGN = 368, /* OR_ASSIGN */ + YYSYMBOL_SUB_ASSIGN = 369, /* SUB_ASSIGN */ + YYSYMBOL_STRING_LITERAL = 370, /* STRING_LITERAL */ + YYSYMBOL_LEFT_PAREN = 371, /* LEFT_PAREN */ + YYSYMBOL_RIGHT_PAREN = 372, /* RIGHT_PAREN */ + YYSYMBOL_LEFT_BRACKET = 373, /* LEFT_BRACKET */ + YYSYMBOL_RIGHT_BRACKET = 374, /* RIGHT_BRACKET */ + YYSYMBOL_LEFT_BRACE = 375, /* LEFT_BRACE */ + YYSYMBOL_RIGHT_BRACE = 376, /* RIGHT_BRACE */ + YYSYMBOL_DOT = 377, /* DOT */ + YYSYMBOL_COMMA = 378, /* COMMA */ + YYSYMBOL_COLON = 379, /* COLON */ + YYSYMBOL_EQUAL = 380, /* EQUAL */ + YYSYMBOL_SEMICOLON = 381, /* SEMICOLON */ + YYSYMBOL_BANG = 382, /* BANG */ + YYSYMBOL_DASH = 383, /* DASH */ + YYSYMBOL_TILDE = 384, /* TILDE */ + YYSYMBOL_PLUS = 385, /* PLUS */ + YYSYMBOL_STAR = 386, /* STAR */ + YYSYMBOL_SLASH = 387, /* SLASH */ + YYSYMBOL_PERCENT = 388, /* PERCENT */ + YYSYMBOL_LEFT_ANGLE = 389, /* LEFT_ANGLE */ + YYSYMBOL_RIGHT_ANGLE = 390, /* RIGHT_ANGLE */ + YYSYMBOL_VERTICAL_BAR = 391, /* VERTICAL_BAR */ + YYSYMBOL_CARET = 392, /* CARET */ + YYSYMBOL_AMPERSAND = 393, /* AMPERSAND */ + YYSYMBOL_QUESTION = 394, /* QUESTION */ + YYSYMBOL_INVARIANT = 395, /* INVARIANT */ + YYSYMBOL_HIGH_PRECISION = 396, /* HIGH_PRECISION */ + YYSYMBOL_MEDIUM_PRECISION = 397, /* MEDIUM_PRECISION */ + YYSYMBOL_LOW_PRECISION = 398, /* LOW_PRECISION */ + YYSYMBOL_PRECISION = 399, /* PRECISION */ + YYSYMBOL_PACKED = 400, /* PACKED */ + YYSYMBOL_RESOURCE = 401, /* RESOURCE */ + YYSYMBOL_SUPERP = 402, /* SUPERP */ + YYSYMBOL_FLOATCONSTANT = 403, /* FLOATCONSTANT */ + YYSYMBOL_INTCONSTANT = 404, /* INTCONSTANT */ + YYSYMBOL_UINTCONSTANT = 405, /* UINTCONSTANT */ + YYSYMBOL_BOOLCONSTANT = 406, /* BOOLCONSTANT */ + YYSYMBOL_IDENTIFIER = 407, /* IDENTIFIER */ + YYSYMBOL_TYPE_NAME = 408, /* TYPE_NAME */ + YYSYMBOL_CENTROID = 409, /* CENTROID */ + YYSYMBOL_IN = 410, /* IN */ + YYSYMBOL_OUT = 411, /* OUT */ + YYSYMBOL_INOUT = 412, /* INOUT */ + YYSYMBOL_STRUCT = 413, /* STRUCT */ + YYSYMBOL_VOID = 414, /* VOID */ + YYSYMBOL_WHILE = 415, /* WHILE */ + YYSYMBOL_BREAK = 416, /* BREAK */ + YYSYMBOL_CONTINUE = 417, /* CONTINUE */ + YYSYMBOL_DO = 418, /* DO */ + YYSYMBOL_ELSE = 419, /* ELSE */ + YYSYMBOL_FOR = 420, /* FOR */ + YYSYMBOL_IF = 421, /* IF */ + YYSYMBOL_DISCARD = 422, /* DISCARD */ + YYSYMBOL_RETURN = 423, /* RETURN */ + YYSYMBOL_SWITCH = 424, /* SWITCH */ + YYSYMBOL_CASE = 425, /* CASE */ + YYSYMBOL_DEFAULT = 426, /* DEFAULT */ + YYSYMBOL_TERMINATE_INVOCATION = 427, /* TERMINATE_INVOCATION */ + YYSYMBOL_TERMINATE_RAY = 428, /* TERMINATE_RAY */ + YYSYMBOL_IGNORE_INTERSECTION = 429, /* IGNORE_INTERSECTION */ + YYSYMBOL_UNIFORM = 430, /* UNIFORM */ + YYSYMBOL_SHARED = 431, /* SHARED */ + YYSYMBOL_BUFFER = 432, /* BUFFER */ + YYSYMBOL_TILEIMAGEEXT = 433, /* TILEIMAGEEXT */ + YYSYMBOL_FLAT = 434, /* FLAT */ + YYSYMBOL_SMOOTH = 435, /* SMOOTH */ + YYSYMBOL_LAYOUT = 436, /* LAYOUT */ + YYSYMBOL_DOUBLECONSTANT = 437, /* DOUBLECONSTANT */ + YYSYMBOL_INT16CONSTANT = 438, /* INT16CONSTANT */ + YYSYMBOL_UINT16CONSTANT = 439, /* UINT16CONSTANT */ + YYSYMBOL_FLOAT16CONSTANT = 440, /* FLOAT16CONSTANT */ + YYSYMBOL_INT32CONSTANT = 441, /* INT32CONSTANT */ + YYSYMBOL_UINT32CONSTANT = 442, /* UINT32CONSTANT */ + YYSYMBOL_INT64CONSTANT = 443, /* INT64CONSTANT */ + YYSYMBOL_UINT64CONSTANT = 444, /* UINT64CONSTANT */ + YYSYMBOL_SUBROUTINE = 445, /* SUBROUTINE */ + YYSYMBOL_DEMOTE = 446, /* DEMOTE */ + YYSYMBOL_FUNCTION = 447, /* FUNCTION */ + YYSYMBOL_PAYLOADNV = 448, /* PAYLOADNV */ + YYSYMBOL_PAYLOADINNV = 449, /* PAYLOADINNV */ + YYSYMBOL_HITATTRNV = 450, /* HITATTRNV */ + YYSYMBOL_CALLDATANV = 451, /* CALLDATANV */ + YYSYMBOL_CALLDATAINNV = 452, /* CALLDATAINNV */ + YYSYMBOL_PAYLOADEXT = 453, /* PAYLOADEXT */ + YYSYMBOL_PAYLOADINEXT = 454, /* PAYLOADINEXT */ + YYSYMBOL_HITATTREXT = 455, /* HITATTREXT */ + YYSYMBOL_CALLDATAEXT = 456, /* CALLDATAEXT */ + YYSYMBOL_CALLDATAINEXT = 457, /* CALLDATAINEXT */ + YYSYMBOL_PATCH = 458, /* PATCH */ + YYSYMBOL_SAMPLE = 459, /* SAMPLE */ + YYSYMBOL_NONUNIFORM = 460, /* NONUNIFORM */ + YYSYMBOL_COHERENT = 461, /* COHERENT */ + YYSYMBOL_VOLATILE = 462, /* VOLATILE */ + YYSYMBOL_RESTRICT = 463, /* RESTRICT */ + YYSYMBOL_READONLY = 464, /* READONLY */ + YYSYMBOL_WRITEONLY = 465, /* WRITEONLY */ + YYSYMBOL_NONTEMPORAL = 466, /* NONTEMPORAL */ + YYSYMBOL_DEVICECOHERENT = 467, /* DEVICECOHERENT */ + YYSYMBOL_QUEUEFAMILYCOHERENT = 468, /* QUEUEFAMILYCOHERENT */ + YYSYMBOL_WORKGROUPCOHERENT = 469, /* WORKGROUPCOHERENT */ + YYSYMBOL_SUBGROUPCOHERENT = 470, /* SUBGROUPCOHERENT */ + YYSYMBOL_NONPRIVATE = 471, /* NONPRIVATE */ + YYSYMBOL_SHADERCALLCOHERENT = 472, /* SHADERCALLCOHERENT */ + YYSYMBOL_NOPERSPECTIVE = 473, /* NOPERSPECTIVE */ + YYSYMBOL_EXPLICITINTERPAMD = 474, /* EXPLICITINTERPAMD */ + YYSYMBOL_PERVERTEXEXT = 475, /* PERVERTEXEXT */ + YYSYMBOL_PERVERTEXNV = 476, /* PERVERTEXNV */ + YYSYMBOL_PERPRIMITIVENV = 477, /* PERPRIMITIVENV */ + YYSYMBOL_PERVIEWNV = 478, /* PERVIEWNV */ + YYSYMBOL_PERTASKNV = 479, /* PERTASKNV */ + YYSYMBOL_PERPRIMITIVEEXT = 480, /* PERPRIMITIVEEXT */ + YYSYMBOL_TASKPAYLOADWORKGROUPEXT = 481, /* TASKPAYLOADWORKGROUPEXT */ + YYSYMBOL_PRECISE = 482, /* PRECISE */ + YYSYMBOL_YYACCEPT = 483, /* $accept */ + YYSYMBOL_variable_identifier = 484, /* variable_identifier */ + YYSYMBOL_primary_expression = 485, /* primary_expression */ + YYSYMBOL_postfix_expression = 486, /* postfix_expression */ + YYSYMBOL_integer_expression = 487, /* integer_expression */ + YYSYMBOL_function_call = 488, /* function_call */ + YYSYMBOL_function_call_or_method = 489, /* function_call_or_method */ + YYSYMBOL_function_call_generic = 490, /* function_call_generic */ + YYSYMBOL_function_call_header_no_parameters = 491, /* function_call_header_no_parameters */ + YYSYMBOL_function_call_header_with_parameters = 492, /* function_call_header_with_parameters */ + YYSYMBOL_function_call_header = 493, /* function_call_header */ + YYSYMBOL_function_identifier = 494, /* function_identifier */ + YYSYMBOL_unary_expression = 495, /* unary_expression */ + YYSYMBOL_unary_operator = 496, /* unary_operator */ + YYSYMBOL_multiplicative_expression = 497, /* multiplicative_expression */ + YYSYMBOL_additive_expression = 498, /* additive_expression */ + YYSYMBOL_shift_expression = 499, /* shift_expression */ + YYSYMBOL_relational_expression = 500, /* relational_expression */ + YYSYMBOL_equality_expression = 501, /* equality_expression */ + YYSYMBOL_and_expression = 502, /* and_expression */ + YYSYMBOL_exclusive_or_expression = 503, /* exclusive_or_expression */ + YYSYMBOL_inclusive_or_expression = 504, /* inclusive_or_expression */ + YYSYMBOL_logical_and_expression = 505, /* logical_and_expression */ + YYSYMBOL_logical_xor_expression = 506, /* logical_xor_expression */ + YYSYMBOL_logical_or_expression = 507, /* logical_or_expression */ + YYSYMBOL_conditional_expression = 508, /* conditional_expression */ + YYSYMBOL_509_1 = 509, /* $@1 */ + YYSYMBOL_assignment_expression = 510, /* assignment_expression */ + YYSYMBOL_assignment_operator = 511, /* assignment_operator */ + YYSYMBOL_expression = 512, /* expression */ + YYSYMBOL_constant_expression = 513, /* constant_expression */ + YYSYMBOL_declaration = 514, /* declaration */ + YYSYMBOL_block_structure = 515, /* block_structure */ + YYSYMBOL_516_2 = 516, /* $@2 */ + YYSYMBOL_identifier_list = 517, /* identifier_list */ + YYSYMBOL_function_prototype = 518, /* function_prototype */ + YYSYMBOL_function_declarator = 519, /* function_declarator */ + YYSYMBOL_function_header_with_parameters = 520, /* function_header_with_parameters */ + YYSYMBOL_function_header = 521, /* function_header */ + YYSYMBOL_parameter_declarator = 522, /* parameter_declarator */ + YYSYMBOL_parameter_declaration = 523, /* parameter_declaration */ + YYSYMBOL_parameter_type_specifier = 524, /* parameter_type_specifier */ + YYSYMBOL_init_declarator_list = 525, /* init_declarator_list */ + YYSYMBOL_single_declaration = 526, /* single_declaration */ + YYSYMBOL_fully_specified_type = 527, /* fully_specified_type */ + YYSYMBOL_invariant_qualifier = 528, /* invariant_qualifier */ + YYSYMBOL_interpolation_qualifier = 529, /* interpolation_qualifier */ + YYSYMBOL_layout_qualifier = 530, /* layout_qualifier */ + YYSYMBOL_layout_qualifier_id_list = 531, /* layout_qualifier_id_list */ + YYSYMBOL_layout_qualifier_id = 532, /* layout_qualifier_id */ + YYSYMBOL_precise_qualifier = 533, /* precise_qualifier */ + YYSYMBOL_type_qualifier = 534, /* type_qualifier */ + YYSYMBOL_single_type_qualifier = 535, /* single_type_qualifier */ + YYSYMBOL_storage_qualifier = 536, /* storage_qualifier */ + YYSYMBOL_non_uniform_qualifier = 537, /* non_uniform_qualifier */ + YYSYMBOL_type_name_list = 538, /* type_name_list */ + YYSYMBOL_type_specifier = 539, /* type_specifier */ + YYSYMBOL_array_specifier = 540, /* array_specifier */ + YYSYMBOL_type_parameter_specifier_opt = 541, /* type_parameter_specifier_opt */ + YYSYMBOL_type_parameter_specifier = 542, /* type_parameter_specifier */ + YYSYMBOL_type_parameter_specifier_list = 543, /* type_parameter_specifier_list */ + YYSYMBOL_type_specifier_nonarray = 544, /* type_specifier_nonarray */ + YYSYMBOL_precision_qualifier = 545, /* precision_qualifier */ + YYSYMBOL_struct_specifier = 546, /* struct_specifier */ + YYSYMBOL_547_3 = 547, /* $@3 */ + YYSYMBOL_548_4 = 548, /* $@4 */ + YYSYMBOL_struct_declaration_list = 549, /* struct_declaration_list */ + YYSYMBOL_struct_declaration = 550, /* struct_declaration */ + YYSYMBOL_struct_declarator_list = 551, /* struct_declarator_list */ + YYSYMBOL_struct_declarator = 552, /* struct_declarator */ + YYSYMBOL_initializer = 553, /* initializer */ + YYSYMBOL_initializer_list = 554, /* initializer_list */ + YYSYMBOL_declaration_statement = 555, /* declaration_statement */ + YYSYMBOL_statement = 556, /* statement */ + YYSYMBOL_simple_statement = 557, /* simple_statement */ + YYSYMBOL_demote_statement = 558, /* demote_statement */ + YYSYMBOL_compound_statement = 559, /* compound_statement */ + YYSYMBOL_560_5 = 560, /* $@5 */ + YYSYMBOL_561_6 = 561, /* $@6 */ + YYSYMBOL_statement_no_new_scope = 562, /* statement_no_new_scope */ + YYSYMBOL_statement_scoped = 563, /* statement_scoped */ + YYSYMBOL_564_7 = 564, /* $@7 */ + YYSYMBOL_565_8 = 565, /* $@8 */ + YYSYMBOL_compound_statement_no_new_scope = 566, /* compound_statement_no_new_scope */ + YYSYMBOL_statement_list = 567, /* statement_list */ + YYSYMBOL_expression_statement = 568, /* expression_statement */ + YYSYMBOL_selection_statement = 569, /* selection_statement */ + YYSYMBOL_selection_statement_nonattributed = 570, /* selection_statement_nonattributed */ + YYSYMBOL_selection_rest_statement = 571, /* selection_rest_statement */ + YYSYMBOL_condition = 572, /* condition */ + YYSYMBOL_switch_statement = 573, /* switch_statement */ + YYSYMBOL_switch_statement_nonattributed = 574, /* switch_statement_nonattributed */ + YYSYMBOL_575_9 = 575, /* $@9 */ + YYSYMBOL_switch_statement_list = 576, /* switch_statement_list */ + YYSYMBOL_case_label = 577, /* case_label */ + YYSYMBOL_iteration_statement = 578, /* iteration_statement */ + YYSYMBOL_iteration_statement_nonattributed = 579, /* iteration_statement_nonattributed */ + YYSYMBOL_580_10 = 580, /* $@10 */ + YYSYMBOL_581_11 = 581, /* $@11 */ + YYSYMBOL_582_12 = 582, /* $@12 */ + YYSYMBOL_for_init_statement = 583, /* for_init_statement */ + YYSYMBOL_conditionopt = 584, /* conditionopt */ + YYSYMBOL_for_rest_statement = 585, /* for_rest_statement */ + YYSYMBOL_jump_statement = 586, /* jump_statement */ + YYSYMBOL_translation_unit = 587, /* translation_unit */ + YYSYMBOL_external_declaration = 588, /* external_declaration */ + YYSYMBOL_function_definition = 589, /* function_definition */ + YYSYMBOL_590_13 = 590, /* $@13 */ + YYSYMBOL_attribute = 591, /* attribute */ + YYSYMBOL_attribute_list = 592, /* attribute_list */ + YYSYMBOL_single_attribute = 593, /* single_attribute */ + YYSYMBOL_spirv_requirements_list = 594, /* spirv_requirements_list */ + YYSYMBOL_spirv_requirements_parameter = 595, /* spirv_requirements_parameter */ + YYSYMBOL_spirv_extension_list = 596, /* spirv_extension_list */ + YYSYMBOL_spirv_capability_list = 597, /* spirv_capability_list */ + YYSYMBOL_spirv_execution_mode_qualifier = 598, /* spirv_execution_mode_qualifier */ + YYSYMBOL_spirv_execution_mode_parameter_list = 599, /* spirv_execution_mode_parameter_list */ + YYSYMBOL_spirv_execution_mode_parameter = 600, /* spirv_execution_mode_parameter */ + YYSYMBOL_spirv_execution_mode_id_parameter_list = 601, /* spirv_execution_mode_id_parameter_list */ + YYSYMBOL_spirv_storage_class_qualifier = 602, /* spirv_storage_class_qualifier */ + YYSYMBOL_spirv_decorate_qualifier = 603, /* spirv_decorate_qualifier */ + YYSYMBOL_spirv_decorate_parameter_list = 604, /* spirv_decorate_parameter_list */ + YYSYMBOL_spirv_decorate_parameter = 605, /* spirv_decorate_parameter */ + YYSYMBOL_spirv_decorate_id_parameter_list = 606, /* spirv_decorate_id_parameter_list */ + YYSYMBOL_spirv_decorate_id_parameter = 607, /* spirv_decorate_id_parameter */ + YYSYMBOL_spirv_decorate_string_parameter_list = 608, /* spirv_decorate_string_parameter_list */ + YYSYMBOL_spirv_type_specifier = 609, /* spirv_type_specifier */ + YYSYMBOL_spirv_type_parameter_list = 610, /* spirv_type_parameter_list */ + YYSYMBOL_spirv_type_parameter = 611, /* spirv_type_parameter */ + YYSYMBOL_spirv_instruction_qualifier = 612, /* spirv_instruction_qualifier */ + YYSYMBOL_spirv_instruction_qualifier_list = 613, /* spirv_instruction_qualifier_list */ + YYSYMBOL_spirv_instruction_qualifier_id = 614 /* spirv_instruction_qualifier_id */ }; typedef enum yysymbol_kind_t yysymbol_kind_t; @@ -741,7 +750,7 @@ typedef enum yysymbol_kind_t yysymbol_kind_t; extern int yylex(YYSTYPE*, TParseContext&); -#line 745 "MachineIndependent/glslang_tab.cpp" +#line 754 "MachineIndependent/glslang_tab.cpp" #ifdef short @@ -1063,21 +1072,21 @@ union yyalloc #endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ -#define YYFINAL 461 +#define YYFINAL 471 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 12966 +#define YYLAST 13688 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 474 +#define YYNTOKENS 483 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 132 /* YYNRULES -- Number of rules. */ -#define YYNRULES 709 +#define YYNRULES 719 /* YYNSTATES -- Number of states. */ -#define YYNSTATES 955 +#define YYNSTATES 966 /* YYMAXUTOK -- Last valid token kind. */ -#define YYMAXUTOK 728 +#define YYMAXUTOK 737 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM @@ -1163,84 +1172,86 @@ static const yytype_int16 yytranslate[] = 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467, 468, 469, 470, 471, 472, 473 + 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, + 475, 476, 477, 478, 479, 480, 481, 482 }; #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_int16 yyrline[] = { - 0, 358, 358, 364, 367, 372, 375, 378, 382, 385, - 388, 392, 396, 400, 404, 408, 412, 418, 425, 428, - 431, 434, 437, 442, 450, 457, 464, 470, 474, 481, - 484, 490, 508, 533, 541, 546, 573, 581, 587, 591, - 595, 615, 616, 617, 618, 624, 625, 630, 635, 644, - 645, 650, 658, 659, 665, 674, 675, 680, 685, 690, - 698, 699, 708, 720, 721, 730, 731, 740, 741, 750, - 751, 759, 760, 768, 769, 777, 778, 778, 796, 797, - 813, 817, 821, 825, 830, 834, 838, 842, 846, 850, - 854, 861, 864, 875, 882, 887, 894, 899, 904, 911, - 915, 919, 923, 928, 933, 942, 942, 953, 957, 964, - 969, 977, 985, 997, 1000, 1007, 1020, 1043, 1066, 1081, - 1106, 1117, 1127, 1137, 1147, 1156, 1159, 1163, 1167, 1172, - 1180, 1185, 1190, 1195, 1200, 1209, 1219, 1246, 1255, 1262, - 1269, 1276, 1283, 1291, 1299, 1309, 1319, 1326, 1336, 1342, - 1345, 1352, 1356, 1360, 1368, 1377, 1380, 1391, 1394, 1397, - 1401, 1405, 1409, 1413, 1416, 1421, 1425, 1430, 1438, 1442, - 1447, 1453, 1459, 1466, 1471, 1476, 1484, 1489, 1501, 1515, - 1521, 1526, 1534, 1542, 1550, 1558, 1566, 1574, 1582, 1590, - 1598, 1605, 1612, 1616, 1621, 1626, 1631, 1636, 1641, 1646, - 1650, 1654, 1658, 1662, 1666, 1672, 1678, 1688, 1695, 1698, - 1706, 1713, 1724, 1729, 1737, 1741, 1751, 1754, 1760, 1766, - 1772, 1780, 1790, 1794, 1798, 1802, 1807, 1811, 1816, 1821, - 1826, 1831, 1836, 1841, 1846, 1851, 1856, 1862, 1868, 1874, - 1879, 1884, 1889, 1894, 1899, 1904, 1909, 1914, 1919, 1924, - 1929, 1934, 1941, 1946, 1951, 1956, 1961, 1966, 1971, 1976, - 1981, 1986, 1991, 1996, 2001, 2009, 2017, 2025, 2031, 2037, - 2043, 2049, 2055, 2061, 2067, 2073, 2079, 2085, 2091, 2097, - 2103, 2109, 2115, 2121, 2127, 2133, 2139, 2145, 2151, 2157, - 2163, 2169, 2175, 2181, 2187, 2193, 2199, 2205, 2211, 2217, - 2223, 2229, 2235, 2241, 2249, 2257, 2265, 2273, 2281, 2289, - 2297, 2305, 2313, 2321, 2329, 2337, 2343, 2349, 2355, 2361, - 2367, 2373, 2379, 2385, 2391, 2397, 2403, 2409, 2415, 2421, - 2427, 2433, 2439, 2445, 2451, 2457, 2463, 2469, 2475, 2481, - 2487, 2493, 2499, 2505, 2511, 2517, 2523, 2529, 2535, 2541, - 2547, 2553, 2557, 2561, 2565, 2570, 2575, 2580, 2585, 2590, - 2595, 2600, 2605, 2610, 2615, 2620, 2625, 2630, 2635, 2641, - 2647, 2653, 2659, 2665, 2671, 2677, 2683, 2689, 2695, 2701, - 2707, 2713, 2718, 2723, 2728, 2733, 2738, 2743, 2748, 2753, - 2758, 2763, 2768, 2773, 2778, 2783, 2788, 2793, 2798, 2803, - 2808, 2813, 2818, 2823, 2828, 2833, 2838, 2843, 2848, 2853, - 2858, 2863, 2868, 2873, 2878, 2884, 2890, 2895, 2900, 2905, - 2911, 2916, 2921, 2926, 2932, 2937, 2942, 2947, 2953, 2958, - 2963, 2968, 2974, 2980, 2986, 2992, 2997, 3003, 3009, 3015, - 3020, 3025, 3030, 3035, 3040, 3046, 3051, 3056, 3061, 3067, - 3072, 3077, 3082, 3088, 3093, 3098, 3103, 3109, 3114, 3119, - 3124, 3130, 3135, 3140, 3145, 3151, 3156, 3161, 3166, 3172, - 3177, 3182, 3187, 3193, 3198, 3203, 3208, 3214, 3219, 3224, - 3229, 3235, 3240, 3245, 3250, 3256, 3261, 3266, 3271, 3277, - 3282, 3287, 3292, 3298, 3303, 3308, 3313, 3319, 3324, 3329, - 3334, 3340, 3345, 3350, 3355, 3360, 3365, 3370, 3375, 3380, - 3385, 3390, 3395, 3400, 3405, 3410, 3415, 3420, 3425, 3430, - 3435, 3440, 3445, 3450, 3455, 3460, 3466, 3472, 3478, 3484, - 3490, 3496, 3502, 3509, 3516, 3522, 3528, 3534, 3540, 3547, - 3554, 3561, 3568, 3573, 3578, 3582, 3588, 3592, 3596, 3601, - 3617, 3622, 3627, 3635, 3635, 3652, 3652, 3662, 3665, 3678, - 3700, 3727, 3731, 3737, 3742, 3753, 3756, 3762, 3768, 3777, - 3780, 3786, 3790, 3791, 3797, 3798, 3799, 3800, 3801, 3802, - 3803, 3804, 3808, 3816, 3817, 3821, 3817, 3835, 3836, 3840, - 3840, 3847, 3847, 3861, 3864, 3874, 3882, 3893, 3894, 3898, - 3901, 3908, 3915, 3919, 3927, 3931, 3944, 3947, 3954, 3954, - 3974, 3977, 3983, 3995, 4007, 4010, 4018, 4018, 4033, 4033, - 4051, 4051, 4072, 4075, 4081, 4084, 4090, 4094, 4101, 4106, - 4111, 4118, 4121, 4125, 4129, 4133, 4142, 4146, 4155, 4158, - 4161, 4169, 4169, 4211, 4216, 4219, 4224, 4227, 4232, 4235, - 4240, 4243, 4248, 4251, 4256, 4259, 4264, 4268, 4273, 4277, - 4282, 4286, 4293, 4296, 4301, 4304, 4307, 4310, 4313, 4318, - 4327, 4338, 4343, 4351, 4355, 4360, 4364, 4369, 4373, 4378, - 4382, 4389, 4392, 4397, 4400, 4403, 4406, 4411, 4414, 4419, - 4425, 4428, 4431, 4434, 4439, 4443, 4448, 4452, 4457, 4461, - 4468, 4471, 4476, 4479, 4484, 4487, 4493, 4496, 4501, 4504 + 0, 361, 361, 367, 370, 375, 378, 381, 385, 388, + 391, 395, 399, 403, 407, 411, 415, 421, 428, 431, + 434, 437, 440, 445, 453, 460, 467, 473, 477, 484, + 487, 493, 511, 536, 544, 549, 576, 584, 590, 594, + 598, 618, 619, 620, 621, 627, 628, 633, 638, 647, + 648, 653, 661, 662, 668, 677, 678, 683, 688, 693, + 701, 702, 711, 723, 724, 733, 734, 743, 744, 753, + 754, 762, 763, 771, 772, 780, 781, 781, 799, 800, + 816, 820, 824, 828, 833, 837, 841, 845, 849, 853, + 857, 864, 867, 878, 885, 890, 897, 902, 907, 914, + 918, 922, 926, 931, 939, 939, 950, 954, 961, 966, + 974, 982, 994, 997, 1004, 1017, 1037, 1044, 1067, 1082, + 1101, 1112, 1123, 1133, 1143, 1153, 1162, 1165, 1169, 1173, + 1178, 1186, 1191, 1196, 1201, 1206, 1215, 1225, 1252, 1261, + 1268, 1275, 1282, 1289, 1297, 1305, 1315, 1325, 1332, 1342, + 1348, 1351, 1358, 1362, 1366, 1374, 1383, 1386, 1397, 1400, + 1403, 1407, 1411, 1415, 1419, 1422, 1427, 1431, 1436, 1444, + 1448, 1453, 1459, 1465, 1472, 1477, 1482, 1490, 1495, 1507, + 1521, 1527, 1532, 1540, 1548, 1556, 1564, 1572, 1580, 1588, + 1596, 1604, 1611, 1618, 1622, 1627, 1632, 1637, 1642, 1647, + 1652, 1656, 1660, 1664, 1668, 1672, 1678, 1684, 1694, 1701, + 1704, 1712, 1719, 1730, 1735, 1743, 1747, 1757, 1760, 1766, + 1772, 1778, 1786, 1796, 1800, 1804, 1808, 1813, 1817, 1822, + 1827, 1832, 1837, 1842, 1847, 1852, 1857, 1862, 1868, 1874, + 1880, 1885, 1890, 1895, 1900, 1905, 1910, 1915, 1920, 1925, + 1930, 1935, 1940, 1947, 1952, 1957, 1962, 1967, 1972, 1977, + 1982, 1987, 1992, 1997, 2002, 2007, 2012, 2017, 2025, 2033, + 2041, 2047, 2053, 2059, 2065, 2071, 2077, 2083, 2089, 2095, + 2101, 2107, 2113, 2119, 2125, 2131, 2137, 2143, 2149, 2155, + 2161, 2167, 2173, 2179, 2185, 2191, 2197, 2203, 2209, 2215, + 2221, 2227, 2233, 2239, 2245, 2251, 2257, 2263, 2269, 2275, + 2281, 2287, 2293, 2301, 2309, 2317, 2325, 2333, 2341, 2349, + 2357, 2365, 2373, 2381, 2389, 2395, 2401, 2407, 2413, 2419, + 2425, 2431, 2437, 2443, 2449, 2455, 2461, 2467, 2473, 2479, + 2485, 2491, 2497, 2503, 2509, 2515, 2521, 2527, 2533, 2539, + 2545, 2551, 2557, 2563, 2569, 2575, 2581, 2587, 2593, 2599, + 2605, 2609, 2613, 2617, 2622, 2627, 2632, 2637, 2642, 2647, + 2652, 2657, 2662, 2667, 2672, 2677, 2682, 2687, 2693, 2699, + 2705, 2711, 2717, 2723, 2729, 2735, 2741, 2747, 2753, 2759, + 2765, 2770, 2775, 2780, 2785, 2790, 2795, 2800, 2805, 2810, + 2815, 2820, 2825, 2830, 2835, 2840, 2845, 2850, 2855, 2860, + 2865, 2870, 2875, 2880, 2885, 2890, 2895, 2900, 2905, 2910, + 2915, 2920, 2925, 2930, 2936, 2942, 2947, 2952, 2957, 2963, + 2968, 2973, 2978, 2984, 2989, 2994, 2999, 3005, 3010, 3015, + 3020, 3026, 3032, 3038, 3044, 3049, 3055, 3061, 3067, 3072, + 3077, 3082, 3087, 3092, 3098, 3103, 3108, 3113, 3119, 3124, + 3129, 3134, 3140, 3145, 3150, 3155, 3161, 3166, 3171, 3176, + 3182, 3187, 3192, 3197, 3203, 3208, 3213, 3218, 3224, 3229, + 3234, 3239, 3245, 3250, 3255, 3260, 3266, 3271, 3276, 3281, + 3287, 3292, 3297, 3302, 3308, 3313, 3318, 3323, 3329, 3334, + 3339, 3344, 3350, 3355, 3360, 3365, 3371, 3376, 3381, 3386, + 3392, 3397, 3402, 3407, 3412, 3417, 3422, 3427, 3432, 3437, + 3442, 3447, 3452, 3457, 3462, 3467, 3472, 3477, 3482, 3487, + 3492, 3497, 3502, 3507, 3512, 3518, 3524, 3530, 3536, 3542, + 3548, 3554, 3561, 3568, 3574, 3580, 3586, 3592, 3599, 3606, + 3613, 3620, 3625, 3630, 3634, 3640, 3646, 3650, 3654, 3659, + 3675, 3680, 3685, 3693, 3693, 3710, 3710, 3720, 3723, 3736, + 3758, 3785, 3789, 3795, 3800, 3811, 3814, 3820, 3826, 3835, + 3838, 3844, 3848, 3849, 3855, 3856, 3857, 3858, 3859, 3860, + 3861, 3862, 3866, 3874, 3875, 3879, 3875, 3893, 3894, 3898, + 3898, 3905, 3905, 3919, 3922, 3932, 3940, 3951, 3952, 3956, + 3959, 3966, 3973, 3977, 3985, 3989, 4002, 4005, 4012, 4012, + 4032, 4035, 4041, 4053, 4065, 4068, 4076, 4076, 4091, 4091, + 4109, 4109, 4130, 4133, 4139, 4142, 4148, 4152, 4159, 4164, + 4169, 4176, 4179, 4183, 4187, 4191, 4200, 4204, 4213, 4216, + 4219, 4227, 4227, 4269, 4274, 4277, 4282, 4285, 4290, 4293, + 4298, 4301, 4306, 4309, 4314, 4317, 4322, 4326, 4331, 4335, + 4340, 4344, 4351, 4354, 4359, 4362, 4365, 4368, 4371, 4376, + 4385, 4396, 4401, 4409, 4413, 4418, 4422, 4427, 4431, 4436, + 4440, 4447, 4450, 4455, 4458, 4461, 4464, 4469, 4472, 4477, + 4483, 4486, 4489, 4492, 4497, 4501, 4506, 4510, 4515, 4519, + 4526, 4529, 4534, 4537, 4542, 4545, 4551, 4554, 4559, 4562 }; #endif @@ -1267,36 +1278,38 @@ static const char *const yytname[] = "USAMPLER2DARRAY", "SAMPLER", "SAMPLERSHADOW", "TEXTURE2D", "TEXTURE3D", "TEXTURECUBE", "TEXTURE2DARRAY", "ITEXTURE2D", "ITEXTURE3D", "ITEXTURECUBE", "ITEXTURE2DARRAY", "UTEXTURE2D", "UTEXTURE3D", - "UTEXTURECUBE", "UTEXTURE2DARRAY", "ATTRIBUTE", "VARYING", "BFLOAT16_T", - "FLOAT16_T", "FLOAT32_T", "DOUBLE", "FLOAT64_T", "INT64_T", "UINT64_T", - "INT32_T", "UINT32_T", "INT16_T", "UINT16_T", "INT8_T", "UINT8_T", - "I64VEC2", "I64VEC3", "I64VEC4", "U64VEC2", "U64VEC3", "U64VEC4", - "I32VEC2", "I32VEC3", "I32VEC4", "U32VEC2", "U32VEC3", "U32VEC4", - "I16VEC2", "I16VEC3", "I16VEC4", "U16VEC2", "U16VEC3", "U16VEC4", - "I8VEC2", "I8VEC3", "I8VEC4", "U8VEC2", "U8VEC3", "U8VEC4", "DVEC2", - "DVEC3", "DVEC4", "DMAT2", "DMAT3", "DMAT4", "BF16VEC2", "BF16VEC3", - "BF16VEC4", "F16VEC2", "F16VEC3", "F16VEC4", "F16MAT2", "F16MAT3", - "F16MAT4", "F32VEC2", "F32VEC3", "F32VEC4", "F32MAT2", "F32MAT3", - "F32MAT4", "F64VEC2", "F64VEC3", "F64VEC4", "F64MAT2", "F64MAT3", - "F64MAT4", "DMAT2X2", "DMAT2X3", "DMAT2X4", "DMAT3X2", "DMAT3X3", - "DMAT3X4", "DMAT4X2", "DMAT4X3", "DMAT4X4", "F16MAT2X2", "F16MAT2X3", - "F16MAT2X4", "F16MAT3X2", "F16MAT3X3", "F16MAT3X4", "F16MAT4X2", - "F16MAT4X3", "F16MAT4X4", "F32MAT2X2", "F32MAT2X3", "F32MAT2X4", - "F32MAT3X2", "F32MAT3X3", "F32MAT3X4", "F32MAT4X2", "F32MAT4X3", - "F32MAT4X4", "F64MAT2X2", "F64MAT2X3", "F64MAT2X4", "F64MAT3X2", - "F64MAT3X3", "F64MAT3X4", "F64MAT4X2", "F64MAT4X3", "F64MAT4X4", - "ATOMIC_UINT", "ACCSTRUCTNV", "ACCSTRUCTEXT", "RAYQUERYEXT", - "FCOOPMATNV", "ICOOPMATNV", "UCOOPMATNV", "COOPMAT", "COOPVECNV", - "HITOBJECTNV", "HITOBJECTATTRNV", "TENSORLAYOUTNV", "TENSORVIEWNV", - "SAMPLERCUBEARRAY", "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY", - "USAMPLERCUBEARRAY", "SAMPLER1D", "SAMPLER1DARRAY", - "SAMPLER1DARRAYSHADOW", "ISAMPLER1D", "SAMPLER1DSHADOW", "SAMPLER2DRECT", - "SAMPLER2DRECTSHADOW", "ISAMPLER2DRECT", "USAMPLER2DRECT", - "SAMPLERBUFFER", "ISAMPLERBUFFER", "USAMPLERBUFFER", "SAMPLER2DMS", - "ISAMPLER2DMS", "USAMPLER2DMS", "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY", - "USAMPLER2DMSARRAY", "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT", - "ISAMPLER1DARRAY", "USAMPLER1D", "USAMPLER1DARRAY", "F16SAMPLER1D", - "F16SAMPLER2D", "F16SAMPLER3D", "F16SAMPLER2DRECT", "F16SAMPLERCUBE", + "UTEXTURECUBE", "UTEXTURE2DARRAY", "ATTRIBUTE", "VARYING", "FLOATE5M2_T", + "FLOATE4M3_T", "BFLOAT16_T", "FLOAT16_T", "FLOAT32_T", "DOUBLE", + "FLOAT64_T", "INT64_T", "UINT64_T", "INT32_T", "UINT32_T", "INT16_T", + "UINT16_T", "INT8_T", "UINT8_T", "I64VEC2", "I64VEC3", "I64VEC4", + "U64VEC2", "U64VEC3", "U64VEC4", "I32VEC2", "I32VEC3", "I32VEC4", + "U32VEC2", "U32VEC3", "U32VEC4", "I16VEC2", "I16VEC3", "I16VEC4", + "U16VEC2", "U16VEC3", "U16VEC4", "I8VEC2", "I8VEC3", "I8VEC4", "U8VEC2", + "U8VEC3", "U8VEC4", "DVEC2", "DVEC3", "DVEC4", "DMAT2", "DMAT3", "DMAT4", + "BF16VEC2", "BF16VEC3", "BF16VEC4", "FE5M2VEC2", "FE5M2VEC3", + "FE5M2VEC4", "FE4M3VEC2", "FE4M3VEC3", "FE4M3VEC4", "F16VEC2", "F16VEC3", + "F16VEC4", "F16MAT2", "F16MAT3", "F16MAT4", "F32VEC2", "F32VEC3", + "F32VEC4", "F32MAT2", "F32MAT3", "F32MAT4", "F64VEC2", "F64VEC3", + "F64VEC4", "F64MAT2", "F64MAT3", "F64MAT4", "DMAT2X2", "DMAT2X3", + "DMAT2X4", "DMAT3X2", "DMAT3X3", "DMAT3X4", "DMAT4X2", "DMAT4X3", + "DMAT4X4", "F16MAT2X2", "F16MAT2X3", "F16MAT2X4", "F16MAT3X2", + "F16MAT3X3", "F16MAT3X4", "F16MAT4X2", "F16MAT4X3", "F16MAT4X4", + "F32MAT2X2", "F32MAT2X3", "F32MAT2X4", "F32MAT3X2", "F32MAT3X3", + "F32MAT3X4", "F32MAT4X2", "F32MAT4X3", "F32MAT4X4", "F64MAT2X2", + "F64MAT2X3", "F64MAT2X4", "F64MAT3X2", "F64MAT3X3", "F64MAT3X4", + "F64MAT4X2", "F64MAT4X3", "F64MAT4X4", "ATOMIC_UINT", "ACCSTRUCTNV", + "ACCSTRUCTEXT", "RAYQUERYEXT", "FCOOPMATNV", "ICOOPMATNV", "UCOOPMATNV", + "COOPMAT", "COOPVECNV", "HITOBJECTNV", "HITOBJECTATTRNV", + "TENSORLAYOUTNV", "TENSORVIEWNV", "TENSORARM", "SAMPLERCUBEARRAY", + "SAMPLERCUBEARRAYSHADOW", "ISAMPLERCUBEARRAY", "USAMPLERCUBEARRAY", + "SAMPLER1D", "SAMPLER1DARRAY", "SAMPLER1DARRAYSHADOW", "ISAMPLER1D", + "SAMPLER1DSHADOW", "SAMPLER2DRECT", "SAMPLER2DRECTSHADOW", + "ISAMPLER2DRECT", "USAMPLER2DRECT", "SAMPLERBUFFER", "ISAMPLERBUFFER", + "USAMPLERBUFFER", "SAMPLER2DMS", "ISAMPLER2DMS", "USAMPLER2DMS", + "SAMPLER2DMSARRAY", "ISAMPLER2DMSARRAY", "USAMPLER2DMSARRAY", + "SAMPLEREXTERNALOES", "SAMPLEREXTERNAL2DY2YEXT", "ISAMPLER1DARRAY", + "USAMPLER1D", "USAMPLER1DARRAY", "F16SAMPLER1D", "F16SAMPLER2D", + "F16SAMPLER3D", "F16SAMPLER2DRECT", "F16SAMPLERCUBE", "F16SAMPLER1DARRAY", "F16SAMPLER2DARRAY", "F16SAMPLERCUBEARRAY", "F16SAMPLERBUFFER", "F16SAMPLER2DMS", "F16SAMPLER2DMSARRAY", "F16SAMPLER1DSHADOW", "F16SAMPLER2DSHADOW", "F16SAMPLER1DARRAYSHADOW", @@ -1419,12 +1432,12 @@ yysymbol_name (yysymbol_kind_t yysymbol) } #endif -#define YYPACT_NINF (-878) +#define YYPACT_NINF (-893) #define yypact_value_is_default(Yyn) \ ((Yyn) == YYPACT_NINF) -#define YYTABLE_NINF (-704) +#define YYTABLE_NINF (-714) #define yytable_value_is_error(Yyn) \ 0 @@ -1433,102 +1446,103 @@ yysymbol_name (yysymbol_kind_t yysymbol) STATE-NUM. */ static const yytype_int16 yypact[] = { - 4729, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -305, -273, -212, -207, -194, - -121, -113, -108, -878, -878, -878, -878, -878, -320, -878, - -878, -878, -878, -878, -196, -878, -878, -878, -878, -878, - -333, -878, -878, -878, -878, -878, -878, -878, -99, -91, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -337, -240, -67, - -64, 8026, -278, -878, -71, -878, -878, -878, -878, 5671, - -878, -878, -878, -878, -47, -878, -878, 961, -878, -878, - 8026, -29, -878, -878, -878, 6142, -53, -134, -133, -128, - -126, -118, -53, -117, -49, 12528, -878, -16, -360, -46, - -878, -316, -878, -13, -10, 8026, -878, -878, -878, 8026, - -43, -42, -878, -313, -878, -258, -878, -878, 11184, -7, - -878, -878, -878, -5, -39, 8026, -878, -12, -9, -8, - -878, -264, -878, -253, -6, -3, -2, -1, -251, 1, - 3, 4, 6, 7, 8, -233, 11, 10, 16, -310, - -878, 13, 8026, -878, 15, -878, -230, -878, -878, -226, - 9392, -878, -274, 1432, -878, -878, -878, -878, -878, -7, - -311, -878, 9840, -271, -878, -35, -878, -238, 11184, 11184, - -878, 11184, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -261, -878, -878, -878, 17, -225, 11632, 19, -878, - 11184, -878, 21, -284, 20, -10, 25, -878, -325, -53, - -878, -34, -878, -321, 24, -116, 11184, -112, -878, -151, - -111, -168, -107, 28, -100, -53, -878, 12080, -878, -98, - 11184, 29, -49, -878, 8026, -27, 6613, -878, 8026, 11184, - -878, -360, -878, 14, -878, -878, -146, -153, -101, -314, - -163, -15, 23, 18, 42, 45, -307, 31, -878, 10288, - -878, 30, -878, -878, 36, 27, 38, -878, 40, 41, - 39, 10736, 52, 11184, 46, 43, 56, 59, 61, -231, - -878, -878, -68, -878, -240, 72, 21, -878, -878, -878, - -878, -878, 1903, -878, -878, -878, -878, -878, -878, -878, - -878, -878, 5200, 20, 9840, -262, 8496, -878, -878, 9840, - 8026, -878, 44, -878, -878, -878, -221, -878, -878, 11184, - 49, -878, -878, 11184, 55, -878, -878, -878, 11184, -878, - -878, -878, -324, -878, -878, -218, 65, -878, -878, -878, - -878, -878, -878, -216, -878, -209, -878, -878, -200, 70, - -878, -878, -878, -878, -199, -878, -198, -878, -878, -878, - -878, -878, -197, -878, 71, -878, -190, 74, -188, 65, - -878, -317, -161, -878, 78, 81, -878, -878, -27, -7, - -66, -878, -878, -878, 7084, -878, -878, -878, 11184, 11184, - 11184, 11184, 11184, 11184, 11184, 11184, 11184, 11184, 11184, 11184, - 11184, 11184, 11184, 11184, 11184, 11184, 11184, -878, -878, -878, - 83, -878, 2374, -878, -878, -878, 2374, -878, 11184, -878, - -878, -41, 11184, -80, -878, -878, -878, -878, -878, -878, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - 11184, 11184, -878, -878, -878, -878, -878, -878, -878, 9840, - -878, -878, -119, -878, 7555, -878, -878, 85, 84, -878, - -878, -878, -878, -878, -252, -131, -878, -318, -878, -321, - -878, -321, -878, 11184, 11184, -878, -151, -878, -151, -878, - -168, -168, -878, 91, 28, -878, 12080, -878, 11184, -878, - -878, -37, 20, -27, -878, -878, -878, -878, -878, -146, - -146, -153, -153, -101, -101, -101, -101, -314, -314, -163, - -15, 23, 18, 42, 45, 11184, -878, 2374, 4258, 48, - 3787, -159, -878, -157, -878, -878, -878, -878, -878, 8944, - -878, -878, -878, 94, -878, 64, -878, -156, -878, -154, - -878, -152, -878, -149, -878, -147, -145, -878, -878, -878, - -33, 89, 84, 62, 99, 101, -878, -878, 4258, 98, - -878, -878, -878, -878, -878, -878, -878, -878, -878, -878, - -878, 11184, -878, 95, 2845, 11184, -878, 97, 104, 60, - 105, 3316, -878, 106, -878, 9840, -878, -878, -878, -144, - 11184, 2845, 98, -878, -878, 2374, -878, 102, 84, -878, - -878, 2374, 108, -878, -878 + 4809, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -330, -285, -276, -250, -225, -198, + -107, -96, -893, -893, -893, -893, -893, -64, -893, -893, + -893, -893, -893, -93, -893, -893, -893, -893, -893, -329, + -893, -893, -893, -893, -893, -893, -893, -41, -31, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -327, -40, -30, -143, + 8649, -244, -893, -62, -893, -893, -893, -893, 5769, -893, + -893, -893, -893, -46, -893, -893, 969, -893, -893, 8649, + -34, -893, -893, -893, 6249, -59, -251, -153, -152, -148, + -147, -59, -146, -58, 13241, -893, -25, -370, -56, -893, + -326, -893, -23, -20, 6729, -893, -893, -893, 8649, -53, + -52, -893, -279, -893, -19, -134, -893, -893, 11870, -16, + -893, -893, -893, -14, -48, 8649, -893, -21, -18, -17, + -893, -231, -893, -230, -15, -12, -11, -10, -228, -9, + -8, -7, -5, -4, -2, -227, 6, -1, 8, -293, + -893, 1, 8649, -893, 3, -893, -218, -893, -893, -200, + 10042, -893, -322, 1449, -893, -893, -13, -893, -893, -893, + -291, -256, -893, 10499, -255, -893, -44, -893, 11870, 11870, + -893, 11870, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -294, -893, -893, -893, 12, -196, 12327, 14, -893, + 11870, -893, 15, -334, 7, -20, 16, -893, -337, -59, + -893, -6, -893, -341, 17, -142, 11870, -138, -893, -306, + -137, -174, -136, 18, -128, -59, -893, 12784, -893, -127, + 11870, 19, -58, -893, 8649, -3, 7209, -893, 8649, 11870, + -893, -370, -893, 10, -893, -893, -80, -95, -297, -315, + -55, 13, 11, 21, 32, 33, -324, 20, -893, 10956, + -893, 22, -893, -893, 24, 27, 35, -893, 28, 29, + 39, 11413, 31, 11870, 26, 40, 41, 43, 44, -257, + -893, -893, -92, -893, -40, 42, 15, -893, -893, -893, + -893, -893, 1929, -893, -893, -893, -893, -893, -893, -893, + -893, -893, 5289, 37, 10499, 7, 10499, -241, 9128, -893, + -893, 10499, 8649, -893, -893, -893, -195, -893, -893, 11870, + 34, -893, -893, 11870, 61, -893, -893, -893, 11870, -893, + -893, -893, -338, -893, -893, -192, 60, -893, -893, -893, + -893, -893, -893, -188, -893, -187, -893, -893, -184, 64, + -893, -893, -893, -893, -180, -893, -179, -893, -893, -893, + -893, -893, -177, -893, 67, -893, -176, 68, -175, 60, + -893, -259, -172, -893, 76, 77, -893, -893, -3, -16, + -84, -893, -893, -893, 7689, -893, -893, -893, 11870, 11870, + 11870, 11870, 11870, 11870, 11870, 11870, 11870, 11870, 11870, 11870, + 11870, 11870, 11870, 11870, 11870, 11870, 11870, -893, -893, -893, + 78, -893, 2409, -893, -893, -893, 2409, -893, 11870, -893, + -893, -83, 11870, -264, -893, -893, -893, -893, -893, -893, + -893, -893, -893, -893, -893, -893, -893, -893, -893, -893, + 11870, 11870, -893, -893, -893, -893, -893, -893, -893, -893, + -893, 10499, -893, -893, -130, -893, 8169, -893, 82, 72, + -893, -893, -893, -893, -893, -150, -140, -893, -328, -893, + -341, -893, -341, -893, 11870, 11870, -893, -306, -893, -306, + -893, -174, -174, -893, 81, 18, -893, 12784, -893, 11870, + -893, -893, -82, 7, -3, -893, -893, -893, -893, -893, + -80, -80, -95, -95, -297, -297, -297, -297, -315, -315, + -55, 13, 11, 21, 32, 33, 11870, -893, 2409, 4329, + -24, 3849, -168, -893, -167, -893, -893, -893, -893, -893, + 9585, -893, -893, -893, 87, -893, 55, -893, -163, -893, + -160, -893, -159, -893, -158, -893, -156, -155, -893, -893, + -893, -45, 84, 72, 54, 90, 93, -893, -893, 4329, + 91, -893, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, 11870, -893, 85, 2889, 11870, -893, 88, 99, + 53, 98, 3369, -893, 101, -893, 10499, -893, -893, -893, + -151, 11870, 2889, 91, -893, -893, 2409, -893, 96, 72, + -893, -893, 2409, 102, -893, -893 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. @@ -1536,140 +1550,141 @@ static const yytype_int16 yypact[] = means the default is an error. */ static const yytype_int16 yydefact[] = { - 0, 168, 226, 224, 225, 223, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 227, 228, 229, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 356, 357, 358, 359, 360, 361, 362, 382, 383, 384, - 385, 386, 387, 388, 397, 410, 411, 398, 399, 401, - 400, 402, 403, 404, 405, 406, 407, 408, 409, 177, - 178, 252, 253, 254, 251, 255, 262, 263, 260, 261, - 258, 259, 256, 257, 288, 289, 290, 300, 301, 302, - 285, 286, 287, 297, 298, 299, 282, 283, 284, 294, - 295, 296, 279, 280, 281, 291, 292, 293, 264, 265, - 266, 303, 304, 305, 267, 268, 269, 270, 271, 272, - 315, 316, 317, 273, 274, 275, 327, 328, 329, 276, - 277, 278, 339, 340, 341, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 330, 331, 332, 333, 334, 335, 336, - 337, 338, 342, 343, 344, 345, 346, 347, 348, 349, - 350, 354, 351, 352, 353, 538, 539, 540, 541, 545, - 547, 182, 542, 543, 366, 367, 390, 393, 355, 364, - 365, 381, 363, 412, 413, 416, 417, 418, 420, 421, - 422, 424, 425, 426, 428, 429, 525, 526, 389, 391, - 392, 368, 369, 370, 414, 371, 375, 376, 379, 419, - 423, 427, 372, 373, 377, 378, 415, 374, 380, 459, - 461, 462, 463, 465, 466, 467, 469, 470, 471, 473, - 474, 475, 477, 478, 479, 481, 482, 483, 485, 486, - 487, 489, 490, 491, 493, 494, 495, 497, 498, 499, - 501, 502, 460, 464, 468, 472, 476, 484, 488, 492, - 480, 496, 500, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 520, 521, 522, 523, 524, 394, 395, 396, 430, 439, - 441, 435, 440, 442, 443, 445, 446, 447, 449, 450, - 451, 453, 454, 455, 457, 458, 431, 432, 433, 444, - 434, 436, 437, 438, 448, 452, 456, 530, 531, 534, - 535, 536, 537, 532, 533, 0, 0, 0, 0, 0, - 0, 0, 0, 166, 167, 527, 528, 529, 0, 640, - 137, 550, 551, 552, 0, 549, 172, 170, 171, 169, - 0, 222, 173, 175, 176, 174, 139, 138, 0, 204, - 544, 184, 186, 181, 188, 190, 185, 187, 183, 189, - 191, 179, 180, 207, 192, 199, 200, 201, 202, 203, - 193, 194, 195, 196, 197, 198, 140, 141, 143, 142, - 144, 146, 147, 145, 206, 154, 639, 0, 641, 0, - 114, 113, 0, 125, 130, 161, 160, 158, 162, 0, - 155, 157, 163, 135, 217, 159, 548, 0, 636, 638, - 0, 0, 164, 165, 546, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 555, 0, 0, 0, - 99, 0, 94, 0, 109, 0, 121, 115, 123, 0, - 124, 0, 97, 131, 102, 0, 156, 136, 0, 210, - 216, 1, 637, 0, 0, 0, 96, 0, 0, 0, - 648, 0, 706, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 646, 0, - 644, 0, 0, 553, 151, 153, 0, 149, 208, 0, - 0, 100, 0, 0, 642, 110, 116, 120, 122, 118, - 126, 117, 0, 132, 105, 0, 103, 0, 0, 0, + 0, 169, 227, 225, 226, 224, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 228, 229, 230, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 365, 366, 367, 368, 369, 370, 371, 391, 392, 393, + 394, 395, 396, 397, 406, 419, 420, 407, 408, 410, + 409, 411, 412, 413, 414, 415, 416, 417, 418, 178, + 179, 254, 255, 253, 256, 257, 252, 258, 265, 266, + 263, 264, 261, 262, 259, 260, 297, 298, 299, 309, + 310, 311, 294, 295, 296, 306, 307, 308, 291, 292, + 293, 303, 304, 305, 288, 289, 290, 300, 301, 302, + 267, 268, 269, 312, 313, 314, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 324, 325, + 326, 282, 283, 284, 336, 337, 338, 285, 286, 287, + 348, 349, 350, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 339, 340, 341, 342, 343, 344, 345, 346, 347, + 351, 352, 353, 354, 355, 356, 357, 358, 359, 363, + 360, 361, 362, 547, 548, 549, 550, 554, 557, 183, + 551, 552, 555, 375, 376, 399, 402, 364, 373, 374, + 390, 372, 421, 422, 425, 426, 427, 429, 430, 431, + 433, 434, 435, 437, 438, 534, 535, 398, 400, 401, + 377, 378, 379, 423, 380, 384, 385, 388, 428, 432, + 436, 381, 382, 386, 387, 424, 383, 389, 468, 470, + 471, 472, 474, 475, 476, 478, 479, 480, 482, 483, + 484, 486, 487, 488, 490, 491, 492, 494, 495, 496, + 498, 499, 500, 502, 503, 504, 506, 507, 508, 510, + 511, 469, 473, 477, 481, 485, 493, 497, 501, 489, + 505, 509, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, + 530, 531, 532, 533, 403, 404, 405, 439, 448, 450, + 444, 449, 451, 452, 454, 455, 456, 458, 459, 460, + 462, 463, 464, 466, 467, 440, 441, 442, 453, 443, + 445, 446, 447, 457, 461, 465, 539, 540, 543, 544, + 545, 546, 541, 542, 0, 0, 0, 0, 0, 0, + 0, 0, 167, 168, 536, 537, 538, 0, 650, 138, + 560, 561, 562, 0, 559, 173, 171, 172, 170, 0, + 223, 174, 176, 177, 175, 140, 139, 0, 205, 553, + 185, 187, 182, 189, 191, 186, 188, 184, 190, 192, + 180, 181, 208, 193, 200, 201, 202, 203, 204, 194, + 195, 196, 197, 198, 199, 141, 142, 144, 143, 145, + 147, 148, 146, 207, 155, 649, 0, 651, 0, 113, + 112, 0, 126, 131, 162, 161, 159, 163, 0, 156, + 158, 164, 136, 218, 160, 558, 0, 646, 648, 0, + 0, 165, 166, 556, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 565, 0, 0, 0, 99, + 0, 94, 0, 108, 0, 122, 114, 124, 0, 125, + 0, 97, 132, 102, 106, 0, 157, 137, 0, 211, + 217, 1, 647, 0, 0, 0, 96, 0, 0, 0, + 658, 0, 716, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 656, 0, + 654, 0, 0, 563, 152, 154, 0, 150, 209, 0, + 0, 100, 0, 0, 652, 109, 0, 115, 121, 123, + 118, 127, 117, 0, 133, 104, 0, 103, 0, 0, 9, 0, 43, 42, 44, 41, 5, 6, 7, 8, 2, 16, 14, 15, 17, 10, 11, 12, 13, 3, - 18, 37, 20, 25, 26, 0, 0, 30, 0, 220, - 0, 36, 219, 0, 211, 111, 0, 95, 0, 0, - 704, 0, 656, 0, 0, 0, 0, 0, 673, 0, - 0, 0, 0, 0, 0, 0, 698, 0, 671, 0, - 0, 0, 0, 98, 0, 0, 0, 557, 0, 0, - 148, 0, 205, 0, 212, 45, 49, 52, 55, 60, + 18, 37, 20, 25, 26, 0, 0, 30, 0, 221, + 0, 36, 220, 0, 212, 110, 0, 95, 0, 0, + 714, 0, 666, 0, 0, 0, 0, 0, 683, 0, + 0, 0, 0, 0, 0, 0, 708, 0, 681, 0, + 0, 0, 0, 98, 0, 0, 0, 567, 0, 0, + 149, 0, 206, 0, 213, 45, 49, 52, 55, 60, 63, 65, 67, 69, 71, 73, 75, 0, 34, 0, - 101, 584, 593, 597, 0, 0, 0, 618, 0, 0, + 101, 594, 603, 607, 0, 0, 0, 628, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, - 78, 91, 0, 571, 0, 163, 135, 574, 595, 573, - 581, 572, 0, 575, 576, 599, 577, 606, 578, 579, - 614, 580, 0, 119, 0, 127, 0, 565, 134, 0, - 0, 107, 0, 104, 38, 39, 0, 22, 23, 0, - 0, 28, 27, 0, 222, 31, 33, 40, 0, 218, - 112, 708, 0, 709, 649, 0, 0, 707, 668, 664, - 665, 666, 667, 0, 662, 0, 93, 669, 0, 0, - 683, 684, 685, 686, 0, 681, 0, 690, 691, 692, - 693, 689, 0, 687, 0, 694, 0, 0, 0, 2, - 702, 217, 0, 700, 0, 0, 643, 645, 0, 563, - 0, 561, 556, 558, 0, 152, 150, 209, 0, 0, + 78, 91, 0, 581, 0, 164, 136, 584, 605, 583, + 591, 582, 0, 585, 586, 609, 587, 616, 588, 589, + 624, 590, 0, 0, 0, 119, 0, 128, 0, 575, + 135, 0, 0, 107, 38, 39, 0, 22, 23, 0, + 0, 28, 27, 0, 223, 31, 33, 40, 0, 219, + 111, 718, 0, 719, 659, 0, 0, 717, 678, 674, + 675, 676, 677, 0, 672, 0, 93, 679, 0, 0, + 693, 694, 695, 696, 0, 691, 0, 700, 701, 702, + 703, 699, 0, 697, 0, 704, 0, 0, 0, 2, + 712, 218, 0, 710, 0, 0, 653, 655, 0, 573, + 0, 571, 566, 568, 0, 153, 151, 210, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 76, 213, 214, - 0, 583, 0, 616, 629, 628, 0, 620, 0, 632, - 630, 0, 0, 0, 613, 633, 634, 635, 582, 81, + 0, 0, 0, 0, 0, 0, 0, 76, 214, 215, + 0, 593, 0, 626, 639, 638, 0, 630, 0, 642, + 640, 0, 0, 0, 623, 643, 644, 645, 592, 81, 82, 84, 83, 86, 87, 88, 89, 90, 85, 80, - 0, 0, 598, 594, 596, 600, 607, 615, 129, 0, - 568, 569, 0, 133, 0, 108, 4, 0, 24, 21, - 32, 221, 652, 654, 0, 0, 705, 0, 658, 0, - 657, 0, 660, 0, 0, 675, 0, 674, 0, 677, - 0, 0, 679, 0, 0, 699, 0, 696, 0, 672, - 647, 0, 564, 0, 559, 554, 46, 47, 48, 51, - 50, 53, 54, 58, 59, 56, 57, 61, 62, 64, - 66, 68, 70, 72, 74, 0, 215, 585, 0, 0, - 0, 0, 631, 0, 612, 79, 92, 128, 566, 0, - 106, 19, 650, 0, 651, 0, 663, 0, 670, 0, - 682, 0, 688, 0, 695, 0, 0, 701, 560, 562, - 0, 0, 604, 0, 0, 0, 623, 622, 625, 591, - 608, 567, 570, 653, 655, 659, 661, 676, 678, 680, - 697, 0, 586, 0, 0, 0, 624, 0, 0, 603, - 0, 0, 601, 0, 77, 0, 588, 617, 587, 0, - 626, 0, 591, 590, 592, 610, 605, 0, 627, 621, - 602, 611, 0, 619, 609 + 0, 0, 608, 604, 606, 610, 617, 625, 116, 120, + 130, 0, 578, 579, 0, 134, 0, 4, 0, 24, + 21, 32, 222, 662, 664, 0, 0, 715, 0, 668, + 0, 667, 0, 670, 0, 0, 685, 0, 684, 0, + 687, 0, 0, 689, 0, 0, 709, 0, 706, 0, + 682, 657, 0, 574, 0, 569, 564, 46, 47, 48, + 51, 50, 53, 54, 58, 59, 56, 57, 61, 62, + 64, 66, 68, 70, 72, 74, 0, 216, 595, 0, + 0, 0, 0, 641, 0, 622, 79, 92, 129, 576, + 0, 105, 19, 660, 0, 661, 0, 673, 0, 680, + 0, 692, 0, 698, 0, 705, 0, 0, 711, 570, + 572, 0, 0, 614, 0, 0, 0, 633, 632, 635, + 601, 618, 577, 580, 663, 665, 669, 671, 686, 688, + 690, 707, 0, 596, 0, 0, 0, 634, 0, 0, + 613, 0, 0, 611, 0, 77, 0, 598, 627, 597, + 0, 636, 0, 601, 600, 602, 620, 615, 0, 637, + 631, 612, 621, 0, 629, 619 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -878, -557, -878, -878, -878, -878, -878, -878, -878, -878, - -878, -878, -431, -878, -403, -397, -489, -409, -275, -279, - -272, -276, -270, -277, -878, -494, -878, -497, -878, -517, - -548, 9, -878, -878, -878, 5, -399, -878, -878, 33, - 35, 34, -878, -878, -417, -878, -878, -878, -878, -105, - -878, -400, -381, -878, 12, -878, 0, -430, -878, -878, - -878, -570, 140, -878, -878, -878, -564, -567, -241, -355, - -643, -878, -380, -625, -877, -878, -441, -878, -878, -448, - -447, -878, -878, 51, -740, -374, -878, -155, -878, -410, - -878, -150, -878, -878, -878, -878, -143, -878, -878, -878, - -878, -878, -878, -878, -878, 82, -878, -878, 2, -878, - -82, -232, -385, -878, -878, -878, -315, -312, -323, -878, - -878, -309, -308, -326, -319, -322, -878, -306, -328, -878, - -398, -551 + -893, -569, -893, -893, -893, -893, -893, -893, -893, -893, + -893, -893, -438, -893, -526, -417, -516, -421, -287, -283, + -282, -284, -280, -278, -893, -503, -893, -509, -893, -504, + -550, 4, -893, -893, -893, 5, -413, -893, -893, 25, + 36, 38, -893, -893, -426, -893, -893, -893, -893, -119, + -893, -409, -387, -893, 9, -893, 0, -452, -893, -893, + -893, -566, 133, -893, -893, -893, -570, -573, -249, -367, + -653, -893, -390, -633, -892, -893, -447, -893, -893, -460, + -458, -893, -893, 45, -748, -383, -893, -162, -893, -420, + -893, -161, -893, -893, -893, -893, -157, -893, -893, -893, + -893, -893, -893, -893, -893, 80, -893, -893, 2, -893, + -89, -272, -449, -893, -893, -893, -325, -321, -331, -893, + -893, -323, -320, -319, -333, -318, -893, -335, -317, -893, + -406, -565 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - 0, 539, 540, 541, 807, 542, 543, 544, 545, 546, - 547, 548, 629, 550, 596, 597, 598, 599, 600, 601, - 602, 603, 604, 605, 606, 630, 865, 631, 790, 632, - 720, 633, 397, 660, 517, 634, 399, 400, 401, 446, - 447, 448, 402, 403, 404, 405, 406, 407, 496, 497, - 408, 409, 410, 411, 551, 499, 608, 502, 459, 460, - 553, 414, 415, 416, 588, 492, 586, 587, 730, 731, - 658, 802, 637, 638, 639, 640, 641, 762, 901, 937, - 929, 930, 931, 938, 642, 643, 644, 645, 932, 904, - 646, 647, 933, 952, 648, 649, 650, 868, 766, 870, - 908, 927, 928, 651, 417, 418, 419, 443, 652, 489, - 490, 469, 470, 814, 815, 421, 693, 694, 698, 422, - 423, 704, 705, 712, 713, 716, 424, 722, 723, 425, - 471, 472 + 0, 549, 550, 551, 818, 552, 553, 554, 555, 556, + 557, 558, 639, 560, 606, 607, 608, 609, 610, 611, + 612, 613, 614, 615, 616, 640, 876, 641, 800, 642, + 730, 643, 406, 672, 465, 644, 408, 409, 410, 455, + 456, 457, 411, 412, 413, 414, 415, 416, 506, 507, + 417, 418, 419, 420, 561, 509, 618, 512, 469, 470, + 563, 423, 424, 425, 598, 502, 596, 597, 740, 741, + 670, 814, 647, 648, 649, 650, 651, 772, 912, 948, + 940, 941, 942, 949, 652, 653, 654, 655, 943, 915, + 656, 657, 944, 963, 658, 659, 660, 879, 776, 881, + 919, 938, 939, 661, 426, 427, 428, 452, 662, 499, + 500, 479, 480, 825, 826, 430, 703, 704, 708, 431, + 432, 714, 715, 722, 723, 726, 433, 732, 733, 434, + 481, 482 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If @@ -1677,480 +1692,152 @@ static const yytype_int16 yydefgoto[] = number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { - 413, 449, 420, 464, 666, 398, 607, 721, 464, 396, - 687, 798, 412, 801, 711, 657, 803, 794, 697, 733, - 465, 463, 867, 513, 734, 465, 687, 549, 456, 554, - 745, 746, 725, 436, 485, 440, 681, 812, 494, 682, - 688, 735, 756, 681, 434, 449, -703, 936, 500, 511, - 675, 500, -703, 500, 944, 581, 501, 426, 512, 582, - 654, 441, 495, 458, 936, 437, 747, 748, 456, 595, - 683, 813, 696, 689, 690, 691, 692, 683, 757, 653, - 655, 667, 668, 696, 456, 678, 696, 664, 665, 427, - 609, 451, 584, 609, 452, 696, 804, 679, 610, 560, - 659, -35, 609, 669, 771, 561, 773, 670, 514, 799, - 562, 515, 568, 882, 516, 760, 563, 883, 569, 677, - 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, - 576, 662, 442, 590, 663, 595, 577, 592, 672, 591, - 789, 869, 806, 593, 673, 816, 595, 818, 791, 595, - 428, 561, 808, 819, 820, 429, 877, 657, 595, 657, - 821, 685, 657, 822, 825, 827, 829, 733, 430, 823, - 826, 828, 830, 832, 684, 835, 810, 718, 595, 833, - 684, 836, 684, 749, 750, 684, 584, 684, 584, 684, - 684, 341, 342, 343, 684, 475, 477, 479, 481, 483, - 484, 487, 837, 456, 909, 951, 910, 915, 838, 916, - 791, 917, 791, 819, 918, 823, 919, 826, 920, 947, - 830, 741, 833, 742, 838, 791, 707, 708, 709, 710, - 530, 738, 739, 740, 884, 464, 912, 733, 885, 743, - 744, 431, 794, 700, 701, 702, 703, 811, 878, 432, - 879, 871, 465, 463, 433, 873, 853, 854, 855, 856, - 584, 473, 476, 438, 474, 474, 721, 478, 721, 480, - 474, 439, 474, 711, 711, 888, 697, 482, 486, 695, - 474, 474, 474, 699, 706, 687, 474, 474, 714, 791, - 874, 474, 946, 875, 876, 717, 444, 724, 474, 842, - 474, 791, 657, 843, 792, 445, 844, 846, 847, 848, - 595, 595, 595, 595, 595, 595, 595, 595, 595, 595, - 595, 595, 595, 595, 595, 595, 794, 453, 791, 696, - 696, 872, 843, 458, 584, 898, 791, 921, 849, 850, - 857, 858, 696, 466, 696, 468, 851, 852, 900, 488, - 493, 902, 498, 503, 338, 509, 510, 500, 555, 556, - 557, 559, 558, 661, 686, 564, 565, 566, 567, 751, - 570, 729, 571, 572, 578, 573, 574, 575, 580, 579, - 671, 676, 657, -34, 609, 583, 589, 511, 682, 715, - 754, 902, 595, 595, 726, 755, 758, 761, 763, 764, - 753, 450, 767, 768, 584, 595, 752, 595, 939, 457, - 765, 769, 737, 412, 772, 775, 774, 413, -29, 420, - 413, 412, 398, 948, 934, 413, 396, 420, 776, 412, - 467, 777, 412, 778, -36, 491, 817, 412, 657, 824, - 831, 839, 805, 834, 840, 450, 505, 809, 866, 450, - 881, 903, 894, 791, 905, 913, 922, 412, 552, 914, - 923, 412, 924, 925, -589, 457, 935, 941, 465, 940, - 942, 611, 945, 860, 953, 954, 859, 412, 862, 864, - 506, 861, 507, 508, 435, 863, 736, 841, 899, 943, - 906, 903, 585, 949, 504, 950, 907, 795, 926, 462, - 727, 889, 796, 636, 412, 893, 887, 886, 465, 797, - 897, 892, 895, 0, 0, 635, 0, 0, 890, 891, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 896, 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, 680, 0, 0, + 422, 458, 429, 474, 405, 407, 697, 617, 474, 421, + 524, 809, 721, 810, 669, 813, 473, 564, 815, 804, + 475, 731, 697, 743, 878, 475, 707, 676, 744, 698, + 559, 466, 823, 691, 766, 495, 692, 504, 755, 756, + 735, 435, 691, 947, 688, 458, 445, 510, 685, 745, + 955, 619, 753, 754, 449, 511, 689, 677, 678, 620, + 947, 505, 699, 700, 701, 702, 824, 693, 665, 667, + 767, 466, 605, 706, 757, 758, 693, -35, 446, 679, + 450, 591, 510, 680, 706, 592, 436, 706, 466, 664, + 674, 675, 522, 594, 510, 437, 706, 710, 711, 712, + 713, 523, 816, 789, 790, 791, 792, 793, 794, 795, + 796, 797, 798, -713, 801, 885, 770, 510, 619, -713, + 694, 438, 687, 799, 666, 671, 694, 781, 694, 783, + 468, 694, 619, 694, 460, 694, 694, 461, 605, 811, + 694, 570, 572, 880, 578, 586, 439, 571, 573, 605, + 579, 587, 605, 483, 600, 669, 484, 669, 888, 669, + 601, 605, 669, 695, 485, 487, 489, 491, 493, 494, + 497, 743, 602, 440, 821, 819, 682, 817, 603, 728, + 827, 605, 683, 801, 829, 831, 571, 594, 833, 594, + 830, 832, 836, 838, 834, 840, 843, 846, 837, 839, + 848, 841, 844, 847, 920, 921, 849, 466, 962, 926, + 801, 801, 927, 928, 929, 830, 930, 931, 834, 837, + 841, 958, 844, 849, 893, 860, 861, 801, 894, 717, + 718, 719, 720, 540, 895, 454, 474, 923, 896, 864, + 865, 866, 867, 743, 526, 804, 889, 527, 890, 473, + 822, 486, 488, 475, 484, 484, 490, 492, 496, 484, + 484, 484, 705, 594, 441, 484, 709, 716, 724, 484, + 484, 484, 721, 721, 882, 442, 727, 734, 884, 484, + 484, 731, 697, 731, 899, 707, 801, 853, 751, 802, + 752, 886, 887, 957, 854, 801, 854, 855, 883, 909, + 759, 760, 669, 350, 351, 352, 748, 749, 750, 443, + 857, 858, 859, 605, 605, 605, 605, 605, 605, 605, + 605, 605, 605, 605, 605, 605, 605, 605, 605, 804, + 447, 706, 706, 801, 932, 594, 862, 863, 868, 869, + 448, 451, 453, 468, 706, 462, 706, 476, 478, 498, + 503, 508, 513, 347, 520, 521, 525, 510, 565, 566, + 567, 569, 568, 673, 663, 574, 575, 576, 577, 580, + 581, 582, 911, 583, 584, 913, 585, 589, 588, 590, + 619, 669, 593, 599, 681, 686, -34, 522, 725, 764, + 692, 916, 765, 736, 768, 773, 605, 605, 771, 777, + 778, 696, 782, 762, 739, 784, 761, 594, 774, 605, + 459, 605, 763, -36, 808, 913, 775, 747, 467, 421, + 779, 785, 786, 945, 787, 788, 422, 421, 429, 422, + 405, 407, 950, -29, 422, 421, 429, 669, 421, 477, + 828, 820, 835, 421, 501, 842, 845, 959, 850, 851, + 801, 905, 877, 914, 459, 515, 892, 924, 459, 925, + 933, 934, 935, 421, 936, 946, -599, 421, 562, 951, + 475, 952, 953, 621, 870, 467, 956, 964, 965, 871, + 873, 872, 746, 518, 421, 874, 444, 910, 875, 852, + 517, 917, 960, 914, 954, 961, 519, 514, 918, 937, + 805, 806, 595, 737, 900, 807, 472, 898, 903, 897, + 475, 421, 907, 646, 0, 0, 902, 901, 0, 0, + 0, 0, 645, 904, 0, 0, 0, 906, 0, 0, + 0, 0, 908, 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, 728, 0, 585, 0, 585, 0, - 0, 0, 0, 0, 0, 0, 412, 0, 412, 0, - 412, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 690, 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, 738, 0, 595, 0, 595, 0, + 0, 0, 0, 421, 0, 421, 0, 421, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 636, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 413, 0, 635, 0, 0, 0, 0, 0, - 585, 0, 0, 0, 412, 0, 0, 0, 0, 0, - 0, 0, 412, 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, 646, 0, 0, 0, 0, 0, 0, 0, + 0, 645, 422, 0, 0, 0, 0, 0, 0, 0, + 0, 421, 595, 0, 0, 0, 0, 0, 0, 0, + 0, 421, 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, 585, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 412, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 636, 0, 0, 0, 636, 0, 0, 0, - 0, 0, 0, 0, 635, 0, 0, 0, 635, 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, 585, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 412, 0, 0, 0, + 0, 0, 0, 0, 595, 0, 0, 0, 0, 0, + 0, 0, 0, 421, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 646, 0, 0, 0, 646, 0, 0, 0, + 0, 645, 0, 0, 0, 645, 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, 595, 0, 0, 0, + 0, 0, 0, 0, 0, 421, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 636, 636, 0, - 636, 0, 420, 0, 0, 0, 0, 0, 0, 635, - 635, 0, 635, 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, 636, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 635, 0, 0, 0, 636, 0, 0, 0, 0, 0, - 0, 636, 0, 0, 0, 0, 635, 0, 0, 0, - 0, 636, 0, 635, 0, 636, 0, 0, 0, 0, - 0, 636, 0, 635, 0, 0, 0, 635, 0, 0, - 0, 461, 0, 635, 1, 2, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 338, 0, 0, 0, 0, - 0, 0, 0, 339, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 340, 341, 342, - 343, 344, 0, 0, 0, 0, 0, 0, 0, 0, - 345, 346, 347, 348, 349, 350, 351, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 352, 353, 354, 355, 356, 357, 358, 0, - 0, 0, 0, 0, 0, 0, 0, 359, 0, 360, - 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, - 391, 392, 393, 394, 395, 1, 2, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, - 336, 337, 0, 0, 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 520, 521, 0, 338, 0, 611, 612, - 0, 0, 0, 0, 613, 522, 523, 524, 525, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 340, 341, - 342, 343, 344, 0, 0, 0, 526, 527, 528, 529, - 530, 345, 346, 347, 348, 349, 350, 351, 614, 615, - 616, 617, 0, 618, 619, 620, 621, 622, 623, 624, - 625, 626, 627, 352, 353, 354, 355, 356, 357, 358, - 531, 532, 533, 534, 535, 536, 537, 538, 359, 628, - 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, - 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, - 390, 391, 392, 393, 394, 395, 1, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 337, 0, 0, 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 520, 521, 0, 338, 0, 611, - 793, 0, 0, 0, 0, 613, 522, 523, 524, 525, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 340, - 341, 342, 343, 344, 0, 0, 0, 526, 527, 528, - 529, 530, 345, 346, 347, 348, 349, 350, 351, 614, - 615, 616, 617, 0, 618, 619, 620, 621, 622, 623, - 624, 625, 626, 627, 352, 353, 354, 355, 356, 357, - 358, 531, 532, 533, 534, 535, 536, 537, 538, 359, - 628, 360, 361, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, - 389, 390, 391, 392, 393, 394, 395, 1, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, 335, 336, 337, 0, 0, 518, 519, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 646, 646, + 0, 646, 0, 429, 0, 0, 0, 645, 645, 0, + 645, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 520, 521, 0, 338, 0, - 611, 0, 0, 0, 0, 0, 613, 522, 523, 524, - 525, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 340, 341, 342, 343, 344, 0, 0, 0, 526, 527, - 528, 529, 530, 345, 346, 347, 348, 349, 350, 351, - 614, 615, 616, 617, 0, 618, 619, 620, 621, 622, - 623, 624, 625, 626, 627, 352, 353, 354, 355, 356, - 357, 358, 531, 532, 533, 534, 535, 536, 537, 538, - 359, 628, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, 335, 336, 337, 0, 0, 518, 519, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 646, + 0, 0, 0, 0, 0, 0, 0, 0, 645, 0, + 0, 0, 0, 0, 0, 646, 0, 0, 0, 0, + 0, 0, 646, 0, 645, 0, 0, 0, 0, 0, + 0, 645, 646, 0, 0, 0, 646, 0, 0, 0, + 0, 645, 646, 0, 0, 645, 0, 0, 0, 471, + 0, 645, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 520, 521, 0, 338, - 0, 503, 0, 0, 0, 0, 0, 613, 522, 523, - 524, 525, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 340, 341, 342, 343, 344, 0, 0, 0, 526, - 527, 528, 529, 530, 345, 346, 347, 348, 349, 350, - 351, 614, 615, 616, 617, 0, 618, 619, 620, 621, - 622, 623, 624, 625, 626, 627, 352, 353, 354, 355, - 356, 357, 358, 531, 532, 533, 534, 535, 536, 537, - 538, 359, 628, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 1, - 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, - 332, 333, 334, 335, 336, 337, 0, 0, 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 520, 521, 0, - 338, 0, 0, 0, 0, 0, 0, 0, 613, 522, - 523, 524, 525, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 340, 341, 342, 343, 344, 0, 0, 0, - 526, 527, 528, 529, 530, 345, 346, 347, 348, 349, - 350, 351, 614, 615, 616, 617, 0, 618, 619, 620, - 621, 622, 623, 624, 625, 626, 627, 352, 353, 354, - 355, 356, 357, 358, 531, 532, 533, 534, 535, 536, - 537, 538, 359, 628, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, - 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, - 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, - 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, - 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, - 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, - 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, - 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 0, 0, 518, - 519, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 520, 521, - 0, 338, 0, 0, 0, 0, 0, 0, 0, 613, - 522, 523, 524, 525, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 340, 341, 342, 343, 344, 0, 0, - 0, 526, 527, 528, 529, 530, 345, 346, 347, 348, - 349, 350, 351, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 352, 353, - 354, 355, 356, 357, 358, 531, 532, 533, 534, 535, - 536, 537, 538, 359, 0, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, - 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 1, 2, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 0, 0, 0, 328, 329, - 330, 331, 332, 333, 334, 335, 336, 337, 0, 0, - 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 520, - 521, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 522, 523, 524, 525, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 340, 341, 342, 343, 0, 0, - 0, 0, 526, 527, 528, 529, 530, 345, 346, 347, - 348, 349, 350, 351, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 352, - 353, 354, 355, 356, 357, 358, 531, 532, 533, 534, - 535, 536, 537, 538, 359, 0, 360, 361, 362, 363, - 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 1, 2, 3, 4, 5, 6, 7, 8, + 0, 0, 347, 0, 0, 0, 0, 0, 0, 0, + 348, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 353, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 355, 356, + 357, 358, 359, 360, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 361, + 362, 363, 364, 365, 366, 367, 0, 0, 0, 0, + 0, 0, 0, 0, 368, 0, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, @@ -2183,530 +1870,742 @@ static const yytype_int16 yytable[] = 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 336, 337, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 338, 0, 0, 0, 0, 0, 0, - 0, 339, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 340, 341, 342, 343, 344, - 0, 0, 0, 0, 0, 0, 0, 0, 345, 346, - 347, 348, 349, 350, 351, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 352, 353, 354, 355, 356, 357, 358, 0, 0, 0, - 0, 0, 0, 0, 0, 359, 0, 360, 361, 362, - 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, + 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 530, + 531, 0, 347, 0, 621, 622, 0, 0, 0, 0, + 623, 532, 533, 534, 535, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 353, 0, + 0, 0, 536, 537, 538, 539, 540, 354, 355, 356, + 357, 358, 359, 360, 624, 625, 626, 627, 0, 628, + 629, 630, 631, 632, 633, 634, 635, 636, 637, 361, + 362, 363, 364, 365, 366, 367, 541, 542, 543, 544, + 545, 546, 547, 548, 368, 638, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 1, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 0, 0, 0, - 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, - 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, 340, 341, 342, 343, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 345, - 346, 347, 348, 349, 350, 351, 614, 0, 0, 617, - 0, 618, 619, 0, 0, 622, 0, 0, 0, 0, - 0, 352, 353, 354, 355, 356, 357, 358, 0, 0, - 0, 0, 0, 0, 0, 0, 359, 0, 360, 361, - 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 1, 2, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 0, 0, - 0, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 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, 454, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 340, 341, 342, - 343, 0, 0, 0, 0, 0, 0, 0, 0, 455, - 345, 346, 347, 348, 349, 350, 351, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 352, 353, 354, 355, 356, 357, 358, 0, - 0, 0, 0, 0, 0, 0, 0, 359, 0, 360, - 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, - 391, 392, 393, 394, 395, 1, 2, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 0, - 0, 0, 328, 329, 330, 331, 332, 333, 334, 335, - 336, 337, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 338, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 340, 341, - 342, 343, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 345, 346, 347, 348, 349, 350, 351, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 352, 353, 354, 355, 356, 357, 358, - 0, 0, 0, 0, 0, 0, 0, 0, 359, 0, - 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, - 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, - 390, 391, 392, 393, 394, 395, 1, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 0, 0, 0, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 337, 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, - 732, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 340, - 341, 342, 343, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 345, 346, 347, 348, 349, 350, 351, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 352, 353, 354, 355, 356, 357, - 358, 0, 0, 0, 0, 0, 0, 0, 0, 359, - 0, 360, 361, 362, 363, 364, 365, 366, 367, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, - 389, 390, 391, 392, 393, 394, 395, 1, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 0, 0, 0, 328, 329, 330, 331, 332, 333, - 334, 335, 336, 337, 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, 845, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 340, 341, 342, 343, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 345, 346, 347, 348, 349, 350, 351, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 352, 353, 354, 355, 356, - 357, 358, 0, 0, 0, 0, 0, 0, 0, 0, - 359, 0, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 1, 2, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 0, 0, 0, 328, 329, 330, 331, 332, - 333, 334, 335, 336, 337, 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, 880, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 340, 341, 342, 343, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 345, 346, 347, 348, 349, 350, - 351, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 352, 353, 354, 355, - 356, 357, 358, 0, 0, 0, 0, 0, 0, 0, - 0, 359, 0, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 1, - 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 323, 324, 0, 0, 0, 328, 329, 330, 331, - 332, 333, 334, 335, 336, 337, 0, 0, 0, 0, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, + 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 530, + 531, 0, 347, 0, 621, 803, 0, 0, 0, 0, + 623, 532, 533, 534, 535, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 353, 0, + 0, 0, 536, 537, 538, 539, 540, 354, 355, 356, + 357, 358, 359, 360, 624, 625, 626, 627, 0, 628, + 629, 630, 631, 632, 633, 634, 635, 636, 637, 361, + 362, 363, 364, 365, 366, 367, 541, 542, 543, 544, + 545, 546, 547, 548, 368, 638, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, + 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 530, + 531, 0, 347, 0, 621, 0, 0, 0, 0, 0, + 623, 532, 533, 534, 535, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 353, 0, + 0, 0, 536, 537, 538, 539, 540, 354, 355, 356, + 357, 358, 359, 360, 624, 625, 626, 627, 0, 628, + 629, 630, 631, 632, 633, 634, 635, 636, 637, 361, + 362, 363, 364, 365, 366, 367, 541, 542, 543, 544, + 545, 546, 547, 548, 368, 638, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, + 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 530, + 531, 0, 347, 0, 513, 0, 0, 0, 0, 0, + 623, 532, 533, 534, 535, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 353, 0, + 0, 0, 536, 537, 538, 539, 540, 354, 355, 356, + 357, 358, 359, 360, 624, 625, 626, 627, 0, 628, + 629, 630, 631, 632, 633, 634, 635, 636, 637, 361, + 362, 363, 364, 365, 366, 367, 541, 542, 543, 544, + 545, 546, 547, 548, 368, 638, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, + 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 530, + 531, 0, 347, 0, 0, 0, 0, 0, 0, 0, + 623, 532, 533, 534, 535, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 353, 0, + 0, 0, 536, 537, 538, 539, 540, 354, 355, 356, + 357, 358, 359, 360, 624, 625, 626, 627, 0, 628, + 629, 630, 631, 632, 633, 634, 635, 636, 637, 361, + 362, 363, 364, 365, 366, 367, 541, 542, 543, 544, + 545, 546, 547, 548, 368, 638, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, + 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 530, + 531, 0, 347, 0, 0, 0, 0, 0, 0, 0, + 623, 532, 533, 534, 535, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 353, 0, + 0, 0, 536, 537, 538, 539, 540, 354, 355, 356, + 357, 358, 359, 360, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 361, + 362, 363, 364, 365, 366, 367, 541, 542, 543, 544, + 545, 546, 547, 548, 368, 0, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 0, 0, 0, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, + 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 530, + 531, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 532, 533, 534, 535, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 0, 0, + 0, 0, 536, 537, 538, 539, 540, 354, 355, 356, + 357, 358, 359, 360, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 361, + 362, 363, 364, 365, 366, 367, 541, 542, 543, 544, + 545, 546, 547, 548, 368, 0, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 347, 0, 0, 0, 0, 0, 0, 0, + 348, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 353, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 355, 356, + 357, 358, 359, 360, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 361, + 362, 363, 364, 365, 366, 367, 0, 0, 0, 0, + 0, 0, 0, 0, 368, 0, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 0, 0, 0, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 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, 349, 350, 351, 352, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 355, 356, + 357, 358, 359, 360, 624, 0, 0, 627, 0, 628, + 629, 0, 0, 632, 0, 0, 0, 0, 0, 361, + 362, 363, 364, 365, 366, 367, 0, 0, 0, 0, + 0, 0, 0, 0, 368, 0, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 0, 0, 0, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 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, + 463, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 0, 0, + 0, 0, 0, 0, 0, 0, 464, 354, 355, 356, + 357, 358, 359, 360, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 361, + 362, 363, 364, 365, 366, 367, 0, 0, 0, 0, + 0, 0, 0, 0, 368, 0, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 0, 0, 0, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 340, 341, 342, 343, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 345, 346, 347, 348, 349, - 350, 351, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 352, 353, 354, - 355, 356, 357, 358, 0, 0, 0, 0, 0, 0, - 0, 0, 359, 0, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, - 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, - 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, - 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 0, 0, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 0, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 323, 324, 0, 0, 0, 0, 0, 0, 331, - 0, 0, 0, 335, 336, 337, 0, 0, 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 520, 521, 0, - 0, 0, 656, 800, 0, 0, 0, 0, 0, 522, - 523, 524, 525, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 347, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 526, 527, 528, 529, 530, 345, 0, 0, 0, 0, - 350, 351, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 355, 356, + 357, 358, 359, 360, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 361, + 362, 363, 364, 365, 366, 367, 0, 0, 0, 0, + 0, 0, 0, 0, 368, 0, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 0, 0, 0, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 531, 532, 533, 534, 535, 536, - 537, 538, 0, 0, 360, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 373, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 0, 0, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 0, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 0, 0, 0, 0, 0, 0, 331, 0, 0, - 0, 335, 336, 337, 0, 0, 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 520, 521, 0, 0, 0, - 656, 911, 0, 0, 0, 0, 0, 522, 523, 524, - 525, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 526, 527, - 528, 529, 530, 345, 0, 0, 0, 0, 350, 351, + 0, 0, 0, 0, 0, 0, 516, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 355, 356, + 357, 358, 359, 360, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 361, + 362, 363, 364, 365, 366, 367, 0, 0, 0, 0, + 0, 0, 0, 0, 368, 0, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 0, 0, 0, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 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, 742, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 355, 356, + 357, 358, 359, 360, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 361, + 362, 363, 364, 365, 366, 367, 0, 0, 0, 0, + 0, 0, 0, 0, 368, 0, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 0, 0, 0, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 531, 532, 533, 534, 535, 536, 537, 538, - 0, 0, 360, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 373, 2, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 0, 0, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 0, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 0, - 0, 0, 0, 0, 0, 331, 0, 0, 0, 335, - 336, 337, 0, 0, 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 520, 521, 0, 0, 594, 0, 0, - 0, 0, 0, 0, 0, 522, 523, 524, 525, 0, + 0, 0, 0, 0, 0, 856, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 355, 356, + 357, 358, 359, 360, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 361, + 362, 363, 364, 365, 366, 367, 0, 0, 0, 0, + 0, 0, 0, 0, 368, 0, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 0, 0, 0, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 526, 527, 528, 529, - 530, 345, 0, 0, 0, 0, 350, 351, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 891, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 531, 532, 533, 534, 535, 536, 537, 538, 0, 0, - 360, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 373, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 0, 0, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 0, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 0, 0, 0, - 0, 0, 0, 331, 0, 0, 0, 335, 336, 337, - 0, 0, 518, 519, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 349, 350, 351, 352, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 355, 356, + 357, 358, 359, 360, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 361, + 362, 363, 364, 365, 366, 367, 0, 0, 0, 0, + 0, 0, 0, 0, 368, 0, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 0, 0, 0, 337, 338, + 339, 340, 341, 342, 343, 344, 345, 346, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 520, 521, 0, 0, 0, 656, 0, 0, 0, - 0, 0, 0, 522, 523, 524, 525, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 526, 527, 528, 529, 530, 345, - 0, 0, 0, 0, 350, 351, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 531, 532, - 533, 534, 535, 536, 537, 538, 0, 0, 360, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 373, 2, 3, 4, 5, 6, 7, 8, 9, + 0, 0, 0, 0, 349, 350, 351, 352, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 354, 355, 356, + 357, 358, 359, 360, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 361, + 362, 363, 364, 365, 366, 367, 0, 0, 0, 0, + 0, 0, 0, 0, 368, 0, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, @@ -2723,7 +2622,7 @@ static const yytype_int16 yytable[] = 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 0, 172, 173, 174, 175, 176, 177, 178, 179, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, @@ -2738,109 +2637,66 @@ static const yytype_int16 yytable[] = 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 0, 0, 0, 0, 0, - 0, 331, 0, 0, 0, 335, 336, 337, 0, 0, - 518, 519, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 520, - 521, 0, 0, 759, 0, 0, 0, 0, 0, 0, - 0, 522, 523, 524, 525, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 526, 527, 528, 529, 530, 345, 0, 0, - 0, 0, 350, 351, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 531, 532, 533, 534, - 535, 536, 537, 538, 0, 0, 360, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 373, - 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 0, 0, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 0, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 323, 324, 0, 0, 0, 0, 0, 0, 331, - 0, 0, 0, 335, 336, 337, 0, 0, 518, 519, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 0, 0, 0, 0, 0, 0, + 340, 0, 0, 0, 344, 345, 346, 0, 0, 528, + 529, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 530, 531, + 0, 0, 0, 668, 812, 0, 0, 0, 0, 0, + 532, 533, 534, 535, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 520, 521, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 770, 522, - 523, 524, 525, 0, 0, 0, 0, 0, 0, 0, + 0, 536, 537, 538, 539, 540, 354, 0, 0, 0, + 0, 359, 360, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 526, 527, 528, 529, 530, 345, 0, 0, 0, 0, - 350, 351, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 531, 532, 533, 534, 535, 536, - 537, 538, 0, 0, 360, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 373, 2, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 0, 0, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 0, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 0, 0, 0, 0, 0, 0, 331, 0, 0, - 0, 335, 336, 337, 0, 0, 518, 519, 0, 0, + 0, 0, 0, 0, 0, 541, 542, 543, 544, 545, + 546, 547, 548, 0, 0, 369, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 382, 2, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 0, 0, 61, 62, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 0, 180, 181, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, + 333, 0, 0, 0, 0, 0, 0, 340, 0, 0, + 0, 344, 345, 346, 0, 0, 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 520, 521, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 522, 523, 524, - 525, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 526, 527, - 528, 529, 530, 345, 0, 0, 0, 0, 350, 351, + 0, 0, 0, 0, 0, 530, 531, 0, 0, 0, + 668, 922, 0, 0, 0, 0, 0, 532, 533, 534, + 535, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 536, 537, + 538, 539, 540, 354, 0, 0, 0, 0, 359, 360, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 531, 532, 533, 534, 535, 536, 537, 538, - 0, 0, 360, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 373, 2, 3, 4, 5, + 0, 0, 541, 542, 543, 544, 545, 546, 547, 548, + 0, 0, 369, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 382, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, @@ -2857,230 +2713,42 @@ static const yytype_int16 yytable[] = 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 0, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 0, - 0, 0, 0, 0, 0, 331, 0, 0, 0, 335, - 336, 337, 0, 0, 518, 519, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 520, 521, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 522, 523, 524, 525, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 526, 527, 528, 529, - 530, 345, 0, 0, 0, 0, 350, 674, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 531, 532, 533, 534, 535, 536, 537, 538, 0, 0, - 360, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 373, 2, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 0, 0, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 0, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 0, 0, 0, - 0, 0, 0, 331, 0, 0, 0, 335, 336, 337, - 0, 0, 518, 519, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 520, 521, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 522, 523, 524, 525, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 526, 527, 528, 529, 719, 345, - 0, 0, 0, 0, 350, 351, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 531, 532, - 533, 534, 535, 536, 537, 538, 0, 0, 360, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 373, 2, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 0, - 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 0, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 0, 0, 0, 0, 0, - 0, 331, 0, 0, 0, 335, 336, 337, 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, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 0, 180, 181, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 0, 0, + 0, 0, 0, 0, 340, 0, 0, 0, 344, 345, + 346, 0, 0, 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 530, 531, 0, 0, 604, 0, 0, 0, + 0, 0, 0, 0, 532, 533, 534, 535, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 345, 0, 0, - 0, 0, 350, 351, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 536, 537, 538, 539, 540, + 354, 0, 0, 0, 0, 359, 360, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 541, + 542, 543, 544, 545, 546, 547, 548, 0, 0, 369, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 360 -}; - -static const yytype_int16 yycheck[] = -{ - 0, 401, 0, 420, 521, 0, 500, 577, 425, 0, - 561, 654, 0, 656, 571, 512, 659, 642, 566, 586, - 420, 420, 762, 453, 588, 425, 577, 458, 409, 459, - 344, 345, 580, 366, 432, 372, 361, 361, 398, 364, - 361, 589, 349, 361, 364, 445, 363, 924, 364, 362, - 547, 364, 369, 364, 931, 365, 372, 362, 371, 369, - 371, 398, 422, 380, 941, 398, 380, 381, 449, 500, - 395, 395, 566, 394, 395, 396, 397, 395, 385, 509, - 510, 342, 343, 577, 465, 369, 580, 518, 519, 362, - 364, 369, 492, 364, 372, 589, 660, 381, 372, 363, - 371, 362, 364, 364, 621, 369, 623, 368, 366, 371, - 363, 369, 363, 365, 372, 609, 369, 369, 369, 550, - 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, - 363, 369, 372, 363, 372, 566, 369, 363, 363, 369, - 371, 766, 363, 369, 369, 363, 577, 363, 369, 580, - 362, 369, 669, 369, 363, 362, 799, 654, 589, 656, - 369, 559, 659, 363, 363, 363, 363, 734, 362, 369, - 369, 369, 369, 363, 559, 363, 673, 575, 609, 369, - 565, 369, 567, 346, 347, 570, 586, 572, 588, 574, - 575, 387, 388, 389, 579, 427, 428, 429, 430, 431, - 432, 433, 363, 584, 363, 945, 363, 363, 369, 363, - 369, 363, 369, 369, 363, 369, 363, 369, 363, 363, - 369, 374, 369, 376, 369, 369, 394, 395, 396, 397, - 398, 377, 378, 379, 365, 652, 879, 804, 369, 340, - 341, 362, 867, 394, 395, 396, 397, 678, 367, 362, - 369, 768, 652, 652, 362, 772, 745, 746, 747, 748, - 660, 395, 395, 362, 398, 398, 836, 395, 838, 395, - 398, 362, 398, 830, 831, 823, 824, 395, 395, 395, - 398, 398, 398, 395, 395, 836, 398, 398, 395, 369, - 370, 398, 935, 790, 791, 395, 363, 395, 398, 729, - 398, 369, 799, 369, 372, 369, 372, 738, 739, 740, - 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, - 751, 752, 753, 754, 755, 756, 951, 398, 369, 823, - 824, 372, 369, 380, 734, 372, 369, 370, 741, 742, - 749, 750, 836, 372, 838, 398, 743, 744, 865, 398, - 366, 868, 398, 366, 364, 398, 398, 364, 363, 398, - 372, 369, 371, 398, 398, 371, 369, 369, 369, 384, - 369, 398, 369, 369, 363, 369, 369, 369, 362, 369, - 363, 362, 879, 362, 364, 372, 371, 362, 364, 361, - 348, 908, 823, 824, 365, 350, 365, 367, 362, 372, - 382, 401, 362, 362, 804, 836, 383, 838, 925, 409, - 372, 372, 398, 401, 362, 372, 370, 417, 363, 417, - 420, 409, 417, 940, 921, 425, 417, 425, 372, 417, - 425, 372, 420, 372, 362, 435, 371, 425, 935, 369, - 369, 363, 398, 369, 363, 445, 444, 398, 365, 449, - 365, 868, 361, 369, 406, 361, 367, 445, 458, 395, - 398, 449, 363, 362, 366, 465, 371, 363, 868, 372, - 410, 366, 366, 752, 372, 367, 751, 465, 754, 756, - 445, 753, 449, 449, 344, 755, 591, 728, 843, 930, - 870, 908, 492, 941, 443, 942, 870, 652, 908, 417, - 582, 824, 652, 503, 492, 831, 821, 819, 908, 652, - 838, 830, 834, -1, -1, 503, -1, -1, 826, 828, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 836, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 555, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 584, -1, 586, -1, 588, -1, - -1, -1, -1, -1, -1, -1, 584, -1, 586, -1, - 588, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 642, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 652, -1, 642, -1, -1, -1, -1, -1, - 660, -1, -1, -1, 652, -1, -1, -1, -1, -1, - -1, -1, 660, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 734, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 734, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 762, -1, -1, -1, 766, -1, -1, -1, - -1, -1, -1, -1, 762, -1, -1, -1, 766, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 804, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 804, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 867, 868, -1, - 870, -1, 870, -1, -1, -1, -1, -1, -1, 867, - 868, -1, 870, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 908, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 908, -1, -1, -1, 924, -1, -1, -1, -1, -1, - -1, 931, -1, -1, -1, -1, 924, -1, -1, -1, - -1, 941, -1, 931, -1, 945, -1, -1, -1, -1, - -1, 951, -1, 941, -1, -1, -1, 945, -1, -1, - -1, 0, -1, 951, 3, 4, 5, 6, 7, 8, + 0, 0, 382, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, + 0, 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, @@ -3092,7 +2760,7 @@ static const yytype_int16 yycheck[] = 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, + 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, @@ -3107,27 +2775,117 @@ static const yytype_int16 yycheck[] = 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, - 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 364, -1, -1, -1, -1, - -1, -1, -1, 372, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 386, 387, 388, - 389, 390, -1, -1, -1, -1, -1, -1, -1, -1, - 399, 400, 401, 402, 403, 404, 405, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 421, 422, 423, 424, 425, 426, 427, -1, - -1, -1, -1, -1, -1, -1, -1, 436, -1, 438, - 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, - 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, - 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, - 469, 470, 471, 472, 473, 3, 4, 5, 6, 7, + 329, 330, 331, 332, 333, 0, 0, 0, 0, 0, + 0, 340, 0, 0, 0, 344, 345, 346, 0, 0, + 528, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 530, + 531, 0, 0, 0, 668, 0, 0, 0, 0, 0, + 0, 532, 533, 534, 535, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 536, 537, 538, 539, 540, 354, 0, 0, + 0, 0, 359, 360, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 541, 542, 543, 544, + 545, 546, 547, 548, 0, 0, 369, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 382, + 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 0, 0, 61, + 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 0, 180, 181, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 0, 0, 0, 0, 0, 0, 340, 0, + 0, 0, 344, 345, 346, 0, 0, 528, 529, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 530, 531, 0, 0, + 769, 0, 0, 0, 0, 0, 0, 0, 532, 533, + 534, 535, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 536, + 537, 538, 539, 540, 354, 0, 0, 0, 0, 359, + 360, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 541, 542, 543, 544, 545, 546, 547, + 548, 0, 0, 369, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 382, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 0, 0, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 0, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 0, + 0, 0, 0, 0, 0, 340, 0, 0, 0, 344, + 345, 346, 0, 0, 528, 529, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 530, 531, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 780, 532, 533, 534, 535, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 536, 537, 538, 539, + 540, 354, 0, 0, 0, 0, 359, 360, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 541, 542, 543, 544, 545, 546, 547, 548, 0, 0, + 369, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 382, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 58, 0, 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, @@ -3139,7 +2897,7 @@ static const yytype_int16 yycheck[] = 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 178, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, @@ -3154,27 +2912,117 @@ static const yytype_int16 yycheck[] = 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, - 338, 339, -1, -1, 342, 343, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 361, 362, -1, 364, -1, 366, 367, - -1, -1, -1, -1, 372, 373, 374, 375, 376, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 386, 387, - 388, 389, 390, -1, -1, -1, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, -1, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, - 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, - 468, 469, 470, 471, 472, 473, 3, 4, 5, 6, + 328, 329, 330, 331, 332, 333, 0, 0, 0, 0, + 0, 0, 340, 0, 0, 0, 344, 345, 346, 0, + 0, 528, 529, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 530, 531, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 532, 533, 534, 535, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 536, 537, 538, 539, 540, 354, 0, + 0, 0, 0, 359, 360, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 541, 542, 543, + 544, 545, 546, 547, 548, 0, 0, 369, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 382, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 0, 0, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 0, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 0, 0, 0, 0, 0, 0, 340, + 0, 0, 0, 344, 345, 346, 0, 0, 528, 529, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 530, 531, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 532, + 533, 534, 535, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 536, 537, 538, 539, 540, 354, 0, 0, 0, 0, + 359, 684, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 541, 542, 543, 544, 545, 546, + 547, 548, 0, 0, 369, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 382, 2, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 0, 0, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, + 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, + 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, + 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 0, 180, 181, 182, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, + 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, + 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, + 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, + 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, + 0, 0, 0, 0, 0, 0, 340, 0, 0, 0, + 344, 345, 346, 0, 0, 528, 529, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 530, 531, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 532, 533, 534, 535, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 536, 537, 538, + 539, 729, 354, 0, 0, 0, 0, 359, 360, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 541, 542, 543, 544, 545, 546, 547, 548, 0, + 0, 369, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 382, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, + 57, 58, 0, 0, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, @@ -3186,7 +3034,7 @@ static const yytype_int16 yycheck[] = 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 177, 178, 0, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, @@ -3201,257 +3049,648 @@ static const yytype_int16 yycheck[] = 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, 339, -1, -1, 342, 343, -1, -1, -1, + 327, 328, 329, 330, 331, 332, 333, 0, 0, 0, + 0, 0, 0, 340, 0, 0, 0, 344, 345, 346, + 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, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 354, + 0, 0, 0, 0, 359, 360, 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, 369 +}; + +static const yytype_int16 yycheck[] = +{ + 0, 410, 0, 429, 0, 0, 571, 510, 434, 0, + 462, 664, 581, 666, 523, 668, 429, 469, 671, 652, + 429, 587, 587, 596, 772, 434, 576, 531, 598, 370, + 468, 418, 370, 370, 358, 441, 373, 407, 353, 354, + 590, 371, 370, 935, 378, 454, 375, 373, 557, 599, + 942, 373, 349, 350, 381, 381, 390, 351, 352, 381, + 952, 431, 403, 404, 405, 406, 404, 404, 520, 521, + 394, 458, 510, 576, 389, 390, 404, 371, 407, 373, + 407, 374, 373, 377, 587, 378, 371, 590, 475, 380, + 528, 529, 371, 502, 373, 371, 599, 403, 404, 405, + 406, 380, 672, 360, 361, 362, 363, 364, 365, 366, + 367, 368, 369, 372, 378, 379, 619, 373, 373, 378, + 569, 371, 560, 380, 380, 380, 575, 631, 577, 633, + 389, 580, 373, 582, 378, 584, 585, 381, 576, 380, + 589, 372, 372, 776, 372, 372, 371, 378, 378, 587, + 378, 378, 590, 404, 372, 664, 407, 666, 811, 668, + 378, 599, 671, 569, 436, 437, 438, 439, 440, 441, + 442, 744, 372, 371, 683, 679, 372, 372, 378, 585, + 372, 619, 378, 378, 372, 372, 378, 596, 372, 598, + 378, 378, 372, 372, 378, 372, 372, 372, 378, 378, + 372, 378, 378, 378, 372, 372, 378, 594, 956, 372, + 378, 378, 372, 372, 372, 378, 372, 372, 378, 378, + 378, 372, 378, 378, 374, 751, 752, 378, 378, 403, + 404, 405, 406, 407, 374, 378, 662, 890, 378, 755, + 756, 757, 758, 816, 378, 878, 376, 381, 378, 662, + 688, 404, 404, 662, 407, 407, 404, 404, 404, 407, + 407, 407, 404, 672, 371, 407, 404, 404, 404, 407, + 407, 407, 841, 842, 778, 371, 404, 404, 782, 407, + 407, 847, 847, 849, 834, 835, 378, 739, 383, 381, + 385, 800, 801, 946, 378, 378, 378, 381, 381, 381, + 355, 356, 811, 396, 397, 398, 386, 387, 388, 373, + 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, + 758, 759, 760, 761, 762, 763, 764, 765, 766, 962, + 371, 834, 835, 378, 379, 744, 753, 754, 759, 760, + 371, 381, 372, 389, 847, 407, 849, 381, 407, 407, + 375, 407, 375, 373, 407, 407, 375, 373, 372, 407, + 381, 378, 380, 407, 377, 380, 378, 378, 378, 378, + 378, 378, 876, 378, 378, 879, 378, 378, 372, 371, + 373, 890, 381, 380, 372, 371, 371, 371, 370, 357, + 373, 415, 359, 374, 374, 371, 834, 835, 376, 371, + 371, 407, 371, 392, 407, 379, 393, 816, 381, 847, + 410, 849, 391, 371, 377, 919, 381, 407, 418, 410, + 381, 381, 381, 932, 381, 381, 426, 418, 426, 429, + 426, 426, 936, 372, 434, 426, 434, 946, 429, 434, + 380, 407, 378, 434, 444, 378, 378, 951, 372, 372, + 378, 370, 374, 879, 454, 453, 374, 370, 458, 404, + 376, 407, 372, 454, 371, 380, 375, 458, 468, 381, + 879, 372, 419, 375, 761, 475, 375, 381, 376, 762, + 764, 763, 601, 458, 475, 765, 353, 854, 766, 738, + 454, 881, 952, 919, 941, 953, 458, 452, 881, 919, + 662, 662, 502, 592, 835, 662, 426, 832, 841, 830, + 919, 502, 847, 513, -1, -1, 839, 837, -1, -1, + -1, -1, 513, 842, -1, -1, -1, 845, -1, -1, + -1, -1, 849, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 565, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 594, -1, 596, -1, 598, -1, + -1, -1, -1, 594, -1, 596, -1, 598, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 652, -1, -1, -1, -1, -1, -1, -1, + -1, 652, 662, -1, -1, -1, -1, -1, -1, -1, + -1, 662, 672, -1, -1, -1, -1, -1, -1, -1, + -1, 672, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 744, -1, -1, -1, -1, -1, + -1, -1, -1, 744, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 772, -1, -1, -1, 776, -1, -1, -1, + -1, 772, -1, -1, -1, 776, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 816, -1, -1, -1, + -1, -1, -1, -1, -1, 816, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 878, 879, + -1, 881, -1, 881, -1, -1, -1, 878, 879, -1, + 881, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 919, + -1, -1, -1, -1, -1, -1, -1, -1, 919, -1, + -1, -1, -1, -1, -1, 935, -1, -1, -1, -1, + -1, -1, 942, -1, 935, -1, -1, -1, -1, -1, + -1, 942, 952, -1, -1, -1, 956, -1, -1, -1, + -1, 952, 962, -1, -1, 956, -1, -1, -1, 0, + -1, 962, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 373, -1, -1, -1, -1, -1, -1, -1, + 381, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, 399, -1, + -1, -1, -1, -1, -1, -1, -1, 408, 409, 410, + 411, 412, 413, 414, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 430, + 431, 432, 433, 434, 435, 436, -1, -1, -1, -1, + -1, -1, -1, -1, 445, -1, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, + 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 370, + 371, -1, 373, -1, 375, 376, -1, -1, -1, -1, + 381, 382, 383, 384, 385, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, 399, -1, + -1, -1, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, + 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 370, + 371, -1, 373, -1, 375, 376, -1, -1, -1, -1, + 381, 382, 383, 384, 385, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, 399, -1, + -1, -1, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, + 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 370, + 371, -1, 373, -1, 375, -1, -1, -1, -1, -1, + 381, 382, 383, 384, 385, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, 399, -1, + -1, -1, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, + 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 370, + 371, -1, 373, -1, 375, -1, -1, -1, -1, -1, + 381, 382, 383, 384, 385, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, 399, -1, + -1, -1, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, + 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 370, + 371, -1, 373, -1, -1, -1, -1, -1, -1, -1, + 381, 382, 383, 384, 385, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, 399, -1, + -1, -1, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, -1, 420, + 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, + 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 370, + 371, -1, 373, -1, -1, -1, -1, -1, -1, -1, + 381, 382, 383, 384, 385, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, 399, -1, + -1, -1, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 430, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, -1, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, -1, -1, -1, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, + 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 370, + 371, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 382, 383, 384, 385, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, -1, -1, + -1, -1, 403, 404, 405, 406, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 430, + 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, + 441, 442, 443, 444, 445, -1, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 361, 362, -1, 364, -1, 366, - 367, -1, -1, -1, -1, 372, 373, 374, 375, 376, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 386, - 387, 388, 389, 390, -1, -1, -1, 394, 395, 396, - 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, -1, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, - 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, - 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, - 467, 468, 469, 470, 471, 472, 473, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, - 336, 337, 338, 339, -1, -1, 342, 343, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 361, 362, -1, 364, -1, - 366, -1, -1, -1, -1, -1, 372, 373, 374, 375, - 376, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 386, 387, 388, 389, 390, -1, -1, -1, 394, 395, - 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 409, -1, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, - 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, - 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, - 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, - 466, 467, 468, 469, 470, 471, 472, 473, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, - 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, - 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, - 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, - 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, - 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 337, 338, 339, -1, -1, 342, 343, -1, + -1, -1, 373, -1, -1, -1, -1, -1, -1, -1, + 381, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, 399, -1, + -1, -1, -1, -1, -1, -1, -1, 408, 409, 410, + 411, 412, 413, 414, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 430, + 431, 432, 433, 434, 435, 436, -1, -1, -1, -1, + -1, -1, -1, -1, 445, -1, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, -1, -1, -1, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 361, 362, -1, 364, - -1, 366, -1, -1, -1, -1, -1, 372, 373, 374, - 375, 376, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 386, 387, 388, 389, 390, -1, -1, -1, 394, - 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 409, -1, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, - 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467, 468, 469, 470, 471, 472, 473, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, 335, 336, 337, 338, 339, -1, -1, 342, 343, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 361, 362, -1, - 364, -1, -1, -1, -1, -1, -1, -1, 372, 373, - 374, 375, 376, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 386, 387, 388, 389, 390, -1, -1, -1, - 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 409, -1, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, - 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, - 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, - 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, - 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, - 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, - 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, - 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, 335, 336, 337, 338, 339, -1, -1, 342, - 343, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 361, 362, - -1, 364, -1, -1, -1, -1, -1, -1, -1, 372, - 373, 374, 375, 376, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 386, 387, 388, 389, 390, -1, -1, - -1, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 421, 422, - 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, - 433, 434, 435, 436, -1, 438, 439, 440, 441, 442, - 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, - 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, - 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, - 473, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 323, 324, 325, 326, -1, -1, -1, 330, 331, - 332, 333, 334, 335, 336, 337, 338, 339, -1, -1, - 342, 343, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 361, - 362, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 373, 374, 375, 376, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 386, 387, 388, 389, -1, -1, - -1, -1, 394, 395, 396, 397, 398, 399, 400, 401, - 402, 403, 404, 405, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 421, - 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, - 432, 433, 434, 435, 436, -1, 438, 439, 440, 441, - 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, - 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, - 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, - 472, 473, 3, 4, 5, 6, 7, 8, 9, 10, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 408, 409, 410, + 411, 412, 413, 414, 415, -1, -1, 418, -1, 420, + 421, -1, -1, 424, -1, -1, -1, -1, -1, 430, + 431, 432, 433, 434, 435, 436, -1, -1, -1, -1, + -1, -1, -1, -1, 445, -1, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, -1, -1, -1, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 381, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, -1, -1, + -1, -1, -1, -1, -1, -1, 407, 408, 409, 410, + 411, 412, 413, 414, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 430, + 431, 432, 433, 434, 435, 436, -1, -1, -1, -1, + -1, -1, -1, -1, 445, -1, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, @@ -3484,262 +3723,313 @@ static const yytype_int16 yycheck[] = 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 338, 339, -1, + 331, 332, 333, 334, 335, -1, -1, -1, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 364, -1, -1, -1, -1, -1, -1, - -1, 372, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 386, 387, 388, 389, 390, - -1, -1, -1, -1, -1, -1, -1, -1, 399, 400, - 401, 402, 403, 404, 405, -1, -1, -1, -1, -1, + -1, -1, 373, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 421, 422, 423, 424, 425, 426, 427, -1, -1, -1, - -1, -1, -1, -1, -1, 436, -1, 438, 439, 440, - 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, + -1, -1, -1, -1, 395, 396, 397, 398, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 408, 409, 410, + 411, 412, 413, 414, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 430, + 431, 432, 433, 434, 435, 436, -1, -1, -1, -1, + -1, -1, -1, -1, 445, -1, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, - 471, 472, 473, 3, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, -1, -1, -1, - 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, -1, -1, -1, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 377, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 386, 387, 388, 389, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 399, - 400, 401, 402, 403, 404, 405, 406, -1, -1, 409, - -1, 411, 412, -1, -1, 415, -1, -1, -1, -1, - -1, 421, 422, 423, 424, 425, 426, 427, -1, -1, - -1, -1, -1, -1, -1, -1, 436, -1, 438, 439, - 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, - 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, - 470, 471, 472, 473, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, - 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, - 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, - 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, - 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, - 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, - 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, - 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, - 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, - 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, -1, -1, - -1, 330, 331, 332, 333, 334, 335, 336, 337, 338, - 339, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 408, 409, 410, + 411, 412, 413, 414, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 430, + 431, 432, 433, 434, 435, 436, -1, -1, -1, -1, + -1, -1, -1, -1, 445, -1, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, -1, -1, -1, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 372, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 386, 387, 388, - 389, -1, -1, -1, -1, -1, -1, -1, -1, 398, - 399, 400, 401, 402, 403, 404, 405, -1, -1, -1, + -1, -1, -1, -1, -1, 376, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 421, 422, 423, 424, 425, 426, 427, -1, - -1, -1, -1, -1, -1, -1, -1, 436, -1, 438, - 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, - 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, - 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, - 469, 470, 471, 472, 473, 3, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, -1, - -1, -1, 330, 331, 332, 333, 334, 335, 336, 337, - 338, 339, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 408, 409, 410, + 411, 412, 413, 414, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 430, + 431, 432, 433, 434, 435, 436, -1, -1, -1, -1, + -1, -1, -1, -1, 445, -1, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, -1, -1, -1, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 364, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 386, 387, - 388, 389, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 399, 400, 401, 402, 403, 404, 405, -1, -1, + -1, -1, -1, -1, -1, 376, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 421, 422, 423, 424, 425, 426, 427, - -1, -1, -1, -1, -1, -1, -1, -1, 436, -1, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, - 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, - 468, 469, 470, 471, 472, 473, 3, 4, 5, 6, - 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - -1, -1, -1, 330, 331, 332, 333, 334, 335, 336, - 337, 338, 339, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 408, 409, 410, + 411, 412, 413, 414, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 430, + 431, 432, 433, 434, 435, 436, -1, -1, -1, -1, + -1, -1, -1, -1, 445, -1, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, -1, -1, -1, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 367, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 386, - 387, 388, 389, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 399, 400, 401, 402, 403, 404, 405, -1, + -1, -1, -1, -1, -1, 376, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 421, 422, 423, 424, 425, 426, - 427, -1, -1, -1, -1, -1, -1, -1, -1, 436, - -1, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, - 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, - 467, 468, 469, 470, 471, 472, 473, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, -1, -1, -1, 330, 331, 332, 333, 334, 335, - 336, 337, 338, 339, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 395, 396, 397, 398, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 408, 409, 410, + 411, 412, 413, 414, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 430, + 431, 432, 433, 434, 435, 436, -1, -1, -1, -1, + -1, -1, -1, -1, 445, -1, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, -1, -1, -1, 339, 340, + 341, 342, 343, 344, 345, 346, 347, 348, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 367, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 386, 387, 388, 389, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 399, 400, 401, 402, 403, 404, 405, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 421, 422, 423, 424, 425, - 426, 427, -1, -1, -1, -1, -1, -1, -1, -1, - 436, -1, 438, 439, 440, 441, 442, 443, 444, 445, - 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, - 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, - 466, 467, 468, 469, 470, 471, 472, 473, 3, 4, + -1, -1, -1, -1, 395, 396, 397, 398, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 408, 409, 410, + 411, 412, 413, 414, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 430, + 431, 432, 433, 434, 435, 436, -1, -1, -1, -1, + -1, -1, -1, -1, 445, -1, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, + 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, + 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, + 481, 482, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, + 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 60, -1, + -1, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, + 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, + 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 176, 177, 178, 179, 180, -1, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, + 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, + 332, 333, 334, 335, -1, -1, -1, -1, -1, -1, + 342, -1, -1, -1, 346, 347, 348, -1, -1, 351, + 352, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 370, 371, + -1, -1, -1, 375, 376, -1, -1, -1, -1, -1, + 382, 383, 384, 385, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 403, 404, 405, 406, 407, 408, -1, -1, -1, + -1, 413, 414, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 437, 438, 439, 440, 441, + 442, 443, 444, -1, -1, 447, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 460, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 55, 56, 57, 58, 59, 60, -1, -1, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, @@ -3751,7 +4041,7 @@ static const yytype_int16 yycheck[] = 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 175, 176, 177, 178, 179, 180, -1, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, @@ -3766,158 +4056,20 @@ static const yytype_int16 yycheck[] = 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, -1, -1, -1, 330, 331, 332, 333, 334, - 335, 336, 337, 338, 339, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 367, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 386, 387, 388, 389, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 399, 400, 401, 402, 403, 404, - 405, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 421, 422, 423, 424, - 425, 426, 427, -1, -1, -1, -1, -1, -1, -1, - -1, 436, -1, 438, 439, 440, 441, 442, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, - 465, 466, 467, 468, 469, 470, 471, 472, 473, 3, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, -1, -1, -1, 330, 331, 332, 333, - 334, 335, 336, 337, 338, 339, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 386, 387, 388, 389, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 399, 400, 401, 402, 403, - 404, 405, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 421, 422, 423, - 424, 425, 426, 427, -1, -1, -1, -1, -1, -1, - -1, -1, 436, -1, 438, 439, 440, 441, 442, 443, - 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, - 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, - 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, - 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 60, -1, -1, 63, - 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, - 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, - 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, -1, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, - 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, - 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, - 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, -1, -1, -1, -1, -1, -1, 333, - -1, -1, -1, 337, 338, 339, -1, -1, 342, 343, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 361, 362, -1, - -1, -1, 366, 367, -1, -1, -1, -1, -1, 373, - 374, 375, 376, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 394, 395, 396, 397, 398, 399, -1, -1, -1, -1, - 404, 405, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 428, 429, 430, 431, 432, 433, - 434, 435, -1, -1, 438, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 451, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, -1, -1, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, -1, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, -1, -1, -1, -1, -1, -1, 333, -1, -1, - -1, 337, 338, 339, -1, -1, 342, 343, -1, -1, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, -1, -1, -1, -1, -1, -1, 342, -1, -1, + -1, 346, 347, 348, -1, -1, 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 361, 362, -1, -1, -1, - 366, 367, -1, -1, -1, -1, -1, 373, 374, 375, - 376, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 394, 395, - 396, 397, 398, 399, -1, -1, -1, -1, 404, 405, + -1, -1, -1, -1, -1, 370, 371, -1, -1, -1, + 375, 376, -1, -1, -1, -1, -1, 382, 383, 384, + 385, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 403, 404, + 405, 406, 407, 408, -1, -1, -1, -1, 413, 414, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 428, 429, 430, 431, 432, 433, 434, 435, - -1, -1, 438, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 451, 4, 5, 6, 7, + -1, -1, 437, 438, 439, 440, 441, 442, 443, 444, + -1, -1, 447, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 460, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, @@ -3934,124 +4086,81 @@ static const yytype_int16 yycheck[] = 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, -1, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, -1, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, -1, - -1, -1, -1, -1, -1, 333, -1, -1, -1, 337, - 338, 339, -1, -1, 342, 343, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 361, 362, -1, -1, 365, -1, -1, - -1, -1, -1, -1, -1, 373, 374, 375, 376, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 394, 395, 396, 397, - 398, 399, -1, -1, -1, -1, 404, 405, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 428, 429, 430, 431, 432, 433, 434, 435, -1, -1, - 438, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 451, 4, 5, 6, 7, 8, 9, - 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, - 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 60, -1, -1, 63, 64, 65, 66, 67, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, - 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, - 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, - 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, - 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, -1, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, - 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, - 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, -1, -1, -1, - -1, -1, -1, 333, -1, -1, -1, 337, 338, 339, - -1, -1, 342, 343, -1, -1, -1, -1, -1, -1, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, -1, -1, + -1, -1, -1, -1, 342, -1, -1, -1, 346, 347, + 348, -1, -1, 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 361, 362, -1, -1, -1, 366, -1, -1, -1, - -1, -1, -1, 373, 374, 375, 376, -1, -1, -1, + -1, -1, 370, 371, -1, -1, 374, -1, -1, -1, + -1, -1, -1, -1, 382, 383, 384, 385, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 394, 395, 396, 397, 398, 399, - -1, -1, -1, -1, 404, 405, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 403, 404, 405, 406, 407, + 408, -1, -1, -1, -1, 413, 414, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 428, 429, - 430, 431, 432, 433, 434, 435, -1, -1, 438, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 437, + 438, 439, 440, 441, 442, 443, 444, -1, -1, 447, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 451, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, -1, - -1, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, -1, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 323, 324, 325, 326, -1, -1, -1, -1, -1, - -1, 333, -1, -1, -1, 337, 338, 339, -1, -1, - 342, 343, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 361, - 362, -1, -1, 365, -1, -1, -1, -1, -1, -1, - -1, 373, 374, 375, 376, -1, -1, -1, -1, -1, + -1, -1, 460, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, + -1, -1, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, + 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, + 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, + 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, + -1, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, + 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, + 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, -1, -1, -1, -1, -1, + -1, 342, -1, -1, -1, 346, 347, 348, -1, -1, + 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 370, + 371, -1, -1, -1, 375, -1, -1, -1, -1, -1, + -1, 382, 383, 384, 385, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 394, 395, 396, 397, 398, 399, -1, -1, - -1, -1, 404, 405, -1, -1, -1, -1, -1, -1, + -1, -1, 403, 404, 405, 406, 407, 408, -1, -1, + -1, -1, 413, 414, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 428, 429, 430, 431, - 432, 433, 434, 435, -1, -1, 438, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 451, + -1, -1, -1, -1, -1, -1, 437, 438, 439, 440, + 441, 442, 443, 444, -1, -1, 447, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 460, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, @@ -4068,8 +4177,8 @@ static const yytype_int16 yycheck[] = 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, - 164, 165, 166, 167, 168, 169, 170, 171, 172, -1, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, + 174, 175, 176, 177, 178, 179, 180, -1, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, @@ -4084,109 +4193,66 @@ static const yytype_int16 yycheck[] = 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, -1, -1, -1, -1, -1, -1, 333, - -1, -1, -1, 337, 338, 339, -1, -1, 342, 343, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 361, 362, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 372, 373, - 374, 375, 376, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 394, 395, 396, 397, 398, 399, -1, -1, -1, -1, - 404, 405, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 428, 429, 430, 431, 432, 433, - 434, 435, -1, -1, 438, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 451, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, - 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, 59, 60, -1, -1, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, - 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, - 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, - 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, - 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, - 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, - 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, - 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, - 166, 167, 168, 169, 170, 171, 172, -1, 174, 175, - 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, - 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, - 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, - 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, - 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, - 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, - 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, -1, -1, -1, -1, -1, -1, 333, -1, -1, - -1, 337, 338, 339, -1, -1, 342, 343, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 361, 362, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 373, 374, 375, - 376, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 394, 395, - 396, 397, 398, 399, -1, -1, -1, -1, 404, 405, + 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, + 334, 335, -1, -1, -1, -1, -1, -1, 342, -1, + -1, -1, 346, 347, 348, -1, -1, 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 370, 371, -1, -1, + 374, -1, -1, -1, -1, -1, -1, -1, 382, 383, + 384, 385, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 403, + 404, 405, 406, 407, 408, -1, -1, -1, -1, 413, + 414, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 428, 429, 430, 431, 432, 433, 434, 435, - -1, -1, 438, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 451, 4, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, - 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 60, -1, -1, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, -1, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, -1, - -1, -1, -1, -1, -1, 333, -1, -1, -1, 337, - 338, 339, -1, -1, 342, 343, -1, -1, -1, -1, + -1, -1, -1, 437, 438, 439, 440, 441, 442, 443, + 444, -1, -1, 447, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 460, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, 60, -1, -1, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, + 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, + 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, + 177, 178, 179, 180, -1, 182, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, + 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, + 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, 329, 330, 331, 332, 333, 334, 335, -1, + -1, -1, -1, -1, -1, 342, -1, -1, -1, 346, + 347, 348, -1, -1, 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 361, 362, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 373, 374, 375, 376, -1, + -1, -1, -1, 370, 371, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 381, 382, 383, 384, 385, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 394, 395, 396, 397, - 398, 399, -1, -1, -1, -1, 404, 405, -1, -1, + -1, -1, -1, -1, -1, -1, 403, 404, 405, 406, + 407, 408, -1, -1, -1, -1, 413, 414, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 428, 429, 430, 431, 432, 433, 434, 435, -1, -1, - 438, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 451, 4, 5, 6, 7, 8, 9, + 437, 438, 439, 440, 441, 442, 443, 444, -1, -1, + 447, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 460, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, @@ -4203,8 +4269,8 @@ static const yytype_int16 yycheck[] = 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, - 170, 171, 172, -1, 174, 175, 176, 177, 178, 179, - 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, -1, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, @@ -4218,63 +4284,156 @@ static const yytype_int16 yycheck[] = 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, -1, -1, -1, - -1, -1, -1, 333, -1, -1, -1, 337, 338, 339, - -1, -1, 342, 343, -1, -1, -1, -1, -1, -1, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 335, -1, -1, -1, -1, + -1, -1, 342, -1, -1, -1, 346, 347, 348, -1, + -1, 351, 352, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 361, 362, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 373, 374, 375, 376, -1, -1, -1, + 370, 371, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 382, 383, 384, 385, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 394, 395, 396, 397, 398, 399, - -1, -1, -1, -1, 404, 405, -1, -1, -1, -1, + -1, -1, -1, 403, 404, 405, 406, 407, 408, -1, + -1, -1, -1, 413, 414, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 428, 429, - 430, 431, 432, 433, 434, 435, -1, -1, 438, -1, + -1, -1, -1, -1, -1, -1, -1, 437, 438, 439, + 440, 441, 442, 443, 444, -1, -1, 447, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 451, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, - 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, - 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, 60, -1, - -1, 63, 64, 65, 66, 67, 68, 69, 70, 71, - 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, - 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, - 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, - 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, - 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, - 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, - 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, - 172, -1, 174, 175, 176, 177, 178, 179, 180, 181, - 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, - 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, - 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, - 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, - 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, - 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 323, 324, 325, 326, -1, -1, -1, -1, -1, - -1, 333, -1, -1, -1, 337, 338, 339, -1, -1, + 460, 4, 5, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, 60, -1, -1, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, + 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, + 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, + 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, + 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, + 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 176, 177, 178, 179, 180, -1, 182, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, + 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, + 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, + 333, 334, 335, -1, -1, -1, -1, -1, -1, 342, + -1, -1, -1, 346, 347, 348, -1, -1, 351, 352, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 370, 371, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 382, + 383, 384, 385, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 403, 404, 405, 406, 407, 408, -1, -1, -1, -1, + 413, 414, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 437, 438, 439, 440, 441, 442, + 443, 444, -1, -1, 447, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 460, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, -1, -1, 63, 64, 65, + 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, + 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, + 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, + 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, -1, 182, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, + 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, + 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, + 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, + -1, -1, -1, -1, -1, -1, 342, -1, -1, -1, + 346, 347, 348, -1, -1, 351, 352, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 370, 371, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 382, 383, 384, 385, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 403, 404, 405, + 406, 407, 408, -1, -1, -1, -1, 413, 414, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 437, 438, 439, 440, 441, 442, 443, 444, -1, + -1, 447, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 460, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 60, -1, -1, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, + 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, + 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, + 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, + 179, 180, -1, 182, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, + 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, + 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, + 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 334, 335, -1, -1, -1, + -1, -1, -1, 342, -1, -1, -1, 346, 347, 348, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 399, -1, -1, - -1, -1, 404, 405, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 408, + -1, -1, -1, -1, 413, 414, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 438 + -1, -1, -1, -1, -1, -1, -1, -1, 447 }; /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of @@ -4314,145 +4473,147 @@ static const yytype_int16 yystos[] = 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, - 332, 333, 334, 335, 336, 337, 338, 339, 364, 372, - 386, 387, 388, 389, 390, 399, 400, 401, 402, 403, - 404, 405, 421, 422, 423, 424, 425, 426, 427, 436, - 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, + 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, + 342, 343, 344, 345, 346, 347, 348, 373, 381, 395, + 396, 397, 398, 399, 408, 409, 410, 411, 412, 413, + 414, 430, 431, 432, 433, 434, 435, 436, 445, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, - 468, 469, 470, 471, 472, 473, 505, 506, 509, 510, - 511, 512, 516, 517, 518, 519, 520, 521, 524, 525, - 526, 527, 528, 530, 535, 536, 537, 578, 579, 580, - 582, 589, 593, 594, 600, 603, 362, 362, 362, 362, - 362, 362, 362, 362, 364, 536, 366, 398, 362, 362, - 372, 398, 372, 581, 363, 369, 513, 514, 515, 525, - 530, 369, 372, 398, 372, 398, 526, 530, 380, 532, - 533, 0, 579, 510, 518, 525, 372, 509, 398, 585, - 586, 604, 605, 395, 398, 585, 395, 585, 395, 585, - 395, 585, 395, 585, 585, 604, 395, 585, 398, 583, - 584, 530, 539, 366, 398, 422, 522, 523, 398, 529, - 364, 372, 531, 366, 557, 582, 514, 513, 515, 398, - 398, 362, 371, 531, 366, 369, 372, 508, 342, 343, - 361, 362, 373, 374, 375, 376, 394, 395, 396, 397, - 398, 428, 429, 430, 431, 432, 433, 434, 435, 475, - 476, 477, 479, 480, 481, 482, 483, 484, 485, 486, - 487, 528, 530, 534, 531, 363, 398, 372, 371, 369, - 363, 369, 363, 369, 371, 369, 369, 369, 363, 369, - 369, 369, 369, 369, 369, 369, 363, 369, 363, 369, - 362, 365, 369, 372, 525, 530, 540, 541, 538, 371, - 363, 369, 363, 369, 365, 486, 488, 489, 490, 491, - 492, 493, 494, 495, 496, 497, 498, 499, 530, 364, - 372, 366, 367, 372, 406, 407, 408, 409, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 437, 486, - 499, 501, 503, 505, 509, 528, 530, 546, 547, 548, - 549, 550, 558, 559, 560, 561, 564, 565, 568, 569, - 570, 577, 582, 531, 371, 531, 366, 501, 544, 371, - 507, 398, 369, 372, 486, 486, 503, 342, 343, 364, - 368, 363, 363, 369, 405, 501, 362, 486, 369, 381, - 582, 361, 364, 395, 586, 604, 398, 605, 361, 394, - 395, 396, 397, 590, 591, 395, 499, 504, 592, 395, - 394, 395, 396, 397, 595, 596, 395, 394, 395, 396, - 397, 475, 597, 598, 395, 361, 599, 395, 604, 398, - 504, 535, 601, 602, 395, 504, 365, 584, 530, 398, - 542, 543, 367, 541, 540, 504, 523, 398, 377, 378, - 379, 374, 376, 340, 341, 344, 345, 380, 381, 346, - 347, 384, 383, 382, 348, 350, 349, 385, 365, 365, - 499, 367, 551, 362, 372, 372, 572, 362, 362, 372, - 372, 503, 362, 503, 370, 372, 372, 372, 372, 351, - 352, 353, 354, 355, 356, 357, 358, 359, 360, 371, - 502, 369, 372, 367, 547, 561, 565, 570, 544, 371, - 367, 544, 545, 544, 540, 398, 363, 478, 503, 398, - 501, 486, 361, 395, 587, 588, 363, 371, 363, 369, - 363, 369, 363, 369, 369, 363, 369, 363, 369, 363, - 369, 369, 363, 369, 369, 363, 369, 363, 369, 363, - 363, 542, 531, 369, 372, 367, 486, 486, 486, 488, - 488, 489, 489, 490, 490, 490, 490, 491, 491, 492, - 493, 494, 495, 496, 497, 500, 365, 558, 571, 547, - 573, 503, 372, 503, 370, 501, 501, 544, 367, 369, - 367, 365, 365, 369, 365, 369, 591, 590, 504, 592, - 596, 595, 598, 597, 361, 599, 601, 602, 372, 543, - 503, 552, 503, 518, 563, 406, 546, 559, 574, 363, - 363, 367, 544, 361, 395, 363, 363, 363, 363, 363, - 363, 370, 367, 398, 363, 362, 563, 575, 576, 554, - 555, 556, 562, 566, 501, 371, 548, 553, 557, 503, - 372, 363, 410, 550, 548, 366, 544, 363, 503, 553, - 554, 558, 567, 372, 367 + 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, + 478, 479, 480, 481, 482, 514, 515, 518, 519, 520, + 521, 525, 526, 527, 528, 529, 530, 533, 534, 535, + 536, 537, 539, 544, 545, 546, 587, 588, 589, 591, + 598, 602, 603, 609, 612, 371, 371, 371, 371, 371, + 371, 371, 371, 373, 545, 375, 407, 371, 371, 381, + 407, 381, 590, 372, 378, 522, 523, 524, 534, 539, + 378, 381, 407, 381, 407, 517, 535, 539, 389, 541, + 542, 0, 588, 519, 527, 534, 381, 518, 407, 594, + 595, 613, 614, 404, 407, 594, 404, 594, 404, 594, + 404, 594, 404, 594, 594, 613, 404, 594, 407, 592, + 593, 539, 548, 375, 407, 431, 531, 532, 407, 538, + 373, 381, 540, 375, 566, 591, 377, 523, 522, 524, + 407, 407, 371, 380, 540, 375, 378, 381, 351, 352, + 370, 371, 382, 383, 384, 385, 403, 404, 405, 406, + 407, 437, 438, 439, 440, 441, 442, 443, 444, 484, + 485, 486, 488, 489, 490, 491, 492, 493, 494, 495, + 496, 537, 539, 543, 540, 372, 407, 381, 380, 378, + 372, 378, 372, 378, 380, 378, 378, 378, 372, 378, + 378, 378, 378, 378, 378, 378, 372, 378, 372, 378, + 371, 374, 378, 381, 534, 539, 549, 550, 547, 380, + 372, 378, 372, 378, 374, 495, 497, 498, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 539, 373, + 381, 375, 376, 381, 415, 416, 417, 418, 420, 421, + 422, 423, 424, 425, 426, 427, 428, 429, 446, 495, + 508, 510, 512, 514, 518, 537, 539, 555, 556, 557, + 558, 559, 567, 568, 569, 570, 573, 574, 577, 578, + 579, 586, 591, 377, 380, 540, 380, 540, 375, 510, + 553, 380, 516, 407, 495, 495, 512, 351, 352, 373, + 377, 372, 372, 378, 414, 510, 371, 495, 378, 390, + 591, 370, 373, 404, 595, 613, 407, 614, 370, 403, + 404, 405, 406, 599, 600, 404, 508, 513, 601, 404, + 403, 404, 405, 406, 604, 605, 404, 403, 404, 405, + 406, 484, 606, 607, 404, 370, 608, 404, 613, 407, + 513, 544, 610, 611, 404, 513, 374, 593, 539, 407, + 551, 552, 376, 550, 549, 513, 532, 407, 386, 387, + 388, 383, 385, 349, 350, 353, 354, 389, 390, 355, + 356, 393, 392, 391, 357, 359, 358, 394, 374, 374, + 508, 376, 560, 371, 381, 381, 581, 371, 371, 381, + 381, 512, 371, 512, 379, 381, 381, 381, 381, 360, + 361, 362, 363, 364, 365, 366, 367, 368, 369, 380, + 511, 378, 381, 376, 556, 570, 574, 579, 377, 553, + 553, 380, 376, 553, 554, 553, 549, 372, 487, 512, + 407, 510, 495, 370, 404, 596, 597, 372, 380, 372, + 378, 372, 378, 372, 378, 378, 372, 378, 372, 378, + 372, 378, 378, 372, 378, 378, 372, 378, 372, 378, + 372, 372, 551, 540, 378, 381, 376, 495, 495, 495, + 497, 497, 498, 498, 499, 499, 499, 499, 500, 500, + 501, 502, 503, 504, 505, 506, 509, 374, 567, 580, + 556, 582, 512, 381, 512, 379, 510, 510, 553, 376, + 378, 376, 374, 374, 378, 374, 378, 600, 599, 513, + 601, 605, 604, 607, 606, 370, 608, 610, 611, 381, + 552, 512, 561, 512, 527, 572, 415, 555, 568, 583, + 372, 372, 376, 553, 370, 404, 372, 372, 372, 372, + 372, 372, 379, 376, 407, 372, 371, 572, 584, 585, + 563, 564, 565, 571, 575, 510, 380, 557, 562, 566, + 512, 381, 372, 419, 559, 557, 375, 553, 372, 512, + 562, 563, 567, 576, 381, 376 }; /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ static const yytype_int16 yyr1[] = { - 0, 474, 475, 476, 476, 476, 476, 476, 476, 476, - 476, 476, 476, 476, 476, 476, 476, 476, 477, 477, - 477, 477, 477, 477, 478, 479, 480, 481, 481, 482, - 482, 483, 483, 484, 485, 485, 485, 486, 486, 486, - 486, 487, 487, 487, 487, 488, 488, 488, 488, 489, - 489, 489, 490, 490, 490, 491, 491, 491, 491, 491, - 492, 492, 492, 493, 493, 494, 494, 495, 495, 496, - 496, 497, 497, 498, 498, 499, 500, 499, 501, 501, - 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, - 502, 503, 503, 504, 505, 505, 505, 505, 505, 505, - 505, 505, 505, 505, 505, 507, 506, 508, 508, 509, - 509, 509, 509, 510, 510, 511, 511, 512, 513, 513, - 514, 514, 514, 514, 515, 516, 516, 516, 516, 516, - 517, 517, 517, 517, 517, 518, 518, 519, 520, 520, - 520, 520, 520, 520, 520, 520, 520, 520, 521, 522, - 522, 523, 523, 523, 524, 525, 525, 526, 526, 526, - 526, 526, 526, 526, 526, 526, 526, 526, 527, 527, - 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, - 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, - 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, - 527, 527, 527, 527, 527, 527, 527, 528, 529, 529, - 530, 530, 531, 531, 531, 531, 532, 532, 533, 534, - 534, 534, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 535, 535, 535, 535, 535, 535, 535, 535, 535, 535, - 536, 536, 536, 538, 537, 539, 537, 540, 540, 541, - 541, 542, 542, 543, 543, 544, 544, 544, 544, 545, - 545, 546, 547, 547, 548, 548, 548, 548, 548, 548, - 548, 548, 549, 550, 551, 552, 550, 553, 553, 555, - 554, 556, 554, 557, 557, 558, 558, 559, 559, 560, - 560, 561, 562, 562, 563, 563, 564, 564, 566, 565, - 567, 567, 568, 568, 569, 569, 571, 570, 572, 570, - 573, 570, 574, 574, 575, 575, 576, 576, 577, 577, - 577, 577, 577, 577, 577, 577, 578, 578, 579, 579, - 579, 581, 580, 582, 583, 583, 584, 584, 585, 585, - 586, 586, 587, 587, 588, 588, 589, 589, 589, 589, - 589, 589, 590, 590, 591, 591, 591, 591, 591, 592, - 592, 593, 593, 594, 594, 594, 594, 594, 594, 594, - 594, 595, 595, 596, 596, 596, 596, 597, 597, 598, - 598, 598, 598, 598, 599, 599, 600, 600, 600, 600, - 601, 601, 602, 602, 603, 603, 604, 604, 605, 605 + 0, 483, 484, 485, 485, 485, 485, 485, 485, 485, + 485, 485, 485, 485, 485, 485, 485, 485, 486, 486, + 486, 486, 486, 486, 487, 488, 489, 490, 490, 491, + 491, 492, 492, 493, 494, 494, 494, 495, 495, 495, + 495, 496, 496, 496, 496, 497, 497, 497, 497, 498, + 498, 498, 499, 499, 499, 500, 500, 500, 500, 500, + 501, 501, 501, 502, 502, 503, 503, 504, 504, 505, + 505, 506, 506, 507, 507, 508, 509, 508, 510, 510, + 511, 511, 511, 511, 511, 511, 511, 511, 511, 511, + 511, 512, 512, 513, 514, 514, 514, 514, 514, 514, + 514, 514, 514, 514, 516, 515, 517, 517, 518, 518, + 518, 518, 519, 519, 520, 520, 520, 521, 522, 522, + 522, 523, 523, 523, 523, 524, 525, 525, 525, 525, + 525, 526, 526, 526, 526, 526, 527, 527, 528, 529, + 529, 529, 529, 529, 529, 529, 529, 529, 529, 530, + 531, 531, 532, 532, 532, 533, 534, 534, 535, 535, + 535, 535, 535, 535, 535, 535, 535, 535, 535, 536, + 536, 536, 536, 536, 536, 536, 536, 536, 536, 536, + 536, 536, 536, 536, 536, 536, 536, 536, 536, 536, + 536, 536, 536, 536, 536, 536, 536, 536, 536, 536, + 536, 536, 536, 536, 536, 536, 536, 536, 537, 538, + 538, 539, 539, 540, 540, 540, 540, 541, 541, 542, + 543, 543, 543, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 544, 544, 544, 544, 544, 544, 544, 544, 544, 544, + 545, 545, 545, 547, 546, 548, 546, 549, 549, 550, + 550, 551, 551, 552, 552, 553, 553, 553, 553, 554, + 554, 555, 556, 556, 557, 557, 557, 557, 557, 557, + 557, 557, 558, 559, 560, 561, 559, 562, 562, 564, + 563, 565, 563, 566, 566, 567, 567, 568, 568, 569, + 569, 570, 571, 571, 572, 572, 573, 573, 575, 574, + 576, 576, 577, 577, 578, 578, 580, 579, 581, 579, + 582, 579, 583, 583, 584, 584, 585, 585, 586, 586, + 586, 586, 586, 586, 586, 586, 587, 587, 588, 588, + 588, 590, 589, 591, 592, 592, 593, 593, 594, 594, + 595, 595, 596, 596, 597, 597, 598, 598, 598, 598, + 598, 598, 599, 599, 600, 600, 600, 600, 600, 601, + 601, 602, 602, 603, 603, 603, 603, 603, 603, 603, + 603, 604, 604, 605, 605, 605, 605, 606, 606, 607, + 607, 607, 607, 607, 608, 608, 609, 609, 609, 609, + 610, 610, 611, 611, 612, 612, 613, 613, 614, 614 }; /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ @@ -4468,19 +4629,20 @@ static const yytype_int8 yyr2[] = 3, 1, 3, 1, 3, 1, 0, 6, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 2, 3, 2, 2, 4, 2, - 3, 4, 2, 3, 4, 0, 6, 2, 3, 2, - 3, 3, 4, 1, 1, 2, 3, 3, 2, 3, - 2, 1, 2, 1, 1, 1, 3, 4, 6, 5, - 1, 2, 3, 5, 4, 1, 2, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, - 3, 1, 3, 1, 1, 1, 2, 1, 1, 1, + 3, 4, 2, 3, 0, 6, 1, 3, 2, 3, + 3, 4, 1, 1, 2, 3, 5, 3, 2, 3, + 4, 2, 1, 2, 1, 1, 1, 3, 4, 6, + 5, 1, 2, 3, 5, 4, 1, 2, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, + 1, 3, 1, 3, 1, 1, 1, 2, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, + 3, 2, 3, 2, 3, 3, 4, 1, 0, 3, + 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 4, 1, 1, 1, 3, - 2, 3, 2, 3, 3, 4, 1, 0, 3, 1, - 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -5270,260 +5432,260 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); switch (yyn) { case 2: /* variable_identifier: IDENTIFIER */ -#line 358 "MachineIndependent/glslang.y" +#line 361 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleVariable((yyvsp[0].lex).loc, (yyvsp[0].lex).symbol, (yyvsp[0].lex).string); } -#line 5278 "MachineIndependent/glslang_tab.cpp" +#line 5440 "MachineIndependent/glslang_tab.cpp" break; case 3: /* primary_expression: variable_identifier */ -#line 364 "MachineIndependent/glslang.y" +#line 367 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5286 "MachineIndependent/glslang_tab.cpp" +#line 5448 "MachineIndependent/glslang_tab.cpp" break; case 4: /* primary_expression: LEFT_PAREN expression RIGHT_PAREN */ -#line 367 "MachineIndependent/glslang.y" +#line 370 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); if ((yyval.interm.intermTypedNode)->getAsConstantUnion()) (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } -#line 5296 "MachineIndependent/glslang_tab.cpp" +#line 5458 "MachineIndependent/glslang_tab.cpp" break; case 5: /* primary_expression: FLOATCONSTANT */ -#line 372 "MachineIndependent/glslang.y" +#line 375 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 5304 "MachineIndependent/glslang_tab.cpp" +#line 5466 "MachineIndependent/glslang_tab.cpp" break; case 6: /* primary_expression: INTCONSTANT */ -#line 375 "MachineIndependent/glslang.y" +#line 378 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 5312 "MachineIndependent/glslang_tab.cpp" +#line 5474 "MachineIndependent/glslang_tab.cpp" break; case 7: /* primary_expression: UINTCONSTANT */ -#line 378 "MachineIndependent/glslang.y" +#line 381 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 5321 "MachineIndependent/glslang_tab.cpp" +#line 5483 "MachineIndependent/glslang_tab.cpp" break; case 8: /* primary_expression: BOOLCONSTANT */ -#line 382 "MachineIndependent/glslang.y" +#line 385 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 5329 "MachineIndependent/glslang_tab.cpp" +#line 5491 "MachineIndependent/glslang_tab.cpp" break; case 9: /* primary_expression: STRING_LITERAL */ -#line 385 "MachineIndependent/glslang.y" +#line 388 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true); } -#line 5337 "MachineIndependent/glslang_tab.cpp" +#line 5499 "MachineIndependent/glslang_tab.cpp" break; case 10: /* primary_expression: INT32CONSTANT */ -#line 388 "MachineIndependent/glslang.y" +#line 391 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 5346 "MachineIndependent/glslang_tab.cpp" +#line 5508 "MachineIndependent/glslang_tab.cpp" break; case 11: /* primary_expression: UINT32CONSTANT */ -#line 392 "MachineIndependent/glslang.y" +#line 395 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 5355 "MachineIndependent/glslang_tab.cpp" +#line 5517 "MachineIndependent/glslang_tab.cpp" break; case 12: /* primary_expression: INT64CONSTANT */ -#line 396 "MachineIndependent/glslang.y" +#line 399 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i64, (yyvsp[0].lex).loc, true); } -#line 5364 "MachineIndependent/glslang_tab.cpp" +#line 5526 "MachineIndependent/glslang_tab.cpp" break; case 13: /* primary_expression: UINT64CONSTANT */ -#line 400 "MachineIndependent/glslang.y" +#line 403 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u64, (yyvsp[0].lex).loc, true); } -#line 5373 "MachineIndependent/glslang_tab.cpp" +#line 5535 "MachineIndependent/glslang_tab.cpp" break; case 14: /* primary_expression: INT16CONSTANT */ -#line 404 "MachineIndependent/glslang.y" +#line 407 "MachineIndependent/glslang.y" { parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((short)(yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 5382 "MachineIndependent/glslang_tab.cpp" +#line 5544 "MachineIndependent/glslang_tab.cpp" break; case 15: /* primary_expression: UINT16CONSTANT */ -#line 408 "MachineIndependent/glslang.y" +#line 411 "MachineIndependent/glslang.y" { parseContext.explicitInt16Check((yyvsp[0].lex).loc, "16-bit unsigned integer literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((unsigned short)(yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 5391 "MachineIndependent/glslang_tab.cpp" +#line 5553 "MachineIndependent/glslang_tab.cpp" break; case 16: /* primary_expression: DOUBLECONSTANT */ -#line 412 "MachineIndependent/glslang.y" +#line 415 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double literal"); if (! parseContext.symbolTable.atBuiltInLevel()) parseContext.doubleCheck((yyvsp[0].lex).loc, "double literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtDouble, (yyvsp[0].lex).loc, true); } -#line 5402 "MachineIndependent/glslang_tab.cpp" +#line 5564 "MachineIndependent/glslang_tab.cpp" break; case 17: /* primary_expression: FLOAT16CONSTANT */ -#line 418 "MachineIndependent/glslang.y" +#line 421 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float literal"); (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat16, (yyvsp[0].lex).loc, true); } -#line 5411 "MachineIndependent/glslang_tab.cpp" +#line 5573 "MachineIndependent/glslang_tab.cpp" break; case 18: /* postfix_expression: primary_expression */ -#line 425 "MachineIndependent/glslang.y" +#line 428 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5419 "MachineIndependent/glslang_tab.cpp" +#line 5581 "MachineIndependent/glslang_tab.cpp" break; case 19: /* postfix_expression: postfix_expression LEFT_BRACKET integer_expression RIGHT_BRACKET */ -#line 428 "MachineIndependent/glslang.y" +#line 431 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBracketDereference((yyvsp[-2].lex).loc, (yyvsp[-3].interm.intermTypedNode), (yyvsp[-1].interm.intermTypedNode)); } -#line 5427 "MachineIndependent/glslang_tab.cpp" +#line 5589 "MachineIndependent/glslang_tab.cpp" break; case 20: /* postfix_expression: function_call */ -#line 431 "MachineIndependent/glslang.y" +#line 434 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5435 "MachineIndependent/glslang_tab.cpp" +#line 5597 "MachineIndependent/glslang_tab.cpp" break; case 21: /* postfix_expression: postfix_expression DOT IDENTIFIER */ -#line 434 "MachineIndependent/glslang.y" +#line 437 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleDotDereference((yyvsp[0].lex).loc, (yyvsp[-2].interm.intermTypedNode), *(yyvsp[0].lex).string); } -#line 5443 "MachineIndependent/glslang_tab.cpp" +#line 5605 "MachineIndependent/glslang_tab.cpp" break; case 22: /* postfix_expression: postfix_expression INC_OP */ -#line 437 "MachineIndependent/glslang.y" +#line 440 "MachineIndependent/glslang.y" { parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "++", (yyvsp[-1].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "++", EOpPostIncrement, (yyvsp[-1].interm.intermTypedNode)); } -#line 5453 "MachineIndependent/glslang_tab.cpp" +#line 5615 "MachineIndependent/glslang_tab.cpp" break; case 23: /* postfix_expression: postfix_expression DEC_OP */ -#line 442 "MachineIndependent/glslang.y" +#line 445 "MachineIndependent/glslang.y" { parseContext.variableCheck((yyvsp[-1].interm.intermTypedNode)); parseContext.lValueErrorCheck((yyvsp[0].lex).loc, "--", (yyvsp[-1].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[0].lex).loc, "--", EOpPostDecrement, (yyvsp[-1].interm.intermTypedNode)); } -#line 5463 "MachineIndependent/glslang_tab.cpp" +#line 5625 "MachineIndependent/glslang_tab.cpp" break; case 24: /* integer_expression: expression */ -#line 450 "MachineIndependent/glslang.y" +#line 453 "MachineIndependent/glslang.y" { parseContext.integerCheck((yyvsp[0].interm.intermTypedNode), "[]"); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5472 "MachineIndependent/glslang_tab.cpp" +#line 5634 "MachineIndependent/glslang_tab.cpp" break; case 25: /* function_call: function_call_or_method */ -#line 457 "MachineIndependent/glslang.y" +#line 460 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleFunctionCall((yyvsp[0].interm).loc, (yyvsp[0].interm).function, (yyvsp[0].interm).intermNode); delete (yyvsp[0].interm).function; } -#line 5481 "MachineIndependent/glslang_tab.cpp" +#line 5643 "MachineIndependent/glslang_tab.cpp" break; case 26: /* function_call_or_method: function_call_generic */ -#line 464 "MachineIndependent/glslang.y" +#line 467 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); } -#line 5489 "MachineIndependent/glslang_tab.cpp" +#line 5651 "MachineIndependent/glslang_tab.cpp" break; case 27: /* function_call_generic: function_call_header_with_parameters RIGHT_PAREN */ -#line 470 "MachineIndependent/glslang.y" +#line 473 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-1].interm); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 5498 "MachineIndependent/glslang_tab.cpp" +#line 5660 "MachineIndependent/glslang_tab.cpp" break; case 28: /* function_call_generic: function_call_header_no_parameters RIGHT_PAREN */ -#line 474 "MachineIndependent/glslang.y" +#line 477 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-1].interm); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 5507 "MachineIndependent/glslang_tab.cpp" +#line 5669 "MachineIndependent/glslang_tab.cpp" break; case 29: /* function_call_header_no_parameters: function_call_header VOID */ -#line 481 "MachineIndependent/glslang.y" +#line 484 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-1].interm); } -#line 5515 "MachineIndependent/glslang_tab.cpp" +#line 5677 "MachineIndependent/glslang_tab.cpp" break; case 30: /* function_call_header_no_parameters: function_call_header */ -#line 484 "MachineIndependent/glslang.y" +#line 487 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); } -#line 5523 "MachineIndependent/glslang_tab.cpp" +#line 5685 "MachineIndependent/glslang_tab.cpp" break; case 31: /* function_call_header_with_parameters: function_call_header assignment_expression */ -#line 490 "MachineIndependent/glslang.y" +#line 493 "MachineIndependent/glslang.y" { if (parseContext.spvVersion.vulkan > 0 && parseContext.spvVersion.vulkanRelaxed @@ -5542,11 +5704,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).intermNode = (yyvsp[0].interm.intermTypedNode); } } -#line 5546 "MachineIndependent/glslang_tab.cpp" +#line 5708 "MachineIndependent/glslang_tab.cpp" break; case 32: /* function_call_header_with_parameters: function_call_header_with_parameters COMMA assignment_expression */ -#line 508 "MachineIndependent/glslang.y" +#line 511 "MachineIndependent/glslang.y" { if (parseContext.spvVersion.vulkan > 0 && parseContext.spvVersion.vulkanRelaxed @@ -5569,29 +5731,29 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-2].interm).intermNode, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); } } -#line 5573 "MachineIndependent/glslang_tab.cpp" +#line 5735 "MachineIndependent/glslang_tab.cpp" break; case 33: /* function_call_header: function_identifier LEFT_PAREN */ -#line 533 "MachineIndependent/glslang.y" +#line 536 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-1].interm); } -#line 5581 "MachineIndependent/glslang_tab.cpp" +#line 5743 "MachineIndependent/glslang_tab.cpp" break; case 34: /* function_identifier: type_specifier */ -#line 541 "MachineIndependent/glslang.y" +#line 544 "MachineIndependent/glslang.y" { // Constructor (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 5591 "MachineIndependent/glslang_tab.cpp" +#line 5753 "MachineIndependent/glslang_tab.cpp" break; case 35: /* function_identifier: postfix_expression */ -#line 546 "MachineIndependent/glslang.y" +#line 549 "MachineIndependent/glslang.y" { // // Should be a method or subroutine call, but we haven't recognized the arguments yet. @@ -5619,50 +5781,50 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).function = new TFunction(empty, TType(EbtVoid), EOpNull); } } -#line 5623 "MachineIndependent/glslang_tab.cpp" +#line 5785 "MachineIndependent/glslang_tab.cpp" break; case 36: /* function_identifier: non_uniform_qualifier */ -#line 573 "MachineIndependent/glslang.y" +#line 576 "MachineIndependent/glslang.y" { // Constructor (yyval.interm).intermNode = 0; (yyval.interm).function = parseContext.handleConstructorCall((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 5633 "MachineIndependent/glslang_tab.cpp" +#line 5795 "MachineIndependent/glslang_tab.cpp" break; case 37: /* unary_expression: postfix_expression */ -#line 581 "MachineIndependent/glslang.y" +#line 584 "MachineIndependent/glslang.y" { parseContext.variableCheck((yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); if (TIntermMethod* method = (yyvsp[0].interm.intermTypedNode)->getAsMethodNode()) parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "incomplete method syntax", method->getMethodName().c_str(), ""); } -#line 5644 "MachineIndependent/glslang_tab.cpp" +#line 5806 "MachineIndependent/glslang_tab.cpp" break; case 38: /* unary_expression: INC_OP unary_expression */ -#line 587 "MachineIndependent/glslang.y" +#line 590 "MachineIndependent/glslang.y" { parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "++", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "++", EOpPreIncrement, (yyvsp[0].interm.intermTypedNode)); } -#line 5653 "MachineIndependent/glslang_tab.cpp" +#line 5815 "MachineIndependent/glslang_tab.cpp" break; case 39: /* unary_expression: DEC_OP unary_expression */ -#line 591 "MachineIndependent/glslang.y" +#line 594 "MachineIndependent/glslang.y" { parseContext.lValueErrorCheck((yyvsp[-1].lex).loc, "--", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.handleUnaryMath((yyvsp[-1].lex).loc, "--", EOpPreDecrement, (yyvsp[0].interm.intermTypedNode)); } -#line 5662 "MachineIndependent/glslang_tab.cpp" +#line 5824 "MachineIndependent/glslang_tab.cpp" break; case 40: /* unary_expression: unary_operator unary_expression */ -#line 595 "MachineIndependent/glslang.y" +#line 598 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm).op != EOpNull) { char errorOp[2] = {0, 0}; @@ -5679,179 +5841,179 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermTypedNode)->getAsConstantUnion()->setExpression(); } } -#line 5683 "MachineIndependent/glslang_tab.cpp" +#line 5845 "MachineIndependent/glslang_tab.cpp" break; case 41: /* unary_operator: PLUS */ -#line 615 "MachineIndependent/glslang.y" +#line 618 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNull; } -#line 5689 "MachineIndependent/glslang_tab.cpp" +#line 5851 "MachineIndependent/glslang_tab.cpp" break; case 42: /* unary_operator: DASH */ -#line 616 "MachineIndependent/glslang.y" +#line 619 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpNegative; } -#line 5695 "MachineIndependent/glslang_tab.cpp" +#line 5857 "MachineIndependent/glslang_tab.cpp" break; case 43: /* unary_operator: BANG */ -#line 617 "MachineIndependent/glslang.y" +#line 620 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLogicalNot; } -#line 5701 "MachineIndependent/glslang_tab.cpp" +#line 5863 "MachineIndependent/glslang_tab.cpp" break; case 44: /* unary_operator: TILDE */ -#line 618 "MachineIndependent/glslang.y" +#line 621 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpBitwiseNot; parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise not"); } -#line 5708 "MachineIndependent/glslang_tab.cpp" +#line 5870 "MachineIndependent/glslang_tab.cpp" break; case 45: /* multiplicative_expression: unary_expression */ -#line 624 "MachineIndependent/glslang.y" +#line 627 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5714 "MachineIndependent/glslang_tab.cpp" +#line 5876 "MachineIndependent/glslang_tab.cpp" break; case 46: /* multiplicative_expression: multiplicative_expression STAR unary_expression */ -#line 625 "MachineIndependent/glslang.y" +#line 628 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "*", EOpMul, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5724 "MachineIndependent/glslang_tab.cpp" +#line 5886 "MachineIndependent/glslang_tab.cpp" break; case 47: /* multiplicative_expression: multiplicative_expression SLASH unary_expression */ -#line 630 "MachineIndependent/glslang.y" +#line 633 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "/", EOpDiv, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5734 "MachineIndependent/glslang_tab.cpp" +#line 5896 "MachineIndependent/glslang_tab.cpp" break; case 48: /* multiplicative_expression: multiplicative_expression PERCENT unary_expression */ -#line 635 "MachineIndependent/glslang.y" +#line 638 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "%"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "%", EOpMod, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5745 "MachineIndependent/glslang_tab.cpp" +#line 5907 "MachineIndependent/glslang_tab.cpp" break; case 49: /* additive_expression: multiplicative_expression */ -#line 644 "MachineIndependent/glslang.y" +#line 647 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5751 "MachineIndependent/glslang_tab.cpp" +#line 5913 "MachineIndependent/glslang_tab.cpp" break; case 50: /* additive_expression: additive_expression PLUS multiplicative_expression */ -#line 645 "MachineIndependent/glslang.y" +#line 648 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "+", EOpAdd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5761 "MachineIndependent/glslang_tab.cpp" +#line 5923 "MachineIndependent/glslang_tab.cpp" break; case 51: /* additive_expression: additive_expression DASH multiplicative_expression */ -#line 650 "MachineIndependent/glslang.y" +#line 653 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "-", EOpSub, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5771 "MachineIndependent/glslang_tab.cpp" +#line 5933 "MachineIndependent/glslang_tab.cpp" break; case 52: /* shift_expression: additive_expression */ -#line 658 "MachineIndependent/glslang.y" +#line 661 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5777 "MachineIndependent/glslang_tab.cpp" +#line 5939 "MachineIndependent/glslang_tab.cpp" break; case 53: /* shift_expression: shift_expression LEFT_OP additive_expression */ -#line 659 "MachineIndependent/glslang.y" +#line 662 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift left"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<<", EOpLeftShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5788 "MachineIndependent/glslang_tab.cpp" +#line 5950 "MachineIndependent/glslang_tab.cpp" break; case 54: /* shift_expression: shift_expression RIGHT_OP additive_expression */ -#line 665 "MachineIndependent/glslang.y" +#line 668 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bit shift right"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">>", EOpRightShift, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5799 "MachineIndependent/glslang_tab.cpp" +#line 5961 "MachineIndependent/glslang_tab.cpp" break; case 55: /* relational_expression: shift_expression */ -#line 674 "MachineIndependent/glslang.y" +#line 677 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5805 "MachineIndependent/glslang_tab.cpp" +#line 5967 "MachineIndependent/glslang_tab.cpp" break; case 56: /* relational_expression: relational_expression LEFT_ANGLE shift_expression */ -#line 675 "MachineIndependent/glslang.y" +#line 678 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<", EOpLessThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5815 "MachineIndependent/glslang_tab.cpp" +#line 5977 "MachineIndependent/glslang_tab.cpp" break; case 57: /* relational_expression: relational_expression RIGHT_ANGLE shift_expression */ -#line 680 "MachineIndependent/glslang.y" +#line 683 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">", EOpGreaterThan, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5825 "MachineIndependent/glslang_tab.cpp" +#line 5987 "MachineIndependent/glslang_tab.cpp" break; case 58: /* relational_expression: relational_expression LE_OP shift_expression */ -#line 685 "MachineIndependent/glslang.y" +#line 688 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "<=", EOpLessThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5835 "MachineIndependent/glslang_tab.cpp" +#line 5997 "MachineIndependent/glslang_tab.cpp" break; case 59: /* relational_expression: relational_expression GE_OP shift_expression */ -#line 690 "MachineIndependent/glslang.y" +#line 693 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, ">=", EOpGreaterThanEqual, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5845 "MachineIndependent/glslang_tab.cpp" +#line 6007 "MachineIndependent/glslang_tab.cpp" break; case 60: /* equality_expression: relational_expression */ -#line 698 "MachineIndependent/glslang.y" +#line 701 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5851 "MachineIndependent/glslang_tab.cpp" +#line 6013 "MachineIndependent/glslang_tab.cpp" break; case 61: /* equality_expression: equality_expression EQ_OP relational_expression */ -#line 699 "MachineIndependent/glslang.y" +#line 702 "MachineIndependent/glslang.y" { parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "=="); @@ -5861,11 +6023,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5865 "MachineIndependent/glslang_tab.cpp" +#line 6027 "MachineIndependent/glslang_tab.cpp" break; case 62: /* equality_expression: equality_expression NE_OP relational_expression */ -#line 708 "MachineIndependent/glslang.y" +#line 711 "MachineIndependent/glslang.y" { parseContext.arrayObjectCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array comparison"); parseContext.opaqueCheck((yyvsp[-1].lex).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "!="); @@ -5875,124 +6037,124 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5879 "MachineIndependent/glslang_tab.cpp" +#line 6041 "MachineIndependent/glslang_tab.cpp" break; case 63: /* and_expression: equality_expression */ -#line 720 "MachineIndependent/glslang.y" +#line 723 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5885 "MachineIndependent/glslang_tab.cpp" +#line 6047 "MachineIndependent/glslang_tab.cpp" break; case 64: /* and_expression: and_expression AMPERSAND equality_expression */ -#line 721 "MachineIndependent/glslang.y" +#line 724 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise and"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&", EOpAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5896 "MachineIndependent/glslang_tab.cpp" +#line 6058 "MachineIndependent/glslang_tab.cpp" break; case 65: /* exclusive_or_expression: and_expression */ -#line 730 "MachineIndependent/glslang.y" +#line 733 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5902 "MachineIndependent/glslang_tab.cpp" +#line 6064 "MachineIndependent/glslang_tab.cpp" break; case 66: /* exclusive_or_expression: exclusive_or_expression CARET and_expression */ -#line 731 "MachineIndependent/glslang.y" +#line 734 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise exclusive or"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^", EOpExclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5913 "MachineIndependent/glslang_tab.cpp" +#line 6075 "MachineIndependent/glslang_tab.cpp" break; case 67: /* inclusive_or_expression: exclusive_or_expression */ -#line 740 "MachineIndependent/glslang.y" +#line 743 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5919 "MachineIndependent/glslang_tab.cpp" +#line 6081 "MachineIndependent/glslang_tab.cpp" break; case 68: /* inclusive_or_expression: inclusive_or_expression VERTICAL_BAR exclusive_or_expression */ -#line 741 "MachineIndependent/glslang.y" +#line 744 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[-1].lex).loc, "bitwise inclusive or"); (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "|", EOpInclusiveOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 5930 "MachineIndependent/glslang_tab.cpp" +#line 6092 "MachineIndependent/glslang_tab.cpp" break; case 69: /* logical_and_expression: inclusive_or_expression */ -#line 750 "MachineIndependent/glslang.y" +#line 753 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5936 "MachineIndependent/glslang_tab.cpp" +#line 6098 "MachineIndependent/glslang_tab.cpp" break; case 70: /* logical_and_expression: logical_and_expression AND_OP inclusive_or_expression */ -#line 751 "MachineIndependent/glslang.y" +#line 754 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "&&", EOpLogicalAnd, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5946 "MachineIndependent/glslang_tab.cpp" +#line 6108 "MachineIndependent/glslang_tab.cpp" break; case 71: /* logical_xor_expression: logical_and_expression */ -#line 759 "MachineIndependent/glslang.y" +#line 762 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5952 "MachineIndependent/glslang_tab.cpp" +#line 6114 "MachineIndependent/glslang_tab.cpp" break; case 72: /* logical_xor_expression: logical_xor_expression XOR_OP logical_and_expression */ -#line 760 "MachineIndependent/glslang.y" +#line 763 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "^^", EOpLogicalXor, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5962 "MachineIndependent/glslang_tab.cpp" +#line 6124 "MachineIndependent/glslang_tab.cpp" break; case 73: /* logical_or_expression: logical_xor_expression */ -#line 768 "MachineIndependent/glslang.y" +#line 771 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5968 "MachineIndependent/glslang_tab.cpp" +#line 6130 "MachineIndependent/glslang_tab.cpp" break; case 74: /* logical_or_expression: logical_or_expression OR_OP logical_xor_expression */ -#line 769 "MachineIndependent/glslang.y" +#line 772 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.handleBinaryMath((yyvsp[-1].lex).loc, "||", EOpLogicalOr, (yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); if ((yyval.interm.intermTypedNode) == 0) (yyval.interm.intermTypedNode) = parseContext.intermediate.addConstantUnion(false, (yyvsp[-1].lex).loc); } -#line 5978 "MachineIndependent/glslang_tab.cpp" +#line 6140 "MachineIndependent/glslang_tab.cpp" break; case 75: /* conditional_expression: logical_or_expression */ -#line 777 "MachineIndependent/glslang.y" +#line 780 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 5984 "MachineIndependent/glslang_tab.cpp" +#line 6146 "MachineIndependent/glslang_tab.cpp" break; case 76: /* $@1: %empty */ -#line 778 "MachineIndependent/glslang.y" +#line 781 "MachineIndependent/glslang.y" { ++parseContext.controlFlowNestingLevel; } -#line 5992 "MachineIndependent/glslang_tab.cpp" +#line 6154 "MachineIndependent/glslang_tab.cpp" break; case 77: /* conditional_expression: logical_or_expression QUESTION $@1 expression COLON assignment_expression */ -#line 781 "MachineIndependent/glslang.y" +#line 784 "MachineIndependent/glslang.y" { --parseContext.controlFlowNestingLevel; parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-5].interm.intermTypedNode)); @@ -6005,17 +6167,17 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 6009 "MachineIndependent/glslang_tab.cpp" +#line 6171 "MachineIndependent/glslang_tab.cpp" break; case 78: /* assignment_expression: conditional_expression */ -#line 796 "MachineIndependent/glslang.y" +#line 799 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6015 "MachineIndependent/glslang_tab.cpp" +#line 6177 "MachineIndependent/glslang_tab.cpp" break; case 79: /* assignment_expression: unary_expression assignment_operator assignment_expression */ -#line 797 "MachineIndependent/glslang.y" +#line 800 "MachineIndependent/glslang.y" { parseContext.arrayObjectCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "array assignment"); parseContext.opaqueCheck((yyvsp[-1].interm).loc, (yyvsp[-2].interm.intermTypedNode)->getType(), "="); @@ -6029,119 +6191,119 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } } -#line 6033 "MachineIndependent/glslang_tab.cpp" +#line 6195 "MachineIndependent/glslang_tab.cpp" break; case 80: /* assignment_operator: EQUAL */ -#line 813 "MachineIndependent/glslang.y" +#line 816 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAssign; } -#line 6042 "MachineIndependent/glslang_tab.cpp" +#line 6204 "MachineIndependent/glslang_tab.cpp" break; case 81: /* assignment_operator: MUL_ASSIGN */ -#line 817 "MachineIndependent/glslang.y" +#line 820 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpMulAssign; } -#line 6051 "MachineIndependent/glslang_tab.cpp" +#line 6213 "MachineIndependent/glslang_tab.cpp" break; case 82: /* assignment_operator: DIV_ASSIGN */ -#line 821 "MachineIndependent/glslang.y" +#line 824 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpDivAssign; } -#line 6060 "MachineIndependent/glslang_tab.cpp" +#line 6222 "MachineIndependent/glslang_tab.cpp" break; case 83: /* assignment_operator: MOD_ASSIGN */ -#line 825 "MachineIndependent/glslang.y" +#line 828 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "%="); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpModAssign; } -#line 6070 "MachineIndependent/glslang_tab.cpp" +#line 6232 "MachineIndependent/glslang_tab.cpp" break; case 84: /* assignment_operator: ADD_ASSIGN */ -#line 830 "MachineIndependent/glslang.y" +#line 833 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAddAssign; } -#line 6079 "MachineIndependent/glslang_tab.cpp" +#line 6241 "MachineIndependent/glslang_tab.cpp" break; case 85: /* assignment_operator: SUB_ASSIGN */ -#line 834 "MachineIndependent/glslang.y" +#line 837 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpSubAssign; } -#line 6088 "MachineIndependent/glslang_tab.cpp" +#line 6250 "MachineIndependent/glslang_tab.cpp" break; case 86: /* assignment_operator: LEFT_ASSIGN */ -#line 838 "MachineIndependent/glslang.y" +#line 841 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift left assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpLeftShiftAssign; } -#line 6097 "MachineIndependent/glslang_tab.cpp" +#line 6259 "MachineIndependent/glslang_tab.cpp" break; case 87: /* assignment_operator: RIGHT_ASSIGN */ -#line 842 "MachineIndependent/glslang.y" +#line 845 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bit-shift right assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpRightShiftAssign; } -#line 6106 "MachineIndependent/glslang_tab.cpp" +#line 6268 "MachineIndependent/glslang_tab.cpp" break; case 88: /* assignment_operator: AND_ASSIGN */ -#line 846 "MachineIndependent/glslang.y" +#line 849 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-and assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpAndAssign; } -#line 6115 "MachineIndependent/glslang_tab.cpp" +#line 6277 "MachineIndependent/glslang_tab.cpp" break; case 89: /* assignment_operator: XOR_ASSIGN */ -#line 850 "MachineIndependent/glslang.y" +#line 853 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-xor assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpExclusiveOrAssign; } -#line 6124 "MachineIndependent/glslang_tab.cpp" +#line 6286 "MachineIndependent/glslang_tab.cpp" break; case 90: /* assignment_operator: OR_ASSIGN */ -#line 854 "MachineIndependent/glslang.y" +#line 857 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "bitwise-or assign"); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).op = EOpInclusiveOrAssign; } -#line 6133 "MachineIndependent/glslang_tab.cpp" +#line 6295 "MachineIndependent/glslang_tab.cpp" break; case 91: /* expression: assignment_expression */ -#line 861 "MachineIndependent/glslang.y" +#line 864 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6141 "MachineIndependent/glslang_tab.cpp" +#line 6303 "MachineIndependent/glslang_tab.cpp" break; case 92: /* expression: expression COMMA assignment_expression */ -#line 864 "MachineIndependent/glslang.y" +#line 867 "MachineIndependent/glslang.y" { parseContext.samplerConstructorLocationCheck((yyvsp[-1].lex).loc, ",", (yyvsp[0].interm.intermTypedNode)); (yyval.interm.intermTypedNode) = parseContext.intermediate.addComma((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); @@ -6150,30 +6312,30 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } } -#line 6154 "MachineIndependent/glslang_tab.cpp" +#line 6316 "MachineIndependent/glslang_tab.cpp" break; case 93: /* constant_expression: conditional_expression */ -#line 875 "MachineIndependent/glslang.y" +#line 878 "MachineIndependent/glslang.y" { parseContext.constantValueCheck((yyvsp[0].interm.intermTypedNode), ""); (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 6163 "MachineIndependent/glslang_tab.cpp" +#line 6325 "MachineIndependent/glslang_tab.cpp" break; case 94: /* declaration: function_prototype SEMICOLON */ -#line 882 "MachineIndependent/glslang.y" +#line 885 "MachineIndependent/glslang.y" { parseContext.handleFunctionDeclarator((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).function, true /* prototype */); (yyval.interm.intermNode) = 0; // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature } -#line 6173 "MachineIndependent/glslang_tab.cpp" +#line 6335 "MachineIndependent/glslang_tab.cpp" break; case 95: /* declaration: spirv_instruction_qualifier function_prototype SEMICOLON */ -#line 887 "MachineIndependent/glslang.y" +#line 890 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[-1].interm).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V instruction qualifier"); (yyvsp[-1].interm).function->setSpirvInstruction(*(yyvsp[-2].interm.spirvInst)); // Attach SPIR-V intruction qualifier @@ -6181,31 +6343,31 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermNode) = 0; // TODO: 4.0 functionality: subroutines: make the identifier a user type for this signature } -#line 6185 "MachineIndependent/glslang_tab.cpp" +#line 6347 "MachineIndependent/glslang_tab.cpp" break; case 96: /* declaration: spirv_execution_mode_qualifier SEMICOLON */ -#line 894 "MachineIndependent/glslang.y" +#line 897 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "SPIR-V execution mode qualifier"); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V execution mode qualifier"); (yyval.interm.intermNode) = 0; } -#line 6195 "MachineIndependent/glslang_tab.cpp" +#line 6357 "MachineIndependent/glslang_tab.cpp" break; case 97: /* declaration: init_declarator_list SEMICOLON */ -#line 899 "MachineIndependent/glslang.y" +#line 902 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm).intermNode && (yyvsp[-1].interm).intermNode->getAsAggregate()) (yyvsp[-1].interm).intermNode->getAsAggregate()->setOperator(EOpSequence); (yyval.interm.intermNode) = (yyvsp[-1].interm).intermNode; } -#line 6205 "MachineIndependent/glslang_tab.cpp" +#line 6367 "MachineIndependent/glslang_tab.cpp" break; case 98: /* declaration: PRECISION precision_qualifier type_specifier SEMICOLON */ -#line 904 "MachineIndependent/glslang.y" +#line 907 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[-3].lex).loc, ENoProfile, 130, 0, "precision statement"); // lazy setting of the previous scope's defaults, has effect only the first time it is called in a particular scope @@ -6213,75 +6375,64 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.setDefaultPrecision((yyvsp[-3].lex).loc, (yyvsp[-1].interm.type), (yyvsp[-2].interm.type).qualifier.precision); (yyval.interm.intermNode) = 0; } -#line 6217 "MachineIndependent/glslang_tab.cpp" +#line 6379 "MachineIndependent/glslang_tab.cpp" break; case 99: /* declaration: block_structure SEMICOLON */ -#line 911 "MachineIndependent/glslang.y" +#line 914 "MachineIndependent/glslang.y" { parseContext.declareBlock((yyvsp[-1].interm).loc, *(yyvsp[-1].interm).typeList); (yyval.interm.intermNode) = 0; } -#line 6226 "MachineIndependent/glslang_tab.cpp" +#line 6388 "MachineIndependent/glslang_tab.cpp" break; case 100: /* declaration: block_structure IDENTIFIER SEMICOLON */ -#line 915 "MachineIndependent/glslang.y" +#line 918 "MachineIndependent/glslang.y" { parseContext.declareBlock((yyvsp[-2].interm).loc, *(yyvsp[-2].interm).typeList, (yyvsp[-1].lex).string); (yyval.interm.intermNode) = 0; } -#line 6235 "MachineIndependent/glslang_tab.cpp" +#line 6397 "MachineIndependent/glslang_tab.cpp" break; case 101: /* declaration: block_structure IDENTIFIER array_specifier SEMICOLON */ -#line 919 "MachineIndependent/glslang.y" +#line 922 "MachineIndependent/glslang.y" { parseContext.declareBlock((yyvsp[-3].interm).loc, *(yyvsp[-3].interm).typeList, (yyvsp[-2].lex).string, (yyvsp[-1].interm).arraySizes); (yyval.interm.intermNode) = 0; } -#line 6244 "MachineIndependent/glslang_tab.cpp" +#line 6406 "MachineIndependent/glslang_tab.cpp" break; case 102: /* declaration: type_qualifier SEMICOLON */ -#line 923 "MachineIndependent/glslang.y" +#line 926 "MachineIndependent/glslang.y" { parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier); parseContext.updateStandaloneQualifierDefaults((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type)); (yyval.interm.intermNode) = 0; } -#line 6254 "MachineIndependent/glslang_tab.cpp" +#line 6416 "MachineIndependent/glslang_tab.cpp" break; - case 103: /* declaration: type_qualifier IDENTIFIER SEMICOLON */ -#line 928 "MachineIndependent/glslang.y" - { + case 103: /* declaration: type_qualifier identifier_list SEMICOLON */ +#line 931 "MachineIndependent/glslang.y" + { parseContext.checkNoShaderLayouts((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).shaderQualifiers); - parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].lex).string); - (yyval.interm.intermNode) = 0; - } -#line 6264 "MachineIndependent/glslang_tab.cpp" - break; - - case 104: /* declaration: type_qualifier IDENTIFIER identifier_list SEMICOLON */ -#line 933 "MachineIndependent/glslang.y" - { - parseContext.checkNoShaderLayouts((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).shaderQualifiers); - (yyvsp[-1].interm.identifierList)->push_back((yyvsp[-2].lex).string); - parseContext.addQualifierToExisting((yyvsp[-3].interm.type).loc, (yyvsp[-3].interm.type).qualifier, *(yyvsp[-1].interm.identifierList)); + parseContext.addQualifierToExisting((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, *(yyvsp[-1].interm.identifierList)); (yyval.interm.intermNode) = 0; } -#line 6275 "MachineIndependent/glslang_tab.cpp" +#line 6426 "MachineIndependent/glslang_tab.cpp" break; - case 105: /* $@2: %empty */ -#line 942 "MachineIndependent/glslang.y" + case 104: /* $@2: %empty */ +#line 939 "MachineIndependent/glslang.y" { parseContext.nestedBlockCheck((yyvsp[-2].interm.type).loc); } -#line 6281 "MachineIndependent/glslang_tab.cpp" +#line 6432 "MachineIndependent/glslang_tab.cpp" break; - case 106: /* block_structure: type_qualifier IDENTIFIER LEFT_BRACE $@2 struct_declaration_list RIGHT_BRACE */ -#line 942 "MachineIndependent/glslang.y" + case 105: /* block_structure: type_qualifier IDENTIFIER LEFT_BRACE $@2 struct_declaration_list RIGHT_BRACE */ +#line 939 "MachineIndependent/glslang.y" { --parseContext.blockNestingLevel; parseContext.blockName = (yyvsp[-4].lex).string; @@ -6291,39 +6442,39 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).loc = (yyvsp[-5].interm.type).loc; (yyval.interm).typeList = (yyvsp[-1].interm.typeList); } -#line 6295 "MachineIndependent/glslang_tab.cpp" +#line 6446 "MachineIndependent/glslang_tab.cpp" break; - case 107: /* identifier_list: COMMA IDENTIFIER */ -#line 953 "MachineIndependent/glslang.y" - { + case 106: /* identifier_list: IDENTIFIER */ +#line 950 "MachineIndependent/glslang.y" + { (yyval.interm.identifierList) = new TIdentifierList; (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 6304 "MachineIndependent/glslang_tab.cpp" +#line 6455 "MachineIndependent/glslang_tab.cpp" break; - case 108: /* identifier_list: identifier_list COMMA IDENTIFIER */ -#line 957 "MachineIndependent/glslang.y" + case 107: /* identifier_list: identifier_list COMMA IDENTIFIER */ +#line 954 "MachineIndependent/glslang.y" { (yyval.interm.identifierList) = (yyvsp[-2].interm.identifierList); (yyval.interm.identifierList)->push_back((yyvsp[0].lex).string); } -#line 6313 "MachineIndependent/glslang_tab.cpp" +#line 6464 "MachineIndependent/glslang_tab.cpp" break; - case 109: /* function_prototype: function_declarator RIGHT_PAREN */ -#line 964 "MachineIndependent/glslang.y" + case 108: /* function_prototype: function_declarator RIGHT_PAREN */ +#line 961 "MachineIndependent/glslang.y" { (yyval.interm).function = (yyvsp[-1].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); (yyval.interm).loc = (yyvsp[0].lex).loc; } -#line 6323 "MachineIndependent/glslang_tab.cpp" +#line 6474 "MachineIndependent/glslang_tab.cpp" break; - case 110: /* function_prototype: function_declarator RIGHT_PAREN attribute */ -#line 969 "MachineIndependent/glslang.y" + case 109: /* function_prototype: function_declarator RIGHT_PAREN attribute */ +#line 966 "MachineIndependent/glslang.y" { (yyval.interm).function = (yyvsp[-2].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); @@ -6332,11 +6483,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.requireExtensions((yyvsp[-1].lex).loc, 2, extensions, "attribute"); parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[0].interm.attributes)); } -#line 6336 "MachineIndependent/glslang_tab.cpp" +#line 6487 "MachineIndependent/glslang_tab.cpp" break; - case 111: /* function_prototype: attribute function_declarator RIGHT_PAREN */ -#line 977 "MachineIndependent/glslang.y" + case 110: /* function_prototype: attribute function_declarator RIGHT_PAREN */ +#line 974 "MachineIndependent/glslang.y" { (yyval.interm).function = (yyvsp[-1].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); @@ -6345,11 +6496,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.requireExtensions((yyvsp[0].lex).loc, 2, extensions, "attribute"); parseContext.handleFunctionAttributes((yyvsp[0].lex).loc, *(yyvsp[-2].interm.attributes)); } -#line 6349 "MachineIndependent/glslang_tab.cpp" +#line 6500 "MachineIndependent/glslang_tab.cpp" break; - case 112: /* function_prototype: attribute function_declarator RIGHT_PAREN attribute */ -#line 985 "MachineIndependent/glslang.y" + case 111: /* function_prototype: attribute function_declarator RIGHT_PAREN attribute */ +#line 982 "MachineIndependent/glslang.y" { (yyval.interm).function = (yyvsp[-2].interm.function); if (parseContext.compileOnly) (yyval.interm).function->setExport(); @@ -6359,27 +6510,27 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[-3].interm.attributes)); parseContext.handleFunctionAttributes((yyvsp[-1].lex).loc, *(yyvsp[0].interm.attributes)); } -#line 6363 "MachineIndependent/glslang_tab.cpp" +#line 6514 "MachineIndependent/glslang_tab.cpp" break; - case 113: /* function_declarator: function_header */ -#line 997 "MachineIndependent/glslang.y" + case 112: /* function_declarator: function_header */ +#line 994 "MachineIndependent/glslang.y" { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 6371 "MachineIndependent/glslang_tab.cpp" +#line 6522 "MachineIndependent/glslang_tab.cpp" break; - case 114: /* function_declarator: function_header_with_parameters */ -#line 1000 "MachineIndependent/glslang.y" + case 113: /* function_declarator: function_header_with_parameters */ +#line 997 "MachineIndependent/glslang.y" { (yyval.interm.function) = (yyvsp[0].interm.function); } -#line 6379 "MachineIndependent/glslang_tab.cpp" +#line 6530 "MachineIndependent/glslang_tab.cpp" break; - case 115: /* function_header_with_parameters: function_header parameter_declaration */ -#line 1007 "MachineIndependent/glslang.y" + case 114: /* function_header_with_parameters: function_header parameter_declaration */ +#line 1004 "MachineIndependent/glslang.y" { // Add the parameter (yyval.interm.function) = (yyvsp[-1].interm.function); @@ -6393,11 +6544,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else delete (yyvsp[0].interm).param.type; } -#line 6397 "MachineIndependent/glslang_tab.cpp" +#line 6548 "MachineIndependent/glslang_tab.cpp" break; - case 116: /* function_header_with_parameters: function_header_with_parameters COMMA parameter_declaration */ -#line 1020 "MachineIndependent/glslang.y" + case 115: /* function_header_with_parameters: function_header_with_parameters COMMA parameter_declaration */ +#line 1017 "MachineIndependent/glslang.y" { // // Only first parameter of one-parameter functions can be void @@ -6418,11 +6569,20 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.vkRelaxedRemapFunctionParameter((yyvsp[-2].interm.function), (yyvsp[0].interm).param); } } -#line 6422 "MachineIndependent/glslang_tab.cpp" +#line 6573 "MachineIndependent/glslang_tab.cpp" + break; + + case 116: /* function_header_with_parameters: function_header_with_parameters COMMA DOT DOT DOT */ +#line 1037 "MachineIndependent/glslang.y" + { + (yyval.interm.function) = (yyvsp[-4].interm.function); + parseContext.makeVariadic((yyvsp[-4].interm.function), (yyvsp[-2].lex).loc); + } +#line 6582 "MachineIndependent/glslang_tab.cpp" break; case 117: /* function_header: fully_specified_type IDENTIFIER LEFT_PAREN */ -#line 1043 "MachineIndependent/glslang.y" +#line 1044 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.type).qualifier.storage != EvqGlobal && (yyvsp[-2].interm.type).qualifier.storage != EvqTemporary) { parseContext.error((yyvsp[-1].lex).loc, "no qualifiers allowed for function return", @@ -6442,11 +6602,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); function = new TFunction((yyvsp[-1].lex).string, type); (yyval.interm.function) = function; } -#line 6446 "MachineIndependent/glslang_tab.cpp" +#line 6606 "MachineIndependent/glslang_tab.cpp" break; case 118: /* parameter_declarator: type_specifier IDENTIFIER */ -#line 1066 "MachineIndependent/glslang.y" +#line 1067 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-1].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -6462,11 +6622,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).loc = (yyvsp[0].lex).loc; (yyval.interm).param = param; } -#line 6466 "MachineIndependent/glslang_tab.cpp" +#line 6626 "MachineIndependent/glslang_tab.cpp" break; case 119: /* parameter_declarator: type_specifier IDENTIFIER array_specifier */ -#line 1081 "MachineIndependent/glslang.y" +#line 1082 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -6486,173 +6646,183 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).param = param; } -#line 6490 "MachineIndependent/glslang_tab.cpp" +#line 6650 "MachineIndependent/glslang_tab.cpp" + break; + + case 120: /* parameter_declarator: type_specifier IDENTIFIER EQUAL initializer */ +#line 1101 "MachineIndependent/glslang.y" + { + TParameter param = parseContext.getParamWithDefault((yyvsp[-3].interm.type), (yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode), (yyvsp[-1].lex).loc); + (yyval.interm).loc = (yyvsp[-2].lex).loc; + (yyval.interm).param = param; + } +#line 6660 "MachineIndependent/glslang_tab.cpp" break; - case 120: /* parameter_declaration: type_qualifier parameter_declarator */ -#line 1106 "MachineIndependent/glslang.y" + case 121: /* parameter_declaration: type_qualifier parameter_declarator */ +#line 1112 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision; - parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMatOrVec()); + parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->hasTypeParameter()); parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers); parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type); parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); } -#line 6506 "MachineIndependent/glslang_tab.cpp" +#line 6676 "MachineIndependent/glslang_tab.cpp" break; - case 121: /* parameter_declaration: parameter_declarator */ -#line 1117 "MachineIndependent/glslang.y" + case 122: /* parameter_declaration: parameter_declarator */ +#line 1123 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type); parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); - parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMatOrVec()); + parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->hasTypeParameter()); } -#line 6518 "MachineIndependent/glslang_tab.cpp" +#line 6688 "MachineIndependent/glslang_tab.cpp" break; - case 122: /* parameter_declaration: type_qualifier parameter_type_specifier */ -#line 1127 "MachineIndependent/glslang.y" + case 123: /* parameter_declaration: type_qualifier parameter_type_specifier */ +#line 1133 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); if ((yyvsp[-1].interm.type).qualifier.precision != EpqNone) (yyval.interm).param.type->getQualifier().precision = (yyvsp[-1].interm.type).qualifier.precision; - parseContext.precisionQualifierCheck((yyvsp[-1].interm.type).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMatOrVec()); + parseContext.precisionQualifierCheck((yyvsp[-1].interm.type).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->hasTypeParameter()); parseContext.checkNoShaderLayouts((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers); parseContext.parameterTypeCheck((yyvsp[0].interm).loc, (yyvsp[-1].interm.type).qualifier.storage, *(yyval.interm).param.type); parseContext.paramCheckFix((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, *(yyval.interm).param.type); } -#line 6533 "MachineIndependent/glslang_tab.cpp" +#line 6703 "MachineIndependent/glslang_tab.cpp" break; - case 123: /* parameter_declaration: parameter_type_specifier */ -#line 1137 "MachineIndependent/glslang.y" + case 124: /* parameter_declaration: parameter_type_specifier */ +#line 1143 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); parseContext.parameterTypeCheck((yyvsp[0].interm).loc, EvqIn, *(yyvsp[0].interm).param.type); parseContext.paramCheckFixStorage((yyvsp[0].interm).loc, EvqTemporary, *(yyval.interm).param.type); - parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->isCoopMatOrVec()); + parseContext.precisionQualifierCheck((yyval.interm).loc, (yyval.interm).param.type->getBasicType(), (yyval.interm).param.type->getQualifier(), (yyval.interm).param.type->hasTypeParameter()); } -#line 6545 "MachineIndependent/glslang_tab.cpp" +#line 6715 "MachineIndependent/glslang_tab.cpp" break; - case 124: /* parameter_type_specifier: type_specifier */ -#line 1147 "MachineIndependent/glslang.y" + case 125: /* parameter_type_specifier: type_specifier */ +#line 1153 "MachineIndependent/glslang.y" { TParameter param = { 0, new TType((yyvsp[0].interm.type)), {} }; (yyval.interm).param = param; if ((yyvsp[0].interm.type).arraySizes) parseContext.arraySizeRequiredCheck((yyvsp[0].interm.type).loc, *(yyvsp[0].interm.type).arraySizes); } -#line 6556 "MachineIndependent/glslang_tab.cpp" +#line 6726 "MachineIndependent/glslang_tab.cpp" break; - case 125: /* init_declarator_list: single_declaration */ -#line 1156 "MachineIndependent/glslang.y" + case 126: /* init_declarator_list: single_declaration */ +#line 1162 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[0].interm); } -#line 6564 "MachineIndependent/glslang_tab.cpp" +#line 6734 "MachineIndependent/glslang_tab.cpp" break; - case 126: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER */ -#line 1159 "MachineIndependent/glslang.y" + case 127: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER */ +#line 1165 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-2].interm); parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-2].interm).type); } -#line 6573 "MachineIndependent/glslang_tab.cpp" +#line 6743 "MachineIndependent/glslang_tab.cpp" break; - case 127: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier */ -#line 1163 "MachineIndependent/glslang.y" + case 128: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier */ +#line 1169 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-3].interm); parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-3].interm).type, (yyvsp[0].interm).arraySizes); } -#line 6582 "MachineIndependent/glslang_tab.cpp" +#line 6752 "MachineIndependent/glslang_tab.cpp" break; - case 128: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier EQUAL initializer */ -#line 1167 "MachineIndependent/glslang.y" + case 129: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER array_specifier EQUAL initializer */ +#line 1173 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-5].interm).type; TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-5].interm).type, (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-5].interm).intermNode, initNode, (yyvsp[-1].lex).loc); } -#line 6592 "MachineIndependent/glslang_tab.cpp" +#line 6762 "MachineIndependent/glslang_tab.cpp" break; - case 129: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER EQUAL initializer */ -#line 1172 "MachineIndependent/glslang.y" + case 130: /* init_declarator_list: init_declarator_list COMMA IDENTIFIER EQUAL initializer */ +#line 1178 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-4].interm).type; TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-4].interm).type, 0, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate((yyvsp[-4].interm).intermNode, initNode, (yyvsp[-1].lex).loc); } -#line 6602 "MachineIndependent/glslang_tab.cpp" +#line 6772 "MachineIndependent/glslang_tab.cpp" break; - case 130: /* single_declaration: fully_specified_type */ -#line 1180 "MachineIndependent/glslang.y" + case 131: /* single_declaration: fully_specified_type */ +#line 1186 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[0].interm.type); (yyval.interm).intermNode = 0; parseContext.declareTypeDefaults((yyval.interm).loc, (yyval.interm).type); } -#line 6612 "MachineIndependent/glslang_tab.cpp" +#line 6782 "MachineIndependent/glslang_tab.cpp" break; - case 131: /* single_declaration: fully_specified_type IDENTIFIER */ -#line 1185 "MachineIndependent/glslang.y" + case 132: /* single_declaration: fully_specified_type IDENTIFIER */ +#line 1191 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-1].interm.type); (yyval.interm).intermNode = 0; parseContext.declareVariable((yyvsp[0].lex).loc, *(yyvsp[0].lex).string, (yyvsp[-1].interm.type)); } -#line 6622 "MachineIndependent/glslang_tab.cpp" +#line 6792 "MachineIndependent/glslang_tab.cpp" break; - case 132: /* single_declaration: fully_specified_type IDENTIFIER array_specifier */ -#line 1190 "MachineIndependent/glslang.y" + case 133: /* single_declaration: fully_specified_type IDENTIFIER array_specifier */ +#line 1196 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-2].interm.type); (yyval.interm).intermNode = 0; parseContext.declareVariable((yyvsp[-1].lex).loc, *(yyvsp[-1].lex).string, (yyvsp[-2].interm.type), (yyvsp[0].interm).arraySizes); } -#line 6632 "MachineIndependent/glslang_tab.cpp" +#line 6802 "MachineIndependent/glslang_tab.cpp" break; - case 133: /* single_declaration: fully_specified_type IDENTIFIER array_specifier EQUAL initializer */ -#line 1195 "MachineIndependent/glslang.y" + case 134: /* single_declaration: fully_specified_type IDENTIFIER array_specifier EQUAL initializer */ +#line 1201 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-4].interm.type); TIntermNode* initNode = parseContext.declareVariable((yyvsp[-3].lex).loc, *(yyvsp[-3].lex).string, (yyvsp[-4].interm.type), (yyvsp[-2].interm).arraySizes, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); } -#line 6642 "MachineIndependent/glslang_tab.cpp" +#line 6812 "MachineIndependent/glslang_tab.cpp" break; - case 134: /* single_declaration: fully_specified_type IDENTIFIER EQUAL initializer */ -#line 1200 "MachineIndependent/glslang.y" + case 135: /* single_declaration: fully_specified_type IDENTIFIER EQUAL initializer */ +#line 1206 "MachineIndependent/glslang.y" { (yyval.interm).type = (yyvsp[-3].interm.type); TIntermNode* initNode = parseContext.declareVariable((yyvsp[-2].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[-3].interm.type), 0, (yyvsp[0].interm.intermTypedNode)); (yyval.interm).intermNode = parseContext.intermediate.growAggregate(0, initNode, (yyvsp[-1].lex).loc); } -#line 6652 "MachineIndependent/glslang_tab.cpp" +#line 6822 "MachineIndependent/glslang_tab.cpp" break; - case 135: /* fully_specified_type: type_specifier */ -#line 1209 "MachineIndependent/glslang.y" + case 136: /* fully_specified_type: type_specifier */ +#line 1215 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); @@ -6661,13 +6831,13 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.profileRequires((yyvsp[0].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); parseContext.profileRequires((yyvsp[0].interm.type).loc, EEsProfile, 300, 0, "arrayed type"); } - parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier, (yyval.interm.type).isCoopmatOrvec()); + parseContext.precisionQualifierCheck((yyval.interm.type).loc, (yyval.interm.type).basicType, (yyval.interm.type).qualifier, (yyval.interm.type).hasTypeParameter()); } -#line 6667 "MachineIndependent/glslang_tab.cpp" +#line 6837 "MachineIndependent/glslang_tab.cpp" break; - case 136: /* fully_specified_type: type_qualifier type_specifier */ -#line 1219 "MachineIndependent/glslang.y" + case 137: /* fully_specified_type: type_qualifier type_specifier */ +#line 1225 "MachineIndependent/glslang.y" { parseContext.globalQualifierFixCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, false, &(yyvsp[0].interm.type)); parseContext.globalQualifierTypeCheck((yyvsp[-1].interm.type).loc, (yyvsp[-1].interm.type).qualifier, (yyvsp[0].interm.type)); @@ -6683,7 +6853,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.checkNoShaderLayouts((yyvsp[0].interm.type).loc, (yyvsp[-1].interm.type).shaderQualifiers); (yyvsp[0].interm.type).shaderQualifiers.merge((yyvsp[-1].interm.type).shaderQualifiers); parseContext.mergeQualifiers((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier, (yyvsp[-1].interm.type).qualifier, true); - parseContext.precisionQualifierCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).basicType, (yyvsp[0].interm.type).qualifier, (yyvsp[0].interm.type).isCoopmatOrvec()); + parseContext.precisionQualifierCheck((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).basicType, (yyvsp[0].interm.type).qualifier, (yyvsp[0].interm.type).hasTypeParameter()); (yyval.interm.type) = (yyvsp[0].interm.type); @@ -6692,22 +6862,22 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (parseContext.language == EShLangFragment && (yyval.interm.type).qualifier.storage == EvqVaryingIn))) (yyval.interm.type).qualifier.smooth = true; } -#line 6696 "MachineIndependent/glslang_tab.cpp" +#line 6866 "MachineIndependent/glslang_tab.cpp" break; - case 137: /* invariant_qualifier: INVARIANT */ -#line 1246 "MachineIndependent/glslang.y" + case 138: /* invariant_qualifier: INVARIANT */ +#line 1252 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "invariant"); parseContext.profileRequires((yyval.interm.type).loc, ENoProfile, 120, 0, "invariant"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.invariant = true; } -#line 6707 "MachineIndependent/glslang_tab.cpp" +#line 6877 "MachineIndependent/glslang_tab.cpp" break; - case 138: /* interpolation_qualifier: SMOOTH */ -#line 1255 "MachineIndependent/glslang.y" + case 139: /* interpolation_qualifier: SMOOTH */ +#line 1261 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "smooth"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "smooth"); @@ -6715,11 +6885,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.smooth = true; } -#line 6719 "MachineIndependent/glslang_tab.cpp" +#line 6889 "MachineIndependent/glslang_tab.cpp" break; - case 139: /* interpolation_qualifier: FLAT */ -#line 1262 "MachineIndependent/glslang.y" + case 140: /* interpolation_qualifier: FLAT */ +#line 1268 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "flat"); parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "flat"); @@ -6727,11 +6897,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.flat = true; } -#line 6731 "MachineIndependent/glslang_tab.cpp" +#line 6901 "MachineIndependent/glslang_tab.cpp" break; - case 140: /* interpolation_qualifier: NOPERSPECTIVE */ -#line 1269 "MachineIndependent/glslang.y" + case 141: /* interpolation_qualifier: NOPERSPECTIVE */ +#line 1275 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "noperspective"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 0, E_GL_NV_shader_noperspective_interpolation, "noperspective"); @@ -6739,11 +6909,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nopersp = true; } -#line 6743 "MachineIndependent/glslang_tab.cpp" +#line 6913 "MachineIndependent/glslang_tab.cpp" break; - case 141: /* interpolation_qualifier: EXPLICITINTERPAMD */ -#line 1276 "MachineIndependent/glslang.y" + case 142: /* interpolation_qualifier: EXPLICITINTERPAMD */ +#line 1282 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "__explicitInterpAMD"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 450, E_GL_AMD_shader_explicit_vertex_parameter, "explicit interpolation"); @@ -6751,11 +6921,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.explicitInterp = true; } -#line 6755 "MachineIndependent/glslang_tab.cpp" +#line 6925 "MachineIndependent/glslang_tab.cpp" break; - case 142: /* interpolation_qualifier: PERVERTEXNV */ -#line 1283 "MachineIndependent/glslang.y" + case 143: /* interpolation_qualifier: PERVERTEXNV */ +#line 1289 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexNV"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_NV_fragment_shader_barycentric, "fragment shader barycentric"); @@ -6764,11 +6934,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.pervertexNV = true; } -#line 6768 "MachineIndependent/glslang_tab.cpp" +#line 6938 "MachineIndependent/glslang_tab.cpp" break; - case 143: /* interpolation_qualifier: PERVERTEXEXT */ -#line 1291 "MachineIndependent/glslang.y" + case 144: /* interpolation_qualifier: PERVERTEXEXT */ +#line 1297 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "pervertexEXT"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile, 0, E_GL_EXT_fragment_shader_barycentric, "fragment shader barycentric"); @@ -6777,11 +6947,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.pervertexEXT = true; } -#line 6781 "MachineIndependent/glslang_tab.cpp" +#line 6951 "MachineIndependent/glslang_tab.cpp" break; - case 144: /* interpolation_qualifier: PERPRIMITIVENV */ -#line 1299 "MachineIndependent/glslang.y" + case 145: /* interpolation_qualifier: PERPRIMITIVENV */ +#line 1305 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveNV"); @@ -6792,11 +6962,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perPrimitiveNV = true; } -#line 6796 "MachineIndependent/glslang_tab.cpp" +#line 6966 "MachineIndependent/glslang_tab.cpp" break; - case 145: /* interpolation_qualifier: PERPRIMITIVEEXT */ -#line 1309 "MachineIndependent/glslang.y" + case 146: /* interpolation_qualifier: PERPRIMITIVEEXT */ +#line 1315 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perprimitiveEXT"); @@ -6807,11 +6977,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perPrimitiveNV = true; } -#line 6811 "MachineIndependent/glslang_tab.cpp" +#line 6981 "MachineIndependent/glslang_tab.cpp" break; - case 146: /* interpolation_qualifier: PERVIEWNV */ -#line 1319 "MachineIndependent/glslang.y" + case 147: /* interpolation_qualifier: PERVIEWNV */ +#line 1325 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "perviewNV"); @@ -6819,11 +6989,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perViewNV = true; } -#line 6823 "MachineIndependent/glslang_tab.cpp" +#line 6993 "MachineIndependent/glslang_tab.cpp" break; - case 147: /* interpolation_qualifier: PERTASKNV */ -#line 1326 "MachineIndependent/glslang.y" + case 148: /* interpolation_qualifier: PERTASKNV */ +#line 1332 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "taskNV"); @@ -6831,84 +7001,84 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.perTaskNV = true; } -#line 6835 "MachineIndependent/glslang_tab.cpp" +#line 7005 "MachineIndependent/glslang_tab.cpp" break; - case 148: /* layout_qualifier: LAYOUT LEFT_PAREN layout_qualifier_id_list RIGHT_PAREN */ -#line 1336 "MachineIndependent/glslang.y" + case 149: /* layout_qualifier: LAYOUT LEFT_PAREN layout_qualifier_id_list RIGHT_PAREN */ +#line 1342 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-1].interm.type); } -#line 6843 "MachineIndependent/glslang_tab.cpp" +#line 7013 "MachineIndependent/glslang_tab.cpp" break; - case 149: /* layout_qualifier_id_list: layout_qualifier_id */ -#line 1342 "MachineIndependent/glslang.y" + case 150: /* layout_qualifier_id_list: layout_qualifier_id */ +#line 1348 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6851 "MachineIndependent/glslang_tab.cpp" +#line 7021 "MachineIndependent/glslang_tab.cpp" break; - case 150: /* layout_qualifier_id_list: layout_qualifier_id_list COMMA layout_qualifier_id */ -#line 1345 "MachineIndependent/glslang.y" + case 151: /* layout_qualifier_id_list: layout_qualifier_id_list COMMA layout_qualifier_id */ +#line 1351 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-2].interm.type); (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); parseContext.mergeObjectLayoutQualifiers((yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); } -#line 6861 "MachineIndependent/glslang_tab.cpp" +#line 7031 "MachineIndependent/glslang_tab.cpp" break; - case 151: /* layout_qualifier_id: IDENTIFIER */ -#line 1352 "MachineIndependent/glslang.y" + case 152: /* layout_qualifier_id: IDENTIFIER */ +#line 1358 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), *(yyvsp[0].lex).string); } -#line 6870 "MachineIndependent/glslang_tab.cpp" +#line 7040 "MachineIndependent/glslang_tab.cpp" break; - case 152: /* layout_qualifier_id: IDENTIFIER EQUAL constant_expression */ -#line 1356 "MachineIndependent/glslang.y" + case 153: /* layout_qualifier_id: IDENTIFIER EQUAL constant_expression */ +#line 1362 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-2].lex).loc); parseContext.setLayoutQualifier((yyvsp[-2].lex).loc, (yyval.interm.type), *(yyvsp[-2].lex).string, (yyvsp[0].interm.intermTypedNode)); } -#line 6879 "MachineIndependent/glslang_tab.cpp" +#line 7049 "MachineIndependent/glslang_tab.cpp" break; - case 153: /* layout_qualifier_id: SHARED */ -#line 1360 "MachineIndependent/glslang.y" + case 154: /* layout_qualifier_id: SHARED */ +#line 1366 "MachineIndependent/glslang.y" { // because "shared" is both an identifier and a keyword (yyval.interm.type).init((yyvsp[0].lex).loc); TString strShared("shared"); parseContext.setLayoutQualifier((yyvsp[0].lex).loc, (yyval.interm.type), strShared); } -#line 6889 "MachineIndependent/glslang_tab.cpp" +#line 7059 "MachineIndependent/glslang_tab.cpp" break; - case 154: /* precise_qualifier: PRECISE */ -#line 1368 "MachineIndependent/glslang.y" + case 155: /* precise_qualifier: PRECISE */ +#line 1374 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyval.interm.type).loc, ECoreProfile | ECompatibilityProfile, 400, E_GL_ARB_gpu_shader5, "precise"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 320, Num_AEP_gpu_shader5, AEP_gpu_shader5, "precise"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.noContraction = true; } -#line 6900 "MachineIndependent/glslang_tab.cpp" +#line 7070 "MachineIndependent/glslang_tab.cpp" break; - case 155: /* type_qualifier: single_type_qualifier */ -#line 1377 "MachineIndependent/glslang.y" + case 156: /* type_qualifier: single_type_qualifier */ +#line 1383 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6908 "MachineIndependent/glslang_tab.cpp" +#line 7078 "MachineIndependent/glslang_tab.cpp" break; - case 156: /* type_qualifier: type_qualifier single_type_qualifier */ -#line 1380 "MachineIndependent/glslang.y" + case 157: /* type_qualifier: type_qualifier single_type_qualifier */ +#line 1386 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-1].interm.type); if ((yyval.interm.type).basicType == EbtVoid) @@ -6917,151 +7087,151 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).shaderQualifiers.merge((yyvsp[0].interm.type).shaderQualifiers); parseContext.mergeQualifiers((yyval.interm.type).loc, (yyval.interm.type).qualifier, (yyvsp[0].interm.type).qualifier, false); } -#line 6921 "MachineIndependent/glslang_tab.cpp" +#line 7091 "MachineIndependent/glslang_tab.cpp" break; - case 157: /* single_type_qualifier: storage_qualifier */ -#line 1391 "MachineIndependent/glslang.y" + case 158: /* single_type_qualifier: storage_qualifier */ +#line 1397 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6929 "MachineIndependent/glslang_tab.cpp" +#line 7099 "MachineIndependent/glslang_tab.cpp" break; - case 158: /* single_type_qualifier: layout_qualifier */ -#line 1394 "MachineIndependent/glslang.y" + case 159: /* single_type_qualifier: layout_qualifier */ +#line 1400 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6937 "MachineIndependent/glslang_tab.cpp" +#line 7107 "MachineIndependent/glslang_tab.cpp" break; - case 159: /* single_type_qualifier: precision_qualifier */ -#line 1397 "MachineIndependent/glslang.y" + case 160: /* single_type_qualifier: precision_qualifier */ +#line 1403 "MachineIndependent/glslang.y" { parseContext.checkPrecisionQualifier((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type).qualifier.precision); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6946 "MachineIndependent/glslang_tab.cpp" +#line 7116 "MachineIndependent/glslang_tab.cpp" break; - case 160: /* single_type_qualifier: interpolation_qualifier */ -#line 1401 "MachineIndependent/glslang.y" + case 161: /* single_type_qualifier: interpolation_qualifier */ +#line 1407 "MachineIndependent/glslang.y" { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6955 "MachineIndependent/glslang_tab.cpp" +#line 7125 "MachineIndependent/glslang_tab.cpp" break; - case 161: /* single_type_qualifier: invariant_qualifier */ -#line 1405 "MachineIndependent/glslang.y" + case 162: /* single_type_qualifier: invariant_qualifier */ +#line 1411 "MachineIndependent/glslang.y" { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6964 "MachineIndependent/glslang_tab.cpp" +#line 7134 "MachineIndependent/glslang_tab.cpp" break; - case 162: /* single_type_qualifier: precise_qualifier */ -#line 1409 "MachineIndependent/glslang.y" + case 163: /* single_type_qualifier: precise_qualifier */ +#line 1415 "MachineIndependent/glslang.y" { // allow inheritance of storage qualifier from block declaration (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6973 "MachineIndependent/glslang_tab.cpp" +#line 7143 "MachineIndependent/glslang_tab.cpp" break; - case 163: /* single_type_qualifier: non_uniform_qualifier */ -#line 1413 "MachineIndependent/glslang.y" + case 164: /* single_type_qualifier: non_uniform_qualifier */ +#line 1419 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6981 "MachineIndependent/glslang_tab.cpp" +#line 7151 "MachineIndependent/glslang_tab.cpp" break; - case 164: /* single_type_qualifier: spirv_storage_class_qualifier */ -#line 1416 "MachineIndependent/glslang.y" + case 165: /* single_type_qualifier: spirv_storage_class_qualifier */ +#line 1422 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].interm.type).loc, "spirv_storage_class"); parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V storage class qualifier"); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 6991 "MachineIndependent/glslang_tab.cpp" +#line 7161 "MachineIndependent/glslang_tab.cpp" break; - case 165: /* single_type_qualifier: spirv_decorate_qualifier */ -#line 1421 "MachineIndependent/glslang.y" + case 166: /* single_type_qualifier: spirv_decorate_qualifier */ +#line 1427 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V decorate qualifier"); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 7000 "MachineIndependent/glslang_tab.cpp" +#line 7170 "MachineIndependent/glslang_tab.cpp" break; - case 166: /* single_type_qualifier: SPIRV_BY_REFERENCE */ -#line 1425 "MachineIndependent/glslang.y" + case 167: /* single_type_qualifier: SPIRV_BY_REFERENCE */ +#line 1431 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_reference"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.setSpirvByReference(); } -#line 7010 "MachineIndependent/glslang_tab.cpp" +#line 7180 "MachineIndependent/glslang_tab.cpp" break; - case 167: /* single_type_qualifier: SPIRV_LITERAL */ -#line 1430 "MachineIndependent/glslang.y" + case 168: /* single_type_qualifier: SPIRV_LITERAL */ +#line 1436 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_spirv_intrinsics, "spirv_by_literal"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.setSpirvLiteral(); } -#line 7020 "MachineIndependent/glslang_tab.cpp" +#line 7190 "MachineIndependent/glslang_tab.cpp" break; - case 168: /* storage_qualifier: CONST */ -#line 1438 "MachineIndependent/glslang.y" + case 169: /* storage_qualifier: CONST */ +#line 1444 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqConst; // will later turn into EvqConstReadOnly, if the initializer is not constant } -#line 7029 "MachineIndependent/glslang_tab.cpp" +#line 7199 "MachineIndependent/glslang_tab.cpp" break; - case 169: /* storage_qualifier: INOUT */ -#line 1442 "MachineIndependent/glslang.y" + case 170: /* storage_qualifier: INOUT */ +#line 1448 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "inout"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqInOut; } -#line 7039 "MachineIndependent/glslang_tab.cpp" +#line 7209 "MachineIndependent/glslang_tab.cpp" break; - case 170: /* storage_qualifier: IN */ -#line 1447 "MachineIndependent/glslang.y" + case 171: /* storage_qualifier: IN */ +#line 1453 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "in"); (yyval.interm.type).init((yyvsp[0].lex).loc); // whether this is a parameter "in" or a pipeline "in" will get sorted out a bit later (yyval.interm.type).qualifier.storage = EvqIn; } -#line 7050 "MachineIndependent/glslang_tab.cpp" +#line 7220 "MachineIndependent/glslang_tab.cpp" break; - case 171: /* storage_qualifier: OUT */ -#line 1453 "MachineIndependent/glslang.y" + case 172: /* storage_qualifier: OUT */ +#line 1459 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "out"); (yyval.interm.type).init((yyvsp[0].lex).loc); // whether this is a parameter "out" or a pipeline "out" will get sorted out a bit later (yyval.interm.type).qualifier.storage = EvqOut; } -#line 7061 "MachineIndependent/glslang_tab.cpp" +#line 7231 "MachineIndependent/glslang_tab.cpp" break; - case 172: /* storage_qualifier: CENTROID */ -#line 1459 "MachineIndependent/glslang.y" + case 173: /* storage_qualifier: CENTROID */ +#line 1465 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 120, 0, "centroid"); parseContext.profileRequires((yyvsp[0].lex).loc, EEsProfile, 300, 0, "centroid"); @@ -7069,31 +7239,31 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.centroid = true; } -#line 7073 "MachineIndependent/glslang_tab.cpp" +#line 7243 "MachineIndependent/glslang_tab.cpp" break; - case 173: /* storage_qualifier: UNIFORM */ -#line 1466 "MachineIndependent/glslang.y" + case 174: /* storage_qualifier: UNIFORM */ +#line 1472 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "uniform"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqUniform; } -#line 7083 "MachineIndependent/glslang_tab.cpp" +#line 7253 "MachineIndependent/glslang_tab.cpp" break; - case 174: /* storage_qualifier: TILEIMAGEEXT */ -#line 1471 "MachineIndependent/glslang.y" + case 175: /* storage_qualifier: TILEIMAGEEXT */ +#line 1477 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "tileImageEXT"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqTileImageEXT; } -#line 7093 "MachineIndependent/glslang_tab.cpp" +#line 7263 "MachineIndependent/glslang_tab.cpp" break; - case 175: /* storage_qualifier: SHARED */ -#line 1476 "MachineIndependent/glslang.y" + case 176: /* storage_qualifier: SHARED */ +#line 1482 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "shared"); parseContext.profileRequires((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_compute_shader, "shared"); @@ -7102,21 +7272,21 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqShared; } -#line 7106 "MachineIndependent/glslang_tab.cpp" +#line 7276 "MachineIndependent/glslang_tab.cpp" break; - case 176: /* storage_qualifier: BUFFER */ -#line 1484 "MachineIndependent/glslang.y" + case 177: /* storage_qualifier: BUFFER */ +#line 1490 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "buffer"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqBuffer; } -#line 7116 "MachineIndependent/glslang_tab.cpp" +#line 7286 "MachineIndependent/glslang_tab.cpp" break; - case 177: /* storage_qualifier: ATTRIBUTE */ -#line 1489 "MachineIndependent/glslang.y" + case 178: /* storage_qualifier: ATTRIBUTE */ +#line 1495 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangVertex, "attribute"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "attribute"); @@ -7129,11 +7299,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 7133 "MachineIndependent/glslang_tab.cpp" +#line 7303 "MachineIndependent/glslang_tab.cpp" break; - case 178: /* storage_qualifier: VARYING */ -#line 1501 "MachineIndependent/glslang.y" + case 179: /* storage_qualifier: VARYING */ +#line 1507 "MachineIndependent/glslang.y" { parseContext.checkDeprecated((yyvsp[0].lex).loc, ENoProfile, 130, "varying"); parseContext.checkDeprecated((yyvsp[0].lex).loc, ECoreProfile, 130, "varying"); @@ -7148,32 +7318,32 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.interm.type).qualifier.storage = EvqVaryingIn; } -#line 7152 "MachineIndependent/glslang_tab.cpp" +#line 7322 "MachineIndependent/glslang_tab.cpp" break; - case 179: /* storage_qualifier: PATCH */ -#line 1515 "MachineIndependent/glslang.y" + case 180: /* storage_qualifier: PATCH */ +#line 1521 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "patch"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangTessControlMask | EShLangTessEvaluationMask), "patch"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.patch = true; } -#line 7163 "MachineIndependent/glslang_tab.cpp" +#line 7333 "MachineIndependent/glslang_tab.cpp" break; - case 180: /* storage_qualifier: SAMPLE */ -#line 1521 "MachineIndependent/glslang.y" + case 181: /* storage_qualifier: SAMPLE */ +#line 1527 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "sample"); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.sample = true; } -#line 7173 "MachineIndependent/glslang_tab.cpp" +#line 7343 "MachineIndependent/glslang_tab.cpp" break; - case 181: /* storage_qualifier: HITATTRNV */ -#line 1526 "MachineIndependent/glslang.y" + case 182: /* storage_qualifier: HITATTRNV */ +#line 1532 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask @@ -7182,11 +7352,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitAttr; } -#line 7186 "MachineIndependent/glslang_tab.cpp" +#line 7356 "MachineIndependent/glslang_tab.cpp" break; - case 182: /* storage_qualifier: HITOBJECTATTRNV */ -#line 1534 "MachineIndependent/glslang.y" + case 183: /* storage_qualifier: HITOBJECTATTRNV */ +#line 1540 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask @@ -7195,11 +7365,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitObjectAttrNV; } -#line 7199 "MachineIndependent/glslang_tab.cpp" +#line 7369 "MachineIndependent/glslang_tab.cpp" break; - case 183: /* storage_qualifier: HITATTREXT */ -#line 1542 "MachineIndependent/glslang.y" + case 184: /* storage_qualifier: HITATTREXT */ +#line 1548 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "hitAttributeEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask @@ -7208,11 +7378,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqHitAttr; } -#line 7212 "MachineIndependent/glslang_tab.cpp" +#line 7382 "MachineIndependent/glslang_tab.cpp" break; - case 184: /* storage_qualifier: PAYLOADNV */ -#line 1550 "MachineIndependent/glslang.y" + case 185: /* storage_qualifier: PAYLOADNV */ +#line 1556 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask | @@ -7221,11 +7391,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayload; } -#line 7225 "MachineIndependent/glslang_tab.cpp" +#line 7395 "MachineIndependent/glslang_tab.cpp" break; - case 185: /* storage_qualifier: PAYLOADEXT */ -#line 1558 "MachineIndependent/glslang.y" + case 186: /* storage_qualifier: PAYLOADEXT */ +#line 1564 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask | @@ -7234,11 +7404,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayload; } -#line 7238 "MachineIndependent/glslang_tab.cpp" +#line 7408 "MachineIndependent/glslang_tab.cpp" break; - case 186: /* storage_qualifier: PAYLOADINNV */ -#line 1566 "MachineIndependent/glslang.y" + case 187: /* storage_qualifier: PAYLOADINNV */ +#line 1572 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask | @@ -7247,11 +7417,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayloadIn; } -#line 7251 "MachineIndependent/glslang_tab.cpp" +#line 7421 "MachineIndependent/glslang_tab.cpp" break; - case 187: /* storage_qualifier: PAYLOADINEXT */ -#line 1574 "MachineIndependent/glslang.y" + case 188: /* storage_qualifier: PAYLOADINEXT */ +#line 1580 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "rayPayloadInEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangClosestHitMask | @@ -7260,11 +7430,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqPayloadIn; } -#line 7264 "MachineIndependent/glslang_tab.cpp" +#line 7434 "MachineIndependent/glslang_tab.cpp" break; - case 188: /* storage_qualifier: CALLDATANV */ -#line 1582 "MachineIndependent/glslang.y" + case 189: /* storage_qualifier: CALLDATANV */ +#line 1588 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | @@ -7273,11 +7443,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableData; } -#line 7277 "MachineIndependent/glslang_tab.cpp" +#line 7447 "MachineIndependent/glslang_tab.cpp" break; - case 189: /* storage_qualifier: CALLDATAEXT */ -#line 1590 "MachineIndependent/glslang.y" + case 190: /* storage_qualifier: CALLDATAEXT */ +#line 1596 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangRayGenMask | @@ -7286,11 +7456,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableData; } -#line 7290 "MachineIndependent/glslang_tab.cpp" +#line 7460 "MachineIndependent/glslang_tab.cpp" break; - case 190: /* storage_qualifier: CALLDATAINNV */ -#line 1598 "MachineIndependent/glslang.y" + case 191: /* storage_qualifier: CALLDATAINNV */ +#line 1604 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInNV"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInNV"); @@ -7298,11 +7468,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableDataIn; } -#line 7302 "MachineIndependent/glslang_tab.cpp" +#line 7472 "MachineIndependent/glslang_tab.cpp" break; - case 191: /* storage_qualifier: CALLDATAINEXT */ -#line 1605 "MachineIndependent/glslang.y" + case 192: /* storage_qualifier: CALLDATAINEXT */ +#line 1611 "MachineIndependent/glslang.y" { parseContext.globalCheck((yyvsp[0].lex).loc, "callableDataInEXT"); parseContext.requireStage((yyvsp[0].lex).loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInEXT"); @@ -7310,147 +7480,147 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqCallableDataIn; } -#line 7314 "MachineIndependent/glslang_tab.cpp" +#line 7484 "MachineIndependent/glslang_tab.cpp" break; - case 192: /* storage_qualifier: COHERENT */ -#line 1612 "MachineIndependent/glslang.y" + case 193: /* storage_qualifier: COHERENT */ +#line 1618 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.coherent = true; } -#line 7323 "MachineIndependent/glslang_tab.cpp" +#line 7493 "MachineIndependent/glslang_tab.cpp" break; - case 193: /* storage_qualifier: DEVICECOHERENT */ -#line 1616 "MachineIndependent/glslang.y" + case 194: /* storage_qualifier: DEVICECOHERENT */ +#line 1622 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "devicecoherent"); (yyval.interm.type).qualifier.devicecoherent = true; } -#line 7333 "MachineIndependent/glslang_tab.cpp" +#line 7503 "MachineIndependent/glslang_tab.cpp" break; - case 194: /* storage_qualifier: QUEUEFAMILYCOHERENT */ -#line 1621 "MachineIndependent/glslang.y" + case 195: /* storage_qualifier: QUEUEFAMILYCOHERENT */ +#line 1627 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "queuefamilycoherent"); (yyval.interm.type).qualifier.queuefamilycoherent = true; } -#line 7343 "MachineIndependent/glslang_tab.cpp" +#line 7513 "MachineIndependent/glslang_tab.cpp" break; - case 195: /* storage_qualifier: WORKGROUPCOHERENT */ -#line 1626 "MachineIndependent/glslang.y" + case 196: /* storage_qualifier: WORKGROUPCOHERENT */ +#line 1632 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "workgroupcoherent"); (yyval.interm.type).qualifier.workgroupcoherent = true; } -#line 7353 "MachineIndependent/glslang_tab.cpp" +#line 7523 "MachineIndependent/glslang_tab.cpp" break; - case 196: /* storage_qualifier: SUBGROUPCOHERENT */ -#line 1631 "MachineIndependent/glslang.y" + case 197: /* storage_qualifier: SUBGROUPCOHERENT */ +#line 1637 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "subgroupcoherent"); (yyval.interm.type).qualifier.subgroupcoherent = true; } -#line 7363 "MachineIndependent/glslang_tab.cpp" +#line 7533 "MachineIndependent/glslang_tab.cpp" break; - case 197: /* storage_qualifier: NONPRIVATE */ -#line 1636 "MachineIndependent/glslang.y" + case 198: /* storage_qualifier: NONPRIVATE */ +#line 1642 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_KHR_memory_scope_semantics, "nonprivate"); (yyval.interm.type).qualifier.nonprivate = true; } -#line 7373 "MachineIndependent/glslang_tab.cpp" +#line 7543 "MachineIndependent/glslang_tab.cpp" break; - case 198: /* storage_qualifier: SHADERCALLCOHERENT */ -#line 1641 "MachineIndependent/glslang.y" + case 199: /* storage_qualifier: SHADERCALLCOHERENT */ +#line 1647 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); parseContext.requireExtensions((yyvsp[0].lex).loc, 1, &E_GL_EXT_ray_tracing, "shadercallcoherent"); (yyval.interm.type).qualifier.shadercallcoherent = true; } -#line 7383 "MachineIndependent/glslang_tab.cpp" +#line 7553 "MachineIndependent/glslang_tab.cpp" break; - case 199: /* storage_qualifier: VOLATILE */ -#line 1646 "MachineIndependent/glslang.y" + case 200: /* storage_qualifier: VOLATILE */ +#line 1652 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.volatil = true; } -#line 7392 "MachineIndependent/glslang_tab.cpp" +#line 7562 "MachineIndependent/glslang_tab.cpp" break; - case 200: /* storage_qualifier: RESTRICT */ -#line 1650 "MachineIndependent/glslang.y" + case 201: /* storage_qualifier: RESTRICT */ +#line 1656 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.restrict = true; } -#line 7401 "MachineIndependent/glslang_tab.cpp" +#line 7571 "MachineIndependent/glslang_tab.cpp" break; - case 201: /* storage_qualifier: READONLY */ -#line 1654 "MachineIndependent/glslang.y" + case 202: /* storage_qualifier: READONLY */ +#line 1660 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.readonly = true; } -#line 7410 "MachineIndependent/glslang_tab.cpp" +#line 7580 "MachineIndependent/glslang_tab.cpp" break; - case 202: /* storage_qualifier: WRITEONLY */ -#line 1658 "MachineIndependent/glslang.y" + case 203: /* storage_qualifier: WRITEONLY */ +#line 1664 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.writeonly = true; } -#line 7419 "MachineIndependent/glslang_tab.cpp" +#line 7589 "MachineIndependent/glslang_tab.cpp" break; - case 203: /* storage_qualifier: NONTEMPORAL */ -#line 1662 "MachineIndependent/glslang.y" + case 204: /* storage_qualifier: NONTEMPORAL */ +#line 1668 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nontemporal = true; } -#line 7428 "MachineIndependent/glslang_tab.cpp" +#line 7598 "MachineIndependent/glslang_tab.cpp" break; - case 204: /* storage_qualifier: SUBROUTINE */ -#line 1666 "MachineIndependent/glslang.y" + case 205: /* storage_qualifier: SUBROUTINE */ +#line 1672 "MachineIndependent/glslang.y" { parseContext.spvRemoved((yyvsp[0].lex).loc, "subroutine"); parseContext.globalCheck((yyvsp[0].lex).loc, "subroutine"); parseContext.unimplemented((yyvsp[0].lex).loc, "subroutine"); (yyval.interm.type).init((yyvsp[0].lex).loc); } -#line 7439 "MachineIndependent/glslang_tab.cpp" +#line 7609 "MachineIndependent/glslang_tab.cpp" break; - case 205: /* storage_qualifier: SUBROUTINE LEFT_PAREN type_name_list RIGHT_PAREN */ -#line 1672 "MachineIndependent/glslang.y" + case 206: /* storage_qualifier: SUBROUTINE LEFT_PAREN type_name_list RIGHT_PAREN */ +#line 1678 "MachineIndependent/glslang.y" { parseContext.spvRemoved((yyvsp[-3].lex).loc, "subroutine"); parseContext.globalCheck((yyvsp[-3].lex).loc, "subroutine"); parseContext.unimplemented((yyvsp[-3].lex).loc, "subroutine"); (yyval.interm.type).init((yyvsp[-3].lex).loc); } -#line 7450 "MachineIndependent/glslang_tab.cpp" +#line 7620 "MachineIndependent/glslang_tab.cpp" break; - case 206: /* storage_qualifier: TASKPAYLOADWORKGROUPEXT */ -#line 1678 "MachineIndependent/glslang.y" + case 207: /* storage_qualifier: TASKPAYLOADWORKGROUPEXT */ +#line 1684 "MachineIndependent/glslang.y" { // No need for profile version or extension check. Shader stage already checks both. parseContext.globalCheck((yyvsp[0].lex).loc, "taskPayloadSharedEXT"); @@ -7458,38 +7628,38 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.storage = EvqtaskPayloadSharedEXT; } -#line 7462 "MachineIndependent/glslang_tab.cpp" +#line 7632 "MachineIndependent/glslang_tab.cpp" break; - case 207: /* non_uniform_qualifier: NONUNIFORM */ -#line 1688 "MachineIndependent/glslang.y" + case 208: /* non_uniform_qualifier: NONUNIFORM */ +#line 1694 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).qualifier.nonUniform = true; } -#line 7471 "MachineIndependent/glslang_tab.cpp" +#line 7641 "MachineIndependent/glslang_tab.cpp" break; - case 208: /* type_name_list: IDENTIFIER */ -#line 1695 "MachineIndependent/glslang.y" + case 209: /* type_name_list: IDENTIFIER */ +#line 1701 "MachineIndependent/glslang.y" { // TODO } -#line 7479 "MachineIndependent/glslang_tab.cpp" +#line 7649 "MachineIndependent/glslang_tab.cpp" break; - case 209: /* type_name_list: type_name_list COMMA IDENTIFIER */ -#line 1698 "MachineIndependent/glslang.y" + case 210: /* type_name_list: type_name_list COMMA IDENTIFIER */ +#line 1704 "MachineIndependent/glslang.y" { // TODO: 4.0 semantics: subroutines // 1) make sure each identifier is a type declared earlier with SUBROUTINE // 2) save all of the identifiers for future comparison with the declared function } -#line 7489 "MachineIndependent/glslang_tab.cpp" +#line 7659 "MachineIndependent/glslang_tab.cpp" break; - case 210: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt */ -#line 1706 "MachineIndependent/glslang.y" + case 211: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt */ +#line 1712 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[-1].interm.type); (yyval.interm.type).qualifier.precision = parseContext.getDefaultPrecision((yyval.interm.type)); @@ -7497,11 +7667,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.typeParametersCheck((yyvsp[-1].interm.type).loc, (yyval.interm.type)); } -#line 7501 "MachineIndependent/glslang_tab.cpp" +#line 7671 "MachineIndependent/glslang_tab.cpp" break; - case 211: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt array_specifier */ -#line 1713 "MachineIndependent/glslang.y" + case 212: /* type_specifier: type_specifier_nonarray type_parameter_specifier_opt array_specifier */ +#line 1719 "MachineIndependent/glslang.y" { parseContext.arrayOfArrayVersionCheck((yyvsp[0].interm).loc, (yyvsp[0].interm).arraySizes); (yyval.interm.type) = (yyvsp[-2].interm.type); @@ -7510,21 +7680,21 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).arraySizes = (yyvsp[0].interm).arraySizes; parseContext.typeParametersCheck((yyvsp[-2].interm.type).loc, (yyval.interm.type)); } -#line 7514 "MachineIndependent/glslang_tab.cpp" +#line 7684 "MachineIndependent/glslang_tab.cpp" break; - case 212: /* array_specifier: LEFT_BRACKET RIGHT_BRACKET */ -#line 1724 "MachineIndependent/glslang.y" + case 213: /* array_specifier: LEFT_BRACKET RIGHT_BRACKET */ +#line 1730 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[-1].lex).loc; (yyval.interm).arraySizes = new TArraySizes; (yyval.interm).arraySizes->addInnerSize(); } -#line 7524 "MachineIndependent/glslang_tab.cpp" +#line 7694 "MachineIndependent/glslang_tab.cpp" break; - case 213: /* array_specifier: LEFT_BRACKET conditional_expression RIGHT_BRACKET */ -#line 1729 "MachineIndependent/glslang.y" + case 214: /* array_specifier: LEFT_BRACKET conditional_expression RIGHT_BRACKET */ +#line 1735 "MachineIndependent/glslang.y" { (yyval.interm).loc = (yyvsp[-2].lex).loc; (yyval.interm).arraySizes = new TArraySizes; @@ -7533,20 +7703,20 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size"); (yyval.interm).arraySizes->addInnerSize(size); } -#line 7537 "MachineIndependent/glslang_tab.cpp" +#line 7707 "MachineIndependent/glslang_tab.cpp" break; - case 214: /* array_specifier: array_specifier LEFT_BRACKET RIGHT_BRACKET */ -#line 1737 "MachineIndependent/glslang.y" + case 215: /* array_specifier: array_specifier LEFT_BRACKET RIGHT_BRACKET */ +#line 1743 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-2].interm); (yyval.interm).arraySizes->addInnerSize(); } -#line 7546 "MachineIndependent/glslang_tab.cpp" +#line 7716 "MachineIndependent/glslang_tab.cpp" break; - case 215: /* array_specifier: array_specifier LEFT_BRACKET conditional_expression RIGHT_BRACKET */ -#line 1741 "MachineIndependent/glslang.y" + case 216: /* array_specifier: array_specifier LEFT_BRACKET conditional_expression RIGHT_BRACKET */ +#line 1747 "MachineIndependent/glslang.y" { (yyval.interm) = (yyvsp[-3].interm); @@ -7554,46 +7724,46 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.arraySizeCheck((yyvsp[-1].interm.intermTypedNode)->getLoc(), (yyvsp[-1].interm.intermTypedNode), size, "array size"); (yyval.interm).arraySizes->addInnerSize(size); } -#line 7558 "MachineIndependent/glslang_tab.cpp" +#line 7728 "MachineIndependent/glslang_tab.cpp" break; - case 216: /* type_parameter_specifier_opt: type_parameter_specifier */ -#line 1751 "MachineIndependent/glslang.y" + case 217: /* type_parameter_specifier_opt: type_parameter_specifier */ +#line 1757 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = (yyvsp[0].interm.typeParameters); } -#line 7566 "MachineIndependent/glslang_tab.cpp" +#line 7736 "MachineIndependent/glslang_tab.cpp" break; - case 217: /* type_parameter_specifier_opt: %empty */ -#line 1754 "MachineIndependent/glslang.y" + case 218: /* type_parameter_specifier_opt: %empty */ +#line 1760 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = 0; } -#line 7574 "MachineIndependent/glslang_tab.cpp" +#line 7744 "MachineIndependent/glslang_tab.cpp" break; - case 218: /* type_parameter_specifier: LEFT_ANGLE type_parameter_specifier_list RIGHT_ANGLE */ -#line 1760 "MachineIndependent/glslang.y" + case 219: /* type_parameter_specifier: LEFT_ANGLE type_parameter_specifier_list RIGHT_ANGLE */ +#line 1766 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = (yyvsp[-1].interm.typeParameters); } -#line 7582 "MachineIndependent/glslang_tab.cpp" +#line 7752 "MachineIndependent/glslang_tab.cpp" break; - case 219: /* type_parameter_specifier_list: type_specifier */ -#line 1766 "MachineIndependent/glslang.y" + case 220: /* type_parameter_specifier_list: type_specifier */ +#line 1772 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = new TTypeParameters; (yyval.interm.typeParameters)->arraySizes = new TArraySizes; (yyval.interm.typeParameters)->spirvType = (yyvsp[0].interm.type).spirvType; (yyval.interm.typeParameters)->basicType = (yyvsp[0].interm.type).basicType; } -#line 7593 "MachineIndependent/glslang_tab.cpp" +#line 7763 "MachineIndependent/glslang_tab.cpp" break; - case 220: /* type_parameter_specifier_list: unary_expression */ -#line 1772 "MachineIndependent/glslang.y" + case 221: /* type_parameter_specifier_list: unary_expression */ +#line 1778 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = new TTypeParameters; (yyval.interm.typeParameters)->arraySizes = new TArraySizes; @@ -7602,11 +7772,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter", true); (yyval.interm.typeParameters)->arraySizes->addInnerSize(size); } -#line 7606 "MachineIndependent/glslang_tab.cpp" +#line 7776 "MachineIndependent/glslang_tab.cpp" break; - case 221: /* type_parameter_specifier_list: type_parameter_specifier_list COMMA unary_expression */ -#line 1780 "MachineIndependent/glslang.y" + case 222: /* type_parameter_specifier_list: type_parameter_specifier_list COMMA unary_expression */ +#line 1786 "MachineIndependent/glslang.y" { (yyval.interm.typeParameters) = (yyvsp[-2].interm.typeParameters); @@ -7614,300 +7784,300 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.arraySizeCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode), size, "type parameter", true); (yyval.interm.typeParameters)->arraySizes->addInnerSize(size); } -#line 7618 "MachineIndependent/glslang_tab.cpp" +#line 7788 "MachineIndependent/glslang_tab.cpp" break; - case 222: /* type_specifier_nonarray: VOID */ -#line 1790 "MachineIndependent/glslang.y" + case 223: /* type_specifier_nonarray: VOID */ +#line 1796 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtVoid; } -#line 7627 "MachineIndependent/glslang_tab.cpp" +#line 7797 "MachineIndependent/glslang_tab.cpp" break; - case 223: /* type_specifier_nonarray: FLOAT */ -#line 1794 "MachineIndependent/glslang.y" + case 224: /* type_specifier_nonarray: FLOAT */ +#line 1800 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } -#line 7636 "MachineIndependent/glslang_tab.cpp" +#line 7806 "MachineIndependent/glslang_tab.cpp" break; - case 224: /* type_specifier_nonarray: INT */ -#line 1798 "MachineIndependent/glslang.y" + case 225: /* type_specifier_nonarray: INT */ +#line 1804 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } -#line 7645 "MachineIndependent/glslang_tab.cpp" +#line 7815 "MachineIndependent/glslang_tab.cpp" break; - case 225: /* type_specifier_nonarray: UINT */ -#line 1802 "MachineIndependent/glslang.y" + case 226: /* type_specifier_nonarray: UINT */ +#line 1808 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; } -#line 7655 "MachineIndependent/glslang_tab.cpp" +#line 7825 "MachineIndependent/glslang_tab.cpp" break; - case 226: /* type_specifier_nonarray: BOOL */ -#line 1807 "MachineIndependent/glslang.y" + case 227: /* type_specifier_nonarray: BOOL */ +#line 1813 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; } -#line 7664 "MachineIndependent/glslang_tab.cpp" +#line 7834 "MachineIndependent/glslang_tab.cpp" break; - case 227: /* type_specifier_nonarray: VEC2 */ -#line 1811 "MachineIndependent/glslang.y" + case 228: /* type_specifier_nonarray: VEC2 */ +#line 1817 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(2); } -#line 7674 "MachineIndependent/glslang_tab.cpp" +#line 7844 "MachineIndependent/glslang_tab.cpp" break; - case 228: /* type_specifier_nonarray: VEC3 */ -#line 1816 "MachineIndependent/glslang.y" + case 229: /* type_specifier_nonarray: VEC3 */ +#line 1822 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(3); } -#line 7684 "MachineIndependent/glslang_tab.cpp" +#line 7854 "MachineIndependent/glslang_tab.cpp" break; - case 229: /* type_specifier_nonarray: VEC4 */ -#line 1821 "MachineIndependent/glslang.y" + case 230: /* type_specifier_nonarray: VEC4 */ +#line 1827 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(4); } -#line 7694 "MachineIndependent/glslang_tab.cpp" +#line 7864 "MachineIndependent/glslang_tab.cpp" break; - case 230: /* type_specifier_nonarray: BVEC2 */ -#line 1826 "MachineIndependent/glslang.y" + case 231: /* type_specifier_nonarray: BVEC2 */ +#line 1832 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(2); } -#line 7704 "MachineIndependent/glslang_tab.cpp" +#line 7874 "MachineIndependent/glslang_tab.cpp" break; - case 231: /* type_specifier_nonarray: BVEC3 */ -#line 1831 "MachineIndependent/glslang.y" + case 232: /* type_specifier_nonarray: BVEC3 */ +#line 1837 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(3); } -#line 7714 "MachineIndependent/glslang_tab.cpp" +#line 7884 "MachineIndependent/glslang_tab.cpp" break; - case 232: /* type_specifier_nonarray: BVEC4 */ -#line 1836 "MachineIndependent/glslang.y" + case 233: /* type_specifier_nonarray: BVEC4 */ +#line 1842 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBool; (yyval.interm.type).setVector(4); } -#line 7724 "MachineIndependent/glslang_tab.cpp" +#line 7894 "MachineIndependent/glslang_tab.cpp" break; - case 233: /* type_specifier_nonarray: IVEC2 */ -#line 1841 "MachineIndependent/glslang.y" + case 234: /* type_specifier_nonarray: IVEC2 */ +#line 1847 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(2); } -#line 7734 "MachineIndependent/glslang_tab.cpp" +#line 7904 "MachineIndependent/glslang_tab.cpp" break; - case 234: /* type_specifier_nonarray: IVEC3 */ -#line 1846 "MachineIndependent/glslang.y" + case 235: /* type_specifier_nonarray: IVEC3 */ +#line 1852 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(3); } -#line 7744 "MachineIndependent/glslang_tab.cpp" +#line 7914 "MachineIndependent/glslang_tab.cpp" break; - case 235: /* type_specifier_nonarray: IVEC4 */ -#line 1851 "MachineIndependent/glslang.y" + case 236: /* type_specifier_nonarray: IVEC4 */ +#line 1857 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(4); } -#line 7754 "MachineIndependent/glslang_tab.cpp" +#line 7924 "MachineIndependent/glslang_tab.cpp" break; - case 236: /* type_specifier_nonarray: UVEC2 */ -#line 1856 "MachineIndependent/glslang.y" + case 237: /* type_specifier_nonarray: UVEC2 */ +#line 1862 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(2); } -#line 7765 "MachineIndependent/glslang_tab.cpp" +#line 7935 "MachineIndependent/glslang_tab.cpp" break; - case 237: /* type_specifier_nonarray: UVEC3 */ -#line 1862 "MachineIndependent/glslang.y" + case 238: /* type_specifier_nonarray: UVEC3 */ +#line 1868 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(3); } -#line 7776 "MachineIndependent/glslang_tab.cpp" +#line 7946 "MachineIndependent/glslang_tab.cpp" break; - case 238: /* type_specifier_nonarray: UVEC4 */ -#line 1868 "MachineIndependent/glslang.y" + case 239: /* type_specifier_nonarray: UVEC4 */ +#line 1874 "MachineIndependent/glslang.y" { parseContext.fullIntegerCheck((yyvsp[0].lex).loc, "unsigned integer vector"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(4); } -#line 7787 "MachineIndependent/glslang_tab.cpp" +#line 7957 "MachineIndependent/glslang_tab.cpp" break; - case 239: /* type_specifier_nonarray: MAT2 */ -#line 1874 "MachineIndependent/glslang.y" + case 240: /* type_specifier_nonarray: MAT2 */ +#line 1880 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } -#line 7797 "MachineIndependent/glslang_tab.cpp" +#line 7967 "MachineIndependent/glslang_tab.cpp" break; - case 240: /* type_specifier_nonarray: MAT3 */ -#line 1879 "MachineIndependent/glslang.y" + case 241: /* type_specifier_nonarray: MAT3 */ +#line 1885 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 7807 "MachineIndependent/glslang_tab.cpp" +#line 7977 "MachineIndependent/glslang_tab.cpp" break; - case 241: /* type_specifier_nonarray: MAT4 */ -#line 1884 "MachineIndependent/glslang.y" + case 242: /* type_specifier_nonarray: MAT4 */ +#line 1890 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 7817 "MachineIndependent/glslang_tab.cpp" +#line 7987 "MachineIndependent/glslang_tab.cpp" break; - case 242: /* type_specifier_nonarray: MAT2X2 */ -#line 1889 "MachineIndependent/glslang.y" + case 243: /* type_specifier_nonarray: MAT2X2 */ +#line 1895 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } -#line 7827 "MachineIndependent/glslang_tab.cpp" +#line 7997 "MachineIndependent/glslang_tab.cpp" break; - case 243: /* type_specifier_nonarray: MAT2X3 */ -#line 1894 "MachineIndependent/glslang.y" + case 244: /* type_specifier_nonarray: MAT2X3 */ +#line 1900 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 3); } -#line 7837 "MachineIndependent/glslang_tab.cpp" +#line 8007 "MachineIndependent/glslang_tab.cpp" break; - case 244: /* type_specifier_nonarray: MAT2X4 */ -#line 1899 "MachineIndependent/glslang.y" + case 245: /* type_specifier_nonarray: MAT2X4 */ +#line 1905 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 4); } -#line 7847 "MachineIndependent/glslang_tab.cpp" +#line 8017 "MachineIndependent/glslang_tab.cpp" break; - case 245: /* type_specifier_nonarray: MAT3X2 */ -#line 1904 "MachineIndependent/glslang.y" + case 246: /* type_specifier_nonarray: MAT3X2 */ +#line 1910 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 2); } -#line 7857 "MachineIndependent/glslang_tab.cpp" +#line 8027 "MachineIndependent/glslang_tab.cpp" break; - case 246: /* type_specifier_nonarray: MAT3X3 */ -#line 1909 "MachineIndependent/glslang.y" + case 247: /* type_specifier_nonarray: MAT3X3 */ +#line 1915 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 7867 "MachineIndependent/glslang_tab.cpp" +#line 8037 "MachineIndependent/glslang_tab.cpp" break; - case 247: /* type_specifier_nonarray: MAT3X4 */ -#line 1914 "MachineIndependent/glslang.y" + case 248: /* type_specifier_nonarray: MAT3X4 */ +#line 1920 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 4); } -#line 7877 "MachineIndependent/glslang_tab.cpp" +#line 8047 "MachineIndependent/glslang_tab.cpp" break; - case 248: /* type_specifier_nonarray: MAT4X2 */ -#line 1919 "MachineIndependent/glslang.y" + case 249: /* type_specifier_nonarray: MAT4X2 */ +#line 1925 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 2); } -#line 7887 "MachineIndependent/glslang_tab.cpp" +#line 8057 "MachineIndependent/glslang_tab.cpp" break; - case 249: /* type_specifier_nonarray: MAT4X3 */ -#line 1924 "MachineIndependent/glslang.y" + case 250: /* type_specifier_nonarray: MAT4X3 */ +#line 1930 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 3); } -#line 7897 "MachineIndependent/glslang_tab.cpp" +#line 8067 "MachineIndependent/glslang_tab.cpp" break; - case 250: /* type_specifier_nonarray: MAT4X4 */ -#line 1929 "MachineIndependent/glslang.y" + case 251: /* type_specifier_nonarray: MAT4X4 */ +#line 1935 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 7907 "MachineIndependent/glslang_tab.cpp" +#line 8077 "MachineIndependent/glslang_tab.cpp" break; - case 251: /* type_specifier_nonarray: DOUBLE */ -#line 1934 "MachineIndependent/glslang.y" + case 252: /* type_specifier_nonarray: DOUBLE */ +#line 1940 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -7915,131 +8085,151 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; } -#line 7919 "MachineIndependent/glslang_tab.cpp" +#line 8089 "MachineIndependent/glslang_tab.cpp" break; - case 252: /* type_specifier_nonarray: BFLOAT16_T */ -#line 1941 "MachineIndependent/glslang.y" + case 253: /* type_specifier_nonarray: BFLOAT16_T */ +#line 1947 "MachineIndependent/glslang.y" { parseContext.bfloat16ScalarVectorCheck((yyvsp[0].lex).loc, "bfloat16_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBFloat16; } -#line 7929 "MachineIndependent/glslang_tab.cpp" +#line 8099 "MachineIndependent/glslang_tab.cpp" + break; + + case 254: /* type_specifier_nonarray: FLOATE5M2_T */ +#line 1952 "MachineIndependent/glslang.y" + { + parseContext.floate5m2ScalarVectorCheck((yyvsp[0].lex).loc, "floate5m2_t", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloatE5M2; + } +#line 8109 "MachineIndependent/glslang_tab.cpp" + break; + + case 255: /* type_specifier_nonarray: FLOATE4M3_T */ +#line 1957 "MachineIndependent/glslang.y" + { + parseContext.floate4m3ScalarVectorCheck((yyvsp[0].lex).loc, "floate4m3_t", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloatE4M3; + } +#line 8119 "MachineIndependent/glslang_tab.cpp" break; - case 253: /* type_specifier_nonarray: FLOAT16_T */ -#line 1946 "MachineIndependent/glslang.y" + case 256: /* type_specifier_nonarray: FLOAT16_T */ +#line 1962 "MachineIndependent/glslang.y" { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "float16_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; } -#line 7939 "MachineIndependent/glslang_tab.cpp" +#line 8129 "MachineIndependent/glslang_tab.cpp" break; - case 254: /* type_specifier_nonarray: FLOAT32_T */ -#line 1951 "MachineIndependent/glslang.y" + case 257: /* type_specifier_nonarray: FLOAT32_T */ +#line 1967 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; } -#line 7949 "MachineIndependent/glslang_tab.cpp" +#line 8139 "MachineIndependent/glslang_tab.cpp" break; - case 255: /* type_specifier_nonarray: FLOAT64_T */ -#line 1956 "MachineIndependent/glslang.y" + case 258: /* type_specifier_nonarray: FLOAT64_T */ +#line 1972 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; } -#line 7959 "MachineIndependent/glslang_tab.cpp" +#line 8149 "MachineIndependent/glslang_tab.cpp" break; - case 256: /* type_specifier_nonarray: INT8_T */ -#line 1961 "MachineIndependent/glslang.y" + case 259: /* type_specifier_nonarray: INT8_T */ +#line 1977 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; } -#line 7969 "MachineIndependent/glslang_tab.cpp" +#line 8159 "MachineIndependent/glslang_tab.cpp" break; - case 257: /* type_specifier_nonarray: UINT8_T */ -#line 1966 "MachineIndependent/glslang.y" + case 260: /* type_specifier_nonarray: UINT8_T */ +#line 1982 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; } -#line 7979 "MachineIndependent/glslang_tab.cpp" +#line 8169 "MachineIndependent/glslang_tab.cpp" break; - case 258: /* type_specifier_nonarray: INT16_T */ -#line 1971 "MachineIndependent/glslang.y" + case 261: /* type_specifier_nonarray: INT16_T */ +#line 1987 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; } -#line 7989 "MachineIndependent/glslang_tab.cpp" +#line 8179 "MachineIndependent/glslang_tab.cpp" break; - case 259: /* type_specifier_nonarray: UINT16_T */ -#line 1976 "MachineIndependent/glslang.y" + case 262: /* type_specifier_nonarray: UINT16_T */ +#line 1992 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; } -#line 7999 "MachineIndependent/glslang_tab.cpp" +#line 8189 "MachineIndependent/glslang_tab.cpp" break; - case 260: /* type_specifier_nonarray: INT32_T */ -#line 1981 "MachineIndependent/glslang.y" + case 263: /* type_specifier_nonarray: INT32_T */ +#line 1997 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; } -#line 8009 "MachineIndependent/glslang_tab.cpp" +#line 8199 "MachineIndependent/glslang_tab.cpp" break; - case 261: /* type_specifier_nonarray: UINT32_T */ -#line 1986 "MachineIndependent/glslang.y" + case 264: /* type_specifier_nonarray: UINT32_T */ +#line 2002 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; } -#line 8019 "MachineIndependent/glslang_tab.cpp" +#line 8209 "MachineIndependent/glslang_tab.cpp" break; - case 262: /* type_specifier_nonarray: INT64_T */ -#line 1991 "MachineIndependent/glslang.y" + case 265: /* type_specifier_nonarray: INT64_T */ +#line 2007 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; } -#line 8029 "MachineIndependent/glslang_tab.cpp" +#line 8219 "MachineIndependent/glslang_tab.cpp" break; - case 263: /* type_specifier_nonarray: UINT64_T */ -#line 1996 "MachineIndependent/glslang.y" + case 266: /* type_specifier_nonarray: UINT64_T */ +#line 2012 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; } -#line 8039 "MachineIndependent/glslang_tab.cpp" +#line 8229 "MachineIndependent/glslang_tab.cpp" break; - case 264: /* type_specifier_nonarray: DVEC2 */ -#line 2001 "MachineIndependent/glslang.y" + case 267: /* type_specifier_nonarray: DVEC2 */ +#line 2017 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8048,11 +8238,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(2); } -#line 8052 "MachineIndependent/glslang_tab.cpp" +#line 8242 "MachineIndependent/glslang_tab.cpp" break; - case 265: /* type_specifier_nonarray: DVEC3 */ -#line 2009 "MachineIndependent/glslang.y" + case 268: /* type_specifier_nonarray: DVEC3 */ +#line 2025 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8061,11 +8251,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(3); } -#line 8065 "MachineIndependent/glslang_tab.cpp" +#line 8255 "MachineIndependent/glslang_tab.cpp" break; - case 266: /* type_specifier_nonarray: DVEC4 */ -#line 2017 "MachineIndependent/glslang.y" + case 269: /* type_specifier_nonarray: DVEC4 */ +#line 2033 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double vector"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8074,407 +8264,473 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(4); } -#line 8078 "MachineIndependent/glslang_tab.cpp" +#line 8268 "MachineIndependent/glslang_tab.cpp" break; - case 267: /* type_specifier_nonarray: BF16VEC2 */ -#line 2025 "MachineIndependent/glslang.y" + case 270: /* type_specifier_nonarray: BF16VEC2 */ +#line 2041 "MachineIndependent/glslang.y" { parseContext.bfloat16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBFloat16; (yyval.interm.type).setVector(2); } -#line 8089 "MachineIndependent/glslang_tab.cpp" +#line 8279 "MachineIndependent/glslang_tab.cpp" break; - case 268: /* type_specifier_nonarray: BF16VEC3 */ -#line 2031 "MachineIndependent/glslang.y" + case 271: /* type_specifier_nonarray: BF16VEC3 */ +#line 2047 "MachineIndependent/glslang.y" { parseContext.bfloat16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBFloat16; (yyval.interm.type).setVector(3); } -#line 8100 "MachineIndependent/glslang_tab.cpp" +#line 8290 "MachineIndependent/glslang_tab.cpp" break; - case 269: /* type_specifier_nonarray: BF16VEC4 */ -#line 2037 "MachineIndependent/glslang.y" + case 272: /* type_specifier_nonarray: BF16VEC4 */ +#line 2053 "MachineIndependent/glslang.y" { parseContext.bfloat16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtBFloat16; (yyval.interm.type).setVector(4); } -#line 8111 "MachineIndependent/glslang_tab.cpp" +#line 8301 "MachineIndependent/glslang_tab.cpp" + break; + + case 273: /* type_specifier_nonarray: FE5M2VEC2 */ +#line 2059 "MachineIndependent/glslang.y" + { + parseContext.floate5m2ScalarVectorCheck((yyvsp[0].lex).loc, "fe5m2 vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloatE5M2; + (yyval.interm.type).setVector(2); + } +#line 8312 "MachineIndependent/glslang_tab.cpp" + break; + + case 274: /* type_specifier_nonarray: FE5M2VEC3 */ +#line 2065 "MachineIndependent/glslang.y" + { + parseContext.floate5m2ScalarVectorCheck((yyvsp[0].lex).loc, "fe5m2 vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloatE5M2; + (yyval.interm.type).setVector(3); + } +#line 8323 "MachineIndependent/glslang_tab.cpp" + break; + + case 275: /* type_specifier_nonarray: FE5M2VEC4 */ +#line 2071 "MachineIndependent/glslang.y" + { + parseContext.floate5m2ScalarVectorCheck((yyvsp[0].lex).loc, "fe5m2 vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloatE5M2; + (yyval.interm.type).setVector(4); + } +#line 8334 "MachineIndependent/glslang_tab.cpp" + break; + + case 276: /* type_specifier_nonarray: FE4M3VEC2 */ +#line 2077 "MachineIndependent/glslang.y" + { + parseContext.floate4m3ScalarVectorCheck((yyvsp[0].lex).loc, "fe4m3 vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloatE4M3; + (yyval.interm.type).setVector(2); + } +#line 8345 "MachineIndependent/glslang_tab.cpp" + break; + + case 277: /* type_specifier_nonarray: FE4M3VEC3 */ +#line 2083 "MachineIndependent/glslang.y" + { + parseContext.floate4m3ScalarVectorCheck((yyvsp[0].lex).loc, "fe4m3 vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloatE4M3; + (yyval.interm.type).setVector(3); + } +#line 8356 "MachineIndependent/glslang_tab.cpp" + break; + + case 278: /* type_specifier_nonarray: FE4M3VEC4 */ +#line 2089 "MachineIndependent/glslang.y" + { + parseContext.floate4m3ScalarVectorCheck((yyvsp[0].lex).loc, "fe4m3 vector", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).basicType = EbtFloatE4M3; + (yyval.interm.type).setVector(4); + } +#line 8367 "MachineIndependent/glslang_tab.cpp" break; - case 270: /* type_specifier_nonarray: F16VEC2 */ -#line 2043 "MachineIndependent/glslang.y" + case 279: /* type_specifier_nonarray: F16VEC2 */ +#line 2095 "MachineIndependent/glslang.y" { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setVector(2); } -#line 8122 "MachineIndependent/glslang_tab.cpp" +#line 8378 "MachineIndependent/glslang_tab.cpp" break; - case 271: /* type_specifier_nonarray: F16VEC3 */ -#line 2049 "MachineIndependent/glslang.y" + case 280: /* type_specifier_nonarray: F16VEC3 */ +#line 2101 "MachineIndependent/glslang.y" { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setVector(3); } -#line 8133 "MachineIndependent/glslang_tab.cpp" +#line 8389 "MachineIndependent/glslang_tab.cpp" break; - case 272: /* type_specifier_nonarray: F16VEC4 */ -#line 2055 "MachineIndependent/glslang.y" + case 281: /* type_specifier_nonarray: F16VEC4 */ +#line 2107 "MachineIndependent/glslang.y" { parseContext.float16ScalarVectorCheck((yyvsp[0].lex).loc, "half float vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setVector(4); } -#line 8144 "MachineIndependent/glslang_tab.cpp" +#line 8400 "MachineIndependent/glslang_tab.cpp" break; - case 273: /* type_specifier_nonarray: F32VEC2 */ -#line 2061 "MachineIndependent/glslang.y" + case 282: /* type_specifier_nonarray: F32VEC2 */ +#line 2113 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(2); } -#line 8155 "MachineIndependent/glslang_tab.cpp" +#line 8411 "MachineIndependent/glslang_tab.cpp" break; - case 274: /* type_specifier_nonarray: F32VEC3 */ -#line 2067 "MachineIndependent/glslang.y" + case 283: /* type_specifier_nonarray: F32VEC3 */ +#line 2119 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(3); } -#line 8166 "MachineIndependent/glslang_tab.cpp" +#line 8422 "MachineIndependent/glslang_tab.cpp" break; - case 275: /* type_specifier_nonarray: F32VEC4 */ -#line 2073 "MachineIndependent/glslang.y" + case 284: /* type_specifier_nonarray: F32VEC4 */ +#line 2125 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setVector(4); } -#line 8177 "MachineIndependent/glslang_tab.cpp" +#line 8433 "MachineIndependent/glslang_tab.cpp" break; - case 276: /* type_specifier_nonarray: F64VEC2 */ -#line 2079 "MachineIndependent/glslang.y" + case 285: /* type_specifier_nonarray: F64VEC2 */ +#line 2131 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(2); } -#line 8188 "MachineIndependent/glslang_tab.cpp" +#line 8444 "MachineIndependent/glslang_tab.cpp" break; - case 277: /* type_specifier_nonarray: F64VEC3 */ -#line 2085 "MachineIndependent/glslang.y" + case 286: /* type_specifier_nonarray: F64VEC3 */ +#line 2137 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(3); } -#line 8199 "MachineIndependent/glslang_tab.cpp" +#line 8455 "MachineIndependent/glslang_tab.cpp" break; - case 278: /* type_specifier_nonarray: F64VEC4 */ -#line 2091 "MachineIndependent/glslang.y" + case 287: /* type_specifier_nonarray: F64VEC4 */ +#line 2143 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setVector(4); } -#line 8210 "MachineIndependent/glslang_tab.cpp" +#line 8466 "MachineIndependent/glslang_tab.cpp" break; - case 279: /* type_specifier_nonarray: I8VEC2 */ -#line 2097 "MachineIndependent/glslang.y" + case 288: /* type_specifier_nonarray: I8VEC2 */ +#line 2149 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; (yyval.interm.type).setVector(2); } -#line 8221 "MachineIndependent/glslang_tab.cpp" +#line 8477 "MachineIndependent/glslang_tab.cpp" break; - case 280: /* type_specifier_nonarray: I8VEC3 */ -#line 2103 "MachineIndependent/glslang.y" + case 289: /* type_specifier_nonarray: I8VEC3 */ +#line 2155 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; (yyval.interm.type).setVector(3); } -#line 8232 "MachineIndependent/glslang_tab.cpp" +#line 8488 "MachineIndependent/glslang_tab.cpp" break; - case 281: /* type_specifier_nonarray: I8VEC4 */ -#line 2109 "MachineIndependent/glslang.y" + case 290: /* type_specifier_nonarray: I8VEC4 */ +#line 2161 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt8; (yyval.interm.type).setVector(4); } -#line 8243 "MachineIndependent/glslang_tab.cpp" +#line 8499 "MachineIndependent/glslang_tab.cpp" break; - case 282: /* type_specifier_nonarray: I16VEC2 */ -#line 2115 "MachineIndependent/glslang.y" + case 291: /* type_specifier_nonarray: I16VEC2 */ +#line 2167 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; (yyval.interm.type).setVector(2); } -#line 8254 "MachineIndependent/glslang_tab.cpp" +#line 8510 "MachineIndependent/glslang_tab.cpp" break; - case 283: /* type_specifier_nonarray: I16VEC3 */ -#line 2121 "MachineIndependent/glslang.y" + case 292: /* type_specifier_nonarray: I16VEC3 */ +#line 2173 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; (yyval.interm.type).setVector(3); } -#line 8265 "MachineIndependent/glslang_tab.cpp" +#line 8521 "MachineIndependent/glslang_tab.cpp" break; - case 284: /* type_specifier_nonarray: I16VEC4 */ -#line 2127 "MachineIndependent/glslang.y" + case 293: /* type_specifier_nonarray: I16VEC4 */ +#line 2179 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt16; (yyval.interm.type).setVector(4); } -#line 8276 "MachineIndependent/glslang_tab.cpp" +#line 8532 "MachineIndependent/glslang_tab.cpp" break; - case 285: /* type_specifier_nonarray: I32VEC2 */ -#line 2133 "MachineIndependent/glslang.y" + case 294: /* type_specifier_nonarray: I32VEC2 */ +#line 2185 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(2); } -#line 8287 "MachineIndependent/glslang_tab.cpp" +#line 8543 "MachineIndependent/glslang_tab.cpp" break; - case 286: /* type_specifier_nonarray: I32VEC3 */ -#line 2139 "MachineIndependent/glslang.y" + case 295: /* type_specifier_nonarray: I32VEC3 */ +#line 2191 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(3); } -#line 8298 "MachineIndependent/glslang_tab.cpp" +#line 8554 "MachineIndependent/glslang_tab.cpp" break; - case 287: /* type_specifier_nonarray: I32VEC4 */ -#line 2145 "MachineIndependent/glslang.y" + case 296: /* type_specifier_nonarray: I32VEC4 */ +#line 2197 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit signed integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt; (yyval.interm.type).setVector(4); } -#line 8309 "MachineIndependent/glslang_tab.cpp" +#line 8565 "MachineIndependent/glslang_tab.cpp" break; - case 288: /* type_specifier_nonarray: I64VEC2 */ -#line 2151 "MachineIndependent/glslang.y" + case 297: /* type_specifier_nonarray: I64VEC2 */ +#line 2203 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; (yyval.interm.type).setVector(2); } -#line 8320 "MachineIndependent/glslang_tab.cpp" +#line 8576 "MachineIndependent/glslang_tab.cpp" break; - case 289: /* type_specifier_nonarray: I64VEC3 */ -#line 2157 "MachineIndependent/glslang.y" + case 298: /* type_specifier_nonarray: I64VEC3 */ +#line 2209 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; (yyval.interm.type).setVector(3); } -#line 8331 "MachineIndependent/glslang_tab.cpp" +#line 8587 "MachineIndependent/glslang_tab.cpp" break; - case 290: /* type_specifier_nonarray: I64VEC4 */ -#line 2163 "MachineIndependent/glslang.y" + case 299: /* type_specifier_nonarray: I64VEC4 */ +#line 2215 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtInt64; (yyval.interm.type).setVector(4); } -#line 8342 "MachineIndependent/glslang_tab.cpp" +#line 8598 "MachineIndependent/glslang_tab.cpp" break; - case 291: /* type_specifier_nonarray: U8VEC2 */ -#line 2169 "MachineIndependent/glslang.y" + case 300: /* type_specifier_nonarray: U8VEC2 */ +#line 2221 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; (yyval.interm.type).setVector(2); } -#line 8353 "MachineIndependent/glslang_tab.cpp" +#line 8609 "MachineIndependent/glslang_tab.cpp" break; - case 292: /* type_specifier_nonarray: U8VEC3 */ -#line 2175 "MachineIndependent/glslang.y" + case 301: /* type_specifier_nonarray: U8VEC3 */ +#line 2227 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; (yyval.interm.type).setVector(3); } -#line 8364 "MachineIndependent/glslang_tab.cpp" +#line 8620 "MachineIndependent/glslang_tab.cpp" break; - case 293: /* type_specifier_nonarray: U8VEC4 */ -#line 2181 "MachineIndependent/glslang.y" + case 302: /* type_specifier_nonarray: U8VEC4 */ +#line 2233 "MachineIndependent/glslang.y" { parseContext.int8ScalarVectorCheck((yyvsp[0].lex).loc, "8-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint8; (yyval.interm.type).setVector(4); } -#line 8375 "MachineIndependent/glslang_tab.cpp" +#line 8631 "MachineIndependent/glslang_tab.cpp" break; - case 294: /* type_specifier_nonarray: U16VEC2 */ -#line 2187 "MachineIndependent/glslang.y" + case 303: /* type_specifier_nonarray: U16VEC2 */ +#line 2239 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; (yyval.interm.type).setVector(2); } -#line 8386 "MachineIndependent/glslang_tab.cpp" +#line 8642 "MachineIndependent/glslang_tab.cpp" break; - case 295: /* type_specifier_nonarray: U16VEC3 */ -#line 2193 "MachineIndependent/glslang.y" + case 304: /* type_specifier_nonarray: U16VEC3 */ +#line 2245 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; (yyval.interm.type).setVector(3); } -#line 8397 "MachineIndependent/glslang_tab.cpp" +#line 8653 "MachineIndependent/glslang_tab.cpp" break; - case 296: /* type_specifier_nonarray: U16VEC4 */ -#line 2199 "MachineIndependent/glslang.y" + case 305: /* type_specifier_nonarray: U16VEC4 */ +#line 2251 "MachineIndependent/glslang.y" { parseContext.int16ScalarVectorCheck((yyvsp[0].lex).loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint16; (yyval.interm.type).setVector(4); } -#line 8408 "MachineIndependent/glslang_tab.cpp" +#line 8664 "MachineIndependent/glslang_tab.cpp" break; - case 297: /* type_specifier_nonarray: U32VEC2 */ -#line 2205 "MachineIndependent/glslang.y" + case 306: /* type_specifier_nonarray: U32VEC2 */ +#line 2257 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(2); } -#line 8419 "MachineIndependent/glslang_tab.cpp" +#line 8675 "MachineIndependent/glslang_tab.cpp" break; - case 298: /* type_specifier_nonarray: U32VEC3 */ -#line 2211 "MachineIndependent/glslang.y" + case 307: /* type_specifier_nonarray: U32VEC3 */ +#line 2263 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(3); } -#line 8430 "MachineIndependent/glslang_tab.cpp" +#line 8686 "MachineIndependent/glslang_tab.cpp" break; - case 299: /* type_specifier_nonarray: U32VEC4 */ -#line 2217 "MachineIndependent/glslang.y" + case 308: /* type_specifier_nonarray: U32VEC4 */ +#line 2269 "MachineIndependent/glslang.y" { parseContext.explicitInt32Check((yyvsp[0].lex).loc, "32-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint; (yyval.interm.type).setVector(4); } -#line 8441 "MachineIndependent/glslang_tab.cpp" +#line 8697 "MachineIndependent/glslang_tab.cpp" break; - case 300: /* type_specifier_nonarray: U64VEC2 */ -#line 2223 "MachineIndependent/glslang.y" + case 309: /* type_specifier_nonarray: U64VEC2 */ +#line 2275 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; (yyval.interm.type).setVector(2); } -#line 8452 "MachineIndependent/glslang_tab.cpp" +#line 8708 "MachineIndependent/glslang_tab.cpp" break; - case 301: /* type_specifier_nonarray: U64VEC3 */ -#line 2229 "MachineIndependent/glslang.y" + case 310: /* type_specifier_nonarray: U64VEC3 */ +#line 2281 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; (yyval.interm.type).setVector(3); } -#line 8463 "MachineIndependent/glslang_tab.cpp" +#line 8719 "MachineIndependent/glslang_tab.cpp" break; - case 302: /* type_specifier_nonarray: U64VEC4 */ -#line 2235 "MachineIndependent/glslang.y" + case 311: /* type_specifier_nonarray: U64VEC4 */ +#line 2287 "MachineIndependent/glslang.y" { parseContext.int64Check((yyvsp[0].lex).loc, "64-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtUint64; (yyval.interm.type).setVector(4); } -#line 8474 "MachineIndependent/glslang_tab.cpp" +#line 8730 "MachineIndependent/glslang_tab.cpp" break; - case 303: /* type_specifier_nonarray: DMAT2 */ -#line 2241 "MachineIndependent/glslang.y" + case 312: /* type_specifier_nonarray: DMAT2 */ +#line 2293 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8483,11 +8739,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 8487 "MachineIndependent/glslang_tab.cpp" +#line 8743 "MachineIndependent/glslang_tab.cpp" break; - case 304: /* type_specifier_nonarray: DMAT3 */ -#line 2249 "MachineIndependent/glslang.y" + case 313: /* type_specifier_nonarray: DMAT3 */ +#line 2301 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8496,11 +8752,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 8500 "MachineIndependent/glslang_tab.cpp" +#line 8756 "MachineIndependent/glslang_tab.cpp" break; - case 305: /* type_specifier_nonarray: DMAT4 */ -#line 2257 "MachineIndependent/glslang.y" + case 314: /* type_specifier_nonarray: DMAT4 */ +#line 2309 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8509,11 +8765,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 8513 "MachineIndependent/glslang_tab.cpp" +#line 8769 "MachineIndependent/glslang_tab.cpp" break; - case 306: /* type_specifier_nonarray: DMAT2X2 */ -#line 2265 "MachineIndependent/glslang.y" + case 315: /* type_specifier_nonarray: DMAT2X2 */ +#line 2317 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8522,11 +8778,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 8526 "MachineIndependent/glslang_tab.cpp" +#line 8782 "MachineIndependent/glslang_tab.cpp" break; - case 307: /* type_specifier_nonarray: DMAT2X3 */ -#line 2273 "MachineIndependent/glslang.y" + case 316: /* type_specifier_nonarray: DMAT2X3 */ +#line 2325 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8535,11 +8791,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 3); } -#line 8539 "MachineIndependent/glslang_tab.cpp" +#line 8795 "MachineIndependent/glslang_tab.cpp" break; - case 308: /* type_specifier_nonarray: DMAT2X4 */ -#line 2281 "MachineIndependent/glslang.y" + case 317: /* type_specifier_nonarray: DMAT2X4 */ +#line 2333 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8548,11 +8804,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 4); } -#line 8552 "MachineIndependent/glslang_tab.cpp" +#line 8808 "MachineIndependent/glslang_tab.cpp" break; - case 309: /* type_specifier_nonarray: DMAT3X2 */ -#line 2289 "MachineIndependent/glslang.y" + case 318: /* type_specifier_nonarray: DMAT3X2 */ +#line 2341 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8561,11 +8817,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 2); } -#line 8565 "MachineIndependent/glslang_tab.cpp" +#line 8821 "MachineIndependent/glslang_tab.cpp" break; - case 310: /* type_specifier_nonarray: DMAT3X3 */ -#line 2297 "MachineIndependent/glslang.y" + case 319: /* type_specifier_nonarray: DMAT3X3 */ +#line 2349 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8574,11 +8830,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 8578 "MachineIndependent/glslang_tab.cpp" +#line 8834 "MachineIndependent/glslang_tab.cpp" break; - case 311: /* type_specifier_nonarray: DMAT3X4 */ -#line 2305 "MachineIndependent/glslang.y" + case 320: /* type_specifier_nonarray: DMAT3X4 */ +#line 2357 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8587,11 +8843,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 4); } -#line 8591 "MachineIndependent/glslang_tab.cpp" +#line 8847 "MachineIndependent/glslang_tab.cpp" break; - case 312: /* type_specifier_nonarray: DMAT4X2 */ -#line 2313 "MachineIndependent/glslang.y" + case 321: /* type_specifier_nonarray: DMAT4X2 */ +#line 2365 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8600,11 +8856,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 2); } -#line 8604 "MachineIndependent/glslang_tab.cpp" +#line 8860 "MachineIndependent/glslang_tab.cpp" break; - case 313: /* type_specifier_nonarray: DMAT4X3 */ -#line 2321 "MachineIndependent/glslang.y" + case 322: /* type_specifier_nonarray: DMAT4X3 */ +#line 2373 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8613,11 +8869,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 3); } -#line 8617 "MachineIndependent/glslang_tab.cpp" +#line 8873 "MachineIndependent/glslang_tab.cpp" break; - case 314: /* type_specifier_nonarray: DMAT4X4 */ -#line 2329 "MachineIndependent/glslang.y" + case 323: /* type_specifier_nonarray: DMAT4X4 */ +#line 2381 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ECoreProfile | ECompatibilityProfile, "double matrix"); if (! parseContext.symbolTable.atBuiltInLevel()) @@ -8626,2261 +8882,2261 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 8630 "MachineIndependent/glslang_tab.cpp" +#line 8886 "MachineIndependent/glslang_tab.cpp" break; - case 315: /* type_specifier_nonarray: F16MAT2 */ -#line 2337 "MachineIndependent/glslang.y" + case 324: /* type_specifier_nonarray: F16MAT2 */ +#line 2389 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 2); } -#line 8641 "MachineIndependent/glslang_tab.cpp" +#line 8897 "MachineIndependent/glslang_tab.cpp" break; - case 316: /* type_specifier_nonarray: F16MAT3 */ -#line 2343 "MachineIndependent/glslang.y" + case 325: /* type_specifier_nonarray: F16MAT3 */ +#line 2395 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(3, 3); } -#line 8652 "MachineIndependent/glslang_tab.cpp" +#line 8908 "MachineIndependent/glslang_tab.cpp" break; - case 317: /* type_specifier_nonarray: F16MAT4 */ -#line 2349 "MachineIndependent/glslang.y" + case 326: /* type_specifier_nonarray: F16MAT4 */ +#line 2401 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 4); } -#line 8663 "MachineIndependent/glslang_tab.cpp" +#line 8919 "MachineIndependent/glslang_tab.cpp" break; - case 318: /* type_specifier_nonarray: F16MAT2X2 */ -#line 2355 "MachineIndependent/glslang.y" + case 327: /* type_specifier_nonarray: F16MAT2X2 */ +#line 2407 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 2); } -#line 8674 "MachineIndependent/glslang_tab.cpp" +#line 8930 "MachineIndependent/glslang_tab.cpp" break; - case 319: /* type_specifier_nonarray: F16MAT2X3 */ -#line 2361 "MachineIndependent/glslang.y" + case 328: /* type_specifier_nonarray: F16MAT2X3 */ +#line 2413 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 3); } -#line 8685 "MachineIndependent/glslang_tab.cpp" +#line 8941 "MachineIndependent/glslang_tab.cpp" break; - case 320: /* type_specifier_nonarray: F16MAT2X4 */ -#line 2367 "MachineIndependent/glslang.y" + case 329: /* type_specifier_nonarray: F16MAT2X4 */ +#line 2419 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(2, 4); } -#line 8696 "MachineIndependent/glslang_tab.cpp" +#line 8952 "MachineIndependent/glslang_tab.cpp" break; - case 321: /* type_specifier_nonarray: F16MAT3X2 */ -#line 2373 "MachineIndependent/glslang.y" + case 330: /* type_specifier_nonarray: F16MAT3X2 */ +#line 2425 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(3, 2); } -#line 8707 "MachineIndependent/glslang_tab.cpp" +#line 8963 "MachineIndependent/glslang_tab.cpp" break; - case 322: /* type_specifier_nonarray: F16MAT3X3 */ -#line 2379 "MachineIndependent/glslang.y" + case 331: /* type_specifier_nonarray: F16MAT3X3 */ +#line 2431 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(3, 3); } -#line 8718 "MachineIndependent/glslang_tab.cpp" +#line 8974 "MachineIndependent/glslang_tab.cpp" break; - case 323: /* type_specifier_nonarray: F16MAT3X4 */ -#line 2385 "MachineIndependent/glslang.y" + case 332: /* type_specifier_nonarray: F16MAT3X4 */ +#line 2437 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(3, 4); } -#line 8729 "MachineIndependent/glslang_tab.cpp" +#line 8985 "MachineIndependent/glslang_tab.cpp" break; - case 324: /* type_specifier_nonarray: F16MAT4X2 */ -#line 2391 "MachineIndependent/glslang.y" + case 333: /* type_specifier_nonarray: F16MAT4X2 */ +#line 2443 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 2); } -#line 8740 "MachineIndependent/glslang_tab.cpp" +#line 8996 "MachineIndependent/glslang_tab.cpp" break; - case 325: /* type_specifier_nonarray: F16MAT4X3 */ -#line 2397 "MachineIndependent/glslang.y" + case 334: /* type_specifier_nonarray: F16MAT4X3 */ +#line 2449 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 3); } -#line 8751 "MachineIndependent/glslang_tab.cpp" +#line 9007 "MachineIndependent/glslang_tab.cpp" break; - case 326: /* type_specifier_nonarray: F16MAT4X4 */ -#line 2403 "MachineIndependent/glslang.y" + case 335: /* type_specifier_nonarray: F16MAT4X4 */ +#line 2455 "MachineIndependent/glslang.y" { parseContext.float16Check((yyvsp[0].lex).loc, "half float matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat16; (yyval.interm.type).setMatrix(4, 4); } -#line 8762 "MachineIndependent/glslang_tab.cpp" +#line 9018 "MachineIndependent/glslang_tab.cpp" break; - case 327: /* type_specifier_nonarray: F32MAT2 */ -#line 2409 "MachineIndependent/glslang.y" + case 336: /* type_specifier_nonarray: F32MAT2 */ +#line 2461 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } -#line 8773 "MachineIndependent/glslang_tab.cpp" +#line 9029 "MachineIndependent/glslang_tab.cpp" break; - case 328: /* type_specifier_nonarray: F32MAT3 */ -#line 2415 "MachineIndependent/glslang.y" + case 337: /* type_specifier_nonarray: F32MAT3 */ +#line 2467 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 8784 "MachineIndependent/glslang_tab.cpp" +#line 9040 "MachineIndependent/glslang_tab.cpp" break; - case 329: /* type_specifier_nonarray: F32MAT4 */ -#line 2421 "MachineIndependent/glslang.y" + case 338: /* type_specifier_nonarray: F32MAT4 */ +#line 2473 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 8795 "MachineIndependent/glslang_tab.cpp" +#line 9051 "MachineIndependent/glslang_tab.cpp" break; - case 330: /* type_specifier_nonarray: F32MAT2X2 */ -#line 2427 "MachineIndependent/glslang.y" + case 339: /* type_specifier_nonarray: F32MAT2X2 */ +#line 2479 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 2); } -#line 8806 "MachineIndependent/glslang_tab.cpp" +#line 9062 "MachineIndependent/glslang_tab.cpp" break; - case 331: /* type_specifier_nonarray: F32MAT2X3 */ -#line 2433 "MachineIndependent/glslang.y" + case 340: /* type_specifier_nonarray: F32MAT2X3 */ +#line 2485 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 3); } -#line 8817 "MachineIndependent/glslang_tab.cpp" +#line 9073 "MachineIndependent/glslang_tab.cpp" break; - case 332: /* type_specifier_nonarray: F32MAT2X4 */ -#line 2439 "MachineIndependent/glslang.y" + case 341: /* type_specifier_nonarray: F32MAT2X4 */ +#line 2491 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(2, 4); } -#line 8828 "MachineIndependent/glslang_tab.cpp" +#line 9084 "MachineIndependent/glslang_tab.cpp" break; - case 333: /* type_specifier_nonarray: F32MAT3X2 */ -#line 2445 "MachineIndependent/glslang.y" + case 342: /* type_specifier_nonarray: F32MAT3X2 */ +#line 2497 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 2); } -#line 8839 "MachineIndependent/glslang_tab.cpp" +#line 9095 "MachineIndependent/glslang_tab.cpp" break; - case 334: /* type_specifier_nonarray: F32MAT3X3 */ -#line 2451 "MachineIndependent/glslang.y" + case 343: /* type_specifier_nonarray: F32MAT3X3 */ +#line 2503 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 3); } -#line 8850 "MachineIndependent/glslang_tab.cpp" +#line 9106 "MachineIndependent/glslang_tab.cpp" break; - case 335: /* type_specifier_nonarray: F32MAT3X4 */ -#line 2457 "MachineIndependent/glslang.y" + case 344: /* type_specifier_nonarray: F32MAT3X4 */ +#line 2509 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(3, 4); } -#line 8861 "MachineIndependent/glslang_tab.cpp" +#line 9117 "MachineIndependent/glslang_tab.cpp" break; - case 336: /* type_specifier_nonarray: F32MAT4X2 */ -#line 2463 "MachineIndependent/glslang.y" + case 345: /* type_specifier_nonarray: F32MAT4X2 */ +#line 2515 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 2); } -#line 8872 "MachineIndependent/glslang_tab.cpp" +#line 9128 "MachineIndependent/glslang_tab.cpp" break; - case 337: /* type_specifier_nonarray: F32MAT4X3 */ -#line 2469 "MachineIndependent/glslang.y" + case 346: /* type_specifier_nonarray: F32MAT4X3 */ +#line 2521 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 3); } -#line 8883 "MachineIndependent/glslang_tab.cpp" +#line 9139 "MachineIndependent/glslang_tab.cpp" break; - case 338: /* type_specifier_nonarray: F32MAT4X4 */ -#line 2475 "MachineIndependent/glslang.y" + case 347: /* type_specifier_nonarray: F32MAT4X4 */ +#line 2527 "MachineIndependent/glslang.y" { parseContext.explicitFloat32Check((yyvsp[0].lex).loc, "float32_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtFloat; (yyval.interm.type).setMatrix(4, 4); } -#line 8894 "MachineIndependent/glslang_tab.cpp" +#line 9150 "MachineIndependent/glslang_tab.cpp" break; - case 339: /* type_specifier_nonarray: F64MAT2 */ -#line 2481 "MachineIndependent/glslang.y" + case 348: /* type_specifier_nonarray: F64MAT2 */ +#line 2533 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 8905 "MachineIndependent/glslang_tab.cpp" +#line 9161 "MachineIndependent/glslang_tab.cpp" break; - case 340: /* type_specifier_nonarray: F64MAT3 */ -#line 2487 "MachineIndependent/glslang.y" + case 349: /* type_specifier_nonarray: F64MAT3 */ +#line 2539 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 8916 "MachineIndependent/glslang_tab.cpp" +#line 9172 "MachineIndependent/glslang_tab.cpp" break; - case 341: /* type_specifier_nonarray: F64MAT4 */ -#line 2493 "MachineIndependent/glslang.y" + case 350: /* type_specifier_nonarray: F64MAT4 */ +#line 2545 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 8927 "MachineIndependent/glslang_tab.cpp" +#line 9183 "MachineIndependent/glslang_tab.cpp" break; - case 342: /* type_specifier_nonarray: F64MAT2X2 */ -#line 2499 "MachineIndependent/glslang.y" + case 351: /* type_specifier_nonarray: F64MAT2X2 */ +#line 2551 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 2); } -#line 8938 "MachineIndependent/glslang_tab.cpp" +#line 9194 "MachineIndependent/glslang_tab.cpp" break; - case 343: /* type_specifier_nonarray: F64MAT2X3 */ -#line 2505 "MachineIndependent/glslang.y" + case 352: /* type_specifier_nonarray: F64MAT2X3 */ +#line 2557 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 3); } -#line 8949 "MachineIndependent/glslang_tab.cpp" +#line 9205 "MachineIndependent/glslang_tab.cpp" break; - case 344: /* type_specifier_nonarray: F64MAT2X4 */ -#line 2511 "MachineIndependent/glslang.y" + case 353: /* type_specifier_nonarray: F64MAT2X4 */ +#line 2563 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(2, 4); } -#line 8960 "MachineIndependent/glslang_tab.cpp" +#line 9216 "MachineIndependent/glslang_tab.cpp" break; - case 345: /* type_specifier_nonarray: F64MAT3X2 */ -#line 2517 "MachineIndependent/glslang.y" + case 354: /* type_specifier_nonarray: F64MAT3X2 */ +#line 2569 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 2); } -#line 8971 "MachineIndependent/glslang_tab.cpp" +#line 9227 "MachineIndependent/glslang_tab.cpp" break; - case 346: /* type_specifier_nonarray: F64MAT3X3 */ -#line 2523 "MachineIndependent/glslang.y" + case 355: /* type_specifier_nonarray: F64MAT3X3 */ +#line 2575 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 3); } -#line 8982 "MachineIndependent/glslang_tab.cpp" +#line 9238 "MachineIndependent/glslang_tab.cpp" break; - case 347: /* type_specifier_nonarray: F64MAT3X4 */ -#line 2529 "MachineIndependent/glslang.y" + case 356: /* type_specifier_nonarray: F64MAT3X4 */ +#line 2581 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(3, 4); } -#line 8993 "MachineIndependent/glslang_tab.cpp" +#line 9249 "MachineIndependent/glslang_tab.cpp" break; - case 348: /* type_specifier_nonarray: F64MAT4X2 */ -#line 2535 "MachineIndependent/glslang.y" + case 357: /* type_specifier_nonarray: F64MAT4X2 */ +#line 2587 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 2); } -#line 9004 "MachineIndependent/glslang_tab.cpp" +#line 9260 "MachineIndependent/glslang_tab.cpp" break; - case 349: /* type_specifier_nonarray: F64MAT4X3 */ -#line 2541 "MachineIndependent/glslang.y" + case 358: /* type_specifier_nonarray: F64MAT4X3 */ +#line 2593 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 3); } -#line 9015 "MachineIndependent/glslang_tab.cpp" +#line 9271 "MachineIndependent/glslang_tab.cpp" break; - case 350: /* type_specifier_nonarray: F64MAT4X4 */ -#line 2547 "MachineIndependent/glslang.y" + case 359: /* type_specifier_nonarray: F64MAT4X4 */ +#line 2599 "MachineIndependent/glslang.y" { parseContext.explicitFloat64Check((yyvsp[0].lex).loc, "float64_t matrix", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtDouble; (yyval.interm.type).setMatrix(4, 4); } -#line 9026 "MachineIndependent/glslang_tab.cpp" +#line 9282 "MachineIndependent/glslang_tab.cpp" break; - case 351: /* type_specifier_nonarray: ACCSTRUCTNV */ -#line 2553 "MachineIndependent/glslang.y" + case 360: /* type_specifier_nonarray: ACCSTRUCTNV */ +#line 2605 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAccStruct; } -#line 9035 "MachineIndependent/glslang_tab.cpp" +#line 9291 "MachineIndependent/glslang_tab.cpp" break; - case 352: /* type_specifier_nonarray: ACCSTRUCTEXT */ -#line 2557 "MachineIndependent/glslang.y" + case 361: /* type_specifier_nonarray: ACCSTRUCTEXT */ +#line 2609 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAccStruct; } -#line 9044 "MachineIndependent/glslang_tab.cpp" +#line 9300 "MachineIndependent/glslang_tab.cpp" break; - case 353: /* type_specifier_nonarray: RAYQUERYEXT */ -#line 2561 "MachineIndependent/glslang.y" + case 362: /* type_specifier_nonarray: RAYQUERYEXT */ +#line 2613 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtRayQuery; } -#line 9053 "MachineIndependent/glslang_tab.cpp" +#line 9309 "MachineIndependent/glslang_tab.cpp" break; - case 354: /* type_specifier_nonarray: ATOMIC_UINT */ -#line 2565 "MachineIndependent/glslang.y" + case 363: /* type_specifier_nonarray: ATOMIC_UINT */ +#line 2617 "MachineIndependent/glslang.y" { parseContext.vulkanRemoved((yyvsp[0].lex).loc, "atomic counter types"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtAtomicUint; } -#line 9063 "MachineIndependent/glslang_tab.cpp" +#line 9319 "MachineIndependent/glslang_tab.cpp" break; - case 355: /* type_specifier_nonarray: SAMPLER1D */ -#line 2570 "MachineIndependent/glslang.y" + case 364: /* type_specifier_nonarray: SAMPLER1D */ +#line 2622 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D); } -#line 9073 "MachineIndependent/glslang_tab.cpp" +#line 9329 "MachineIndependent/glslang_tab.cpp" break; - case 356: /* type_specifier_nonarray: SAMPLER2D */ -#line 2575 "MachineIndependent/glslang.y" + case 365: /* type_specifier_nonarray: SAMPLER2D */ +#line 2627 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); } -#line 9083 "MachineIndependent/glslang_tab.cpp" +#line 9339 "MachineIndependent/glslang_tab.cpp" break; - case 357: /* type_specifier_nonarray: SAMPLER3D */ -#line 2580 "MachineIndependent/glslang.y" + case 366: /* type_specifier_nonarray: SAMPLER3D */ +#line 2632 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd3D); } -#line 9093 "MachineIndependent/glslang_tab.cpp" +#line 9349 "MachineIndependent/glslang_tab.cpp" break; - case 358: /* type_specifier_nonarray: SAMPLERCUBE */ -#line 2585 "MachineIndependent/glslang.y" + case 367: /* type_specifier_nonarray: SAMPLERCUBE */ +#line 2637 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube); } -#line 9103 "MachineIndependent/glslang_tab.cpp" +#line 9359 "MachineIndependent/glslang_tab.cpp" break; - case 359: /* type_specifier_nonarray: SAMPLER2DSHADOW */ -#line 2590 "MachineIndependent/glslang.y" + case 368: /* type_specifier_nonarray: SAMPLER2DSHADOW */ +#line 2642 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, true); } -#line 9113 "MachineIndependent/glslang_tab.cpp" +#line 9369 "MachineIndependent/glslang_tab.cpp" break; - case 360: /* type_specifier_nonarray: SAMPLERCUBESHADOW */ -#line 2595 "MachineIndependent/glslang.y" + case 369: /* type_specifier_nonarray: SAMPLERCUBESHADOW */ +#line 2647 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, false, true); } -#line 9123 "MachineIndependent/glslang_tab.cpp" +#line 9379 "MachineIndependent/glslang_tab.cpp" break; - case 361: /* type_specifier_nonarray: SAMPLER2DARRAY */ -#line 2600 "MachineIndependent/glslang.y" + case 370: /* type_specifier_nonarray: SAMPLER2DARRAY */ +#line 2652 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true); } -#line 9133 "MachineIndependent/glslang_tab.cpp" +#line 9389 "MachineIndependent/glslang_tab.cpp" break; - case 362: /* type_specifier_nonarray: SAMPLER2DARRAYSHADOW */ -#line 2605 "MachineIndependent/glslang.y" + case 371: /* type_specifier_nonarray: SAMPLER2DARRAYSHADOW */ +#line 2657 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, true); } -#line 9143 "MachineIndependent/glslang_tab.cpp" +#line 9399 "MachineIndependent/glslang_tab.cpp" break; - case 363: /* type_specifier_nonarray: SAMPLER1DSHADOW */ -#line 2610 "MachineIndependent/glslang.y" + case 372: /* type_specifier_nonarray: SAMPLER1DSHADOW */ +#line 2662 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, false, true); } -#line 9153 "MachineIndependent/glslang_tab.cpp" +#line 9409 "MachineIndependent/glslang_tab.cpp" break; - case 364: /* type_specifier_nonarray: SAMPLER1DARRAY */ -#line 2615 "MachineIndependent/glslang.y" + case 373: /* type_specifier_nonarray: SAMPLER1DARRAY */ +#line 2667 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true); } -#line 9163 "MachineIndependent/glslang_tab.cpp" +#line 9419 "MachineIndependent/glslang_tab.cpp" break; - case 365: /* type_specifier_nonarray: SAMPLER1DARRAYSHADOW */ -#line 2620 "MachineIndependent/glslang.y" + case 374: /* type_specifier_nonarray: SAMPLER1DARRAYSHADOW */ +#line 2672 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd1D, true, true); } -#line 9173 "MachineIndependent/glslang_tab.cpp" +#line 9429 "MachineIndependent/glslang_tab.cpp" break; - case 366: /* type_specifier_nonarray: SAMPLERCUBEARRAY */ -#line 2625 "MachineIndependent/glslang.y" + case 375: /* type_specifier_nonarray: SAMPLERCUBEARRAY */ +#line 2677 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true); } -#line 9183 "MachineIndependent/glslang_tab.cpp" +#line 9439 "MachineIndependent/glslang_tab.cpp" break; - case 367: /* type_specifier_nonarray: SAMPLERCUBEARRAYSHADOW */ -#line 2630 "MachineIndependent/glslang.y" + case 376: /* type_specifier_nonarray: SAMPLERCUBEARRAYSHADOW */ +#line 2682 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdCube, true, true); } -#line 9193 "MachineIndependent/glslang_tab.cpp" +#line 9449 "MachineIndependent/glslang_tab.cpp" break; - case 368: /* type_specifier_nonarray: F16SAMPLER1D */ -#line 2635 "MachineIndependent/glslang.y" + case 377: /* type_specifier_nonarray: F16SAMPLER1D */ +#line 2687 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D); } -#line 9204 "MachineIndependent/glslang_tab.cpp" +#line 9460 "MachineIndependent/glslang_tab.cpp" break; - case 369: /* type_specifier_nonarray: F16SAMPLER2D */ -#line 2641 "MachineIndependent/glslang.y" + case 378: /* type_specifier_nonarray: F16SAMPLER2D */ +#line 2693 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D); } -#line 9215 "MachineIndependent/glslang_tab.cpp" +#line 9471 "MachineIndependent/glslang_tab.cpp" break; - case 370: /* type_specifier_nonarray: F16SAMPLER3D */ -#line 2647 "MachineIndependent/glslang.y" + case 379: /* type_specifier_nonarray: F16SAMPLER3D */ +#line 2699 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd3D); } -#line 9226 "MachineIndependent/glslang_tab.cpp" +#line 9482 "MachineIndependent/glslang_tab.cpp" break; - case 371: /* type_specifier_nonarray: F16SAMPLERCUBE */ -#line 2653 "MachineIndependent/glslang.y" + case 380: /* type_specifier_nonarray: F16SAMPLERCUBE */ +#line 2705 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube); } -#line 9237 "MachineIndependent/glslang_tab.cpp" +#line 9493 "MachineIndependent/glslang_tab.cpp" break; - case 372: /* type_specifier_nonarray: F16SAMPLER1DSHADOW */ -#line 2659 "MachineIndependent/glslang.y" + case 381: /* type_specifier_nonarray: F16SAMPLER1DSHADOW */ +#line 2711 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, false, true); } -#line 9248 "MachineIndependent/glslang_tab.cpp" +#line 9504 "MachineIndependent/glslang_tab.cpp" break; - case 373: /* type_specifier_nonarray: F16SAMPLER2DSHADOW */ -#line 2665 "MachineIndependent/glslang.y" + case 382: /* type_specifier_nonarray: F16SAMPLER2DSHADOW */ +#line 2717 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, true); } -#line 9259 "MachineIndependent/glslang_tab.cpp" +#line 9515 "MachineIndependent/glslang_tab.cpp" break; - case 374: /* type_specifier_nonarray: F16SAMPLERCUBESHADOW */ -#line 2671 "MachineIndependent/glslang.y" + case 383: /* type_specifier_nonarray: F16SAMPLERCUBESHADOW */ +#line 2723 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, false, true); } -#line 9270 "MachineIndependent/glslang_tab.cpp" +#line 9526 "MachineIndependent/glslang_tab.cpp" break; - case 375: /* type_specifier_nonarray: F16SAMPLER1DARRAY */ -#line 2677 "MachineIndependent/glslang.y" + case 384: /* type_specifier_nonarray: F16SAMPLER1DARRAY */ +#line 2729 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true); } -#line 9281 "MachineIndependent/glslang_tab.cpp" +#line 9537 "MachineIndependent/glslang_tab.cpp" break; - case 376: /* type_specifier_nonarray: F16SAMPLER2DARRAY */ -#line 2683 "MachineIndependent/glslang.y" + case 385: /* type_specifier_nonarray: F16SAMPLER2DARRAY */ +#line 2735 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true); } -#line 9292 "MachineIndependent/glslang_tab.cpp" +#line 9548 "MachineIndependent/glslang_tab.cpp" break; - case 377: /* type_specifier_nonarray: F16SAMPLER1DARRAYSHADOW */ -#line 2689 "MachineIndependent/glslang.y" + case 386: /* type_specifier_nonarray: F16SAMPLER1DARRAYSHADOW */ +#line 2741 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd1D, true, true); } -#line 9303 "MachineIndependent/glslang_tab.cpp" +#line 9559 "MachineIndependent/glslang_tab.cpp" break; - case 378: /* type_specifier_nonarray: F16SAMPLER2DARRAYSHADOW */ -#line 2695 "MachineIndependent/glslang.y" + case 387: /* type_specifier_nonarray: F16SAMPLER2DARRAYSHADOW */ +#line 2747 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, true); } -#line 9314 "MachineIndependent/glslang_tab.cpp" +#line 9570 "MachineIndependent/glslang_tab.cpp" break; - case 379: /* type_specifier_nonarray: F16SAMPLERCUBEARRAY */ -#line 2701 "MachineIndependent/glslang.y" + case 388: /* type_specifier_nonarray: F16SAMPLERCUBEARRAY */ +#line 2753 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true); } -#line 9325 "MachineIndependent/glslang_tab.cpp" +#line 9581 "MachineIndependent/glslang_tab.cpp" break; - case 380: /* type_specifier_nonarray: F16SAMPLERCUBEARRAYSHADOW */ -#line 2707 "MachineIndependent/glslang.y" + case 389: /* type_specifier_nonarray: F16SAMPLERCUBEARRAYSHADOW */ +#line 2759 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdCube, true, true); } -#line 9336 "MachineIndependent/glslang_tab.cpp" +#line 9592 "MachineIndependent/glslang_tab.cpp" break; - case 381: /* type_specifier_nonarray: ISAMPLER1D */ -#line 2713 "MachineIndependent/glslang.y" + case 390: /* type_specifier_nonarray: ISAMPLER1D */ +#line 2765 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd1D); } -#line 9346 "MachineIndependent/glslang_tab.cpp" +#line 9602 "MachineIndependent/glslang_tab.cpp" break; - case 382: /* type_specifier_nonarray: ISAMPLER2D */ -#line 2718 "MachineIndependent/glslang.y" + case 391: /* type_specifier_nonarray: ISAMPLER2D */ +#line 2770 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D); } -#line 9356 "MachineIndependent/glslang_tab.cpp" +#line 9612 "MachineIndependent/glslang_tab.cpp" break; - case 383: /* type_specifier_nonarray: ISAMPLER3D */ -#line 2723 "MachineIndependent/glslang.y" + case 392: /* type_specifier_nonarray: ISAMPLER3D */ +#line 2775 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd3D); } -#line 9366 "MachineIndependent/glslang_tab.cpp" +#line 9622 "MachineIndependent/glslang_tab.cpp" break; - case 384: /* type_specifier_nonarray: ISAMPLERCUBE */ -#line 2728 "MachineIndependent/glslang.y" + case 393: /* type_specifier_nonarray: ISAMPLERCUBE */ +#line 2780 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdCube); } -#line 9376 "MachineIndependent/glslang_tab.cpp" +#line 9632 "MachineIndependent/glslang_tab.cpp" break; - case 385: /* type_specifier_nonarray: ISAMPLER2DARRAY */ -#line 2733 "MachineIndependent/glslang.y" + case 394: /* type_specifier_nonarray: ISAMPLER2DARRAY */ +#line 2785 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, true); } -#line 9386 "MachineIndependent/glslang_tab.cpp" +#line 9642 "MachineIndependent/glslang_tab.cpp" break; - case 386: /* type_specifier_nonarray: USAMPLER2D */ -#line 2738 "MachineIndependent/glslang.y" + case 395: /* type_specifier_nonarray: USAMPLER2D */ +#line 2790 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D); } -#line 9396 "MachineIndependent/glslang_tab.cpp" +#line 9652 "MachineIndependent/glslang_tab.cpp" break; - case 387: /* type_specifier_nonarray: USAMPLER3D */ -#line 2743 "MachineIndependent/glslang.y" + case 396: /* type_specifier_nonarray: USAMPLER3D */ +#line 2795 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd3D); } -#line 9406 "MachineIndependent/glslang_tab.cpp" +#line 9662 "MachineIndependent/glslang_tab.cpp" break; - case 388: /* type_specifier_nonarray: USAMPLERCUBE */ -#line 2748 "MachineIndependent/glslang.y" + case 397: /* type_specifier_nonarray: USAMPLERCUBE */ +#line 2800 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdCube); } -#line 9416 "MachineIndependent/glslang_tab.cpp" +#line 9672 "MachineIndependent/glslang_tab.cpp" break; - case 389: /* type_specifier_nonarray: ISAMPLER1DARRAY */ -#line 2753 "MachineIndependent/glslang.y" + case 398: /* type_specifier_nonarray: ISAMPLER1DARRAY */ +#line 2805 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd1D, true); } -#line 9426 "MachineIndependent/glslang_tab.cpp" +#line 9682 "MachineIndependent/glslang_tab.cpp" break; - case 390: /* type_specifier_nonarray: ISAMPLERCUBEARRAY */ -#line 2758 "MachineIndependent/glslang.y" + case 399: /* type_specifier_nonarray: ISAMPLERCUBEARRAY */ +#line 2810 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdCube, true); } -#line 9436 "MachineIndependent/glslang_tab.cpp" +#line 9692 "MachineIndependent/glslang_tab.cpp" break; - case 391: /* type_specifier_nonarray: USAMPLER1D */ -#line 2763 "MachineIndependent/glslang.y" + case 400: /* type_specifier_nonarray: USAMPLER1D */ +#line 2815 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd1D); } -#line 9446 "MachineIndependent/glslang_tab.cpp" +#line 9702 "MachineIndependent/glslang_tab.cpp" break; - case 392: /* type_specifier_nonarray: USAMPLER1DARRAY */ -#line 2768 "MachineIndependent/glslang.y" + case 401: /* type_specifier_nonarray: USAMPLER1DARRAY */ +#line 2820 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd1D, true); } -#line 9456 "MachineIndependent/glslang_tab.cpp" +#line 9712 "MachineIndependent/glslang_tab.cpp" break; - case 393: /* type_specifier_nonarray: USAMPLERCUBEARRAY */ -#line 2773 "MachineIndependent/glslang.y" + case 402: /* type_specifier_nonarray: USAMPLERCUBEARRAY */ +#line 2825 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdCube, true); } -#line 9466 "MachineIndependent/glslang_tab.cpp" +#line 9722 "MachineIndependent/glslang_tab.cpp" break; - case 394: /* type_specifier_nonarray: TEXTURECUBEARRAY */ -#line 2778 "MachineIndependent/glslang.y" + case 403: /* type_specifier_nonarray: TEXTURECUBEARRAY */ +#line 2830 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube, true); } -#line 9476 "MachineIndependent/glslang_tab.cpp" +#line 9732 "MachineIndependent/glslang_tab.cpp" break; - case 395: /* type_specifier_nonarray: ITEXTURECUBEARRAY */ -#line 2783 "MachineIndependent/glslang.y" + case 404: /* type_specifier_nonarray: ITEXTURECUBEARRAY */ +#line 2835 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube, true); } -#line 9486 "MachineIndependent/glslang_tab.cpp" +#line 9742 "MachineIndependent/glslang_tab.cpp" break; - case 396: /* type_specifier_nonarray: UTEXTURECUBEARRAY */ -#line 2788 "MachineIndependent/glslang.y" + case 405: /* type_specifier_nonarray: UTEXTURECUBEARRAY */ +#line 2840 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube, true); } -#line 9496 "MachineIndependent/glslang_tab.cpp" +#line 9752 "MachineIndependent/glslang_tab.cpp" break; - case 397: /* type_specifier_nonarray: USAMPLER2DARRAY */ -#line 2793 "MachineIndependent/glslang.y" + case 406: /* type_specifier_nonarray: USAMPLER2DARRAY */ +#line 2845 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, true); } -#line 9506 "MachineIndependent/glslang_tab.cpp" +#line 9762 "MachineIndependent/glslang_tab.cpp" break; - case 398: /* type_specifier_nonarray: TEXTURE2D */ -#line 2798 "MachineIndependent/glslang.y" + case 407: /* type_specifier_nonarray: TEXTURE2D */ +#line 2850 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D); } -#line 9516 "MachineIndependent/glslang_tab.cpp" +#line 9772 "MachineIndependent/glslang_tab.cpp" break; - case 399: /* type_specifier_nonarray: TEXTURE3D */ -#line 2803 "MachineIndependent/glslang.y" + case 408: /* type_specifier_nonarray: TEXTURE3D */ +#line 2855 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd3D); } -#line 9526 "MachineIndependent/glslang_tab.cpp" +#line 9782 "MachineIndependent/glslang_tab.cpp" break; - case 400: /* type_specifier_nonarray: TEXTURE2DARRAY */ -#line 2808 "MachineIndependent/glslang.y" + case 409: /* type_specifier_nonarray: TEXTURE2DARRAY */ +#line 2860 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true); } -#line 9536 "MachineIndependent/glslang_tab.cpp" +#line 9792 "MachineIndependent/glslang_tab.cpp" break; - case 401: /* type_specifier_nonarray: TEXTURECUBE */ -#line 2813 "MachineIndependent/glslang.y" + case 410: /* type_specifier_nonarray: TEXTURECUBE */ +#line 2865 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdCube); } -#line 9546 "MachineIndependent/glslang_tab.cpp" +#line 9802 "MachineIndependent/glslang_tab.cpp" break; - case 402: /* type_specifier_nonarray: ITEXTURE2D */ -#line 2818 "MachineIndependent/glslang.y" + case 411: /* type_specifier_nonarray: ITEXTURE2D */ +#line 2870 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D); } -#line 9556 "MachineIndependent/glslang_tab.cpp" +#line 9812 "MachineIndependent/glslang_tab.cpp" break; - case 403: /* type_specifier_nonarray: ITEXTURE3D */ -#line 2823 "MachineIndependent/glslang.y" + case 412: /* type_specifier_nonarray: ITEXTURE3D */ +#line 2875 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd3D); } -#line 9566 "MachineIndependent/glslang_tab.cpp" +#line 9822 "MachineIndependent/glslang_tab.cpp" break; - case 404: /* type_specifier_nonarray: ITEXTURECUBE */ -#line 2828 "MachineIndependent/glslang.y" + case 413: /* type_specifier_nonarray: ITEXTURECUBE */ +#line 2880 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdCube); } -#line 9576 "MachineIndependent/glslang_tab.cpp" +#line 9832 "MachineIndependent/glslang_tab.cpp" break; - case 405: /* type_specifier_nonarray: ITEXTURE2DARRAY */ -#line 2833 "MachineIndependent/glslang.y" + case 414: /* type_specifier_nonarray: ITEXTURE2DARRAY */ +#line 2885 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true); } -#line 9586 "MachineIndependent/glslang_tab.cpp" +#line 9842 "MachineIndependent/glslang_tab.cpp" break; - case 406: /* type_specifier_nonarray: UTEXTURE2D */ -#line 2838 "MachineIndependent/glslang.y" + case 415: /* type_specifier_nonarray: UTEXTURE2D */ +#line 2890 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D); } -#line 9596 "MachineIndependent/glslang_tab.cpp" +#line 9852 "MachineIndependent/glslang_tab.cpp" break; - case 407: /* type_specifier_nonarray: UTEXTURE3D */ -#line 2843 "MachineIndependent/glslang.y" + case 416: /* type_specifier_nonarray: UTEXTURE3D */ +#line 2895 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd3D); } -#line 9606 "MachineIndependent/glslang_tab.cpp" +#line 9862 "MachineIndependent/glslang_tab.cpp" break; - case 408: /* type_specifier_nonarray: UTEXTURECUBE */ -#line 2848 "MachineIndependent/glslang.y" + case 417: /* type_specifier_nonarray: UTEXTURECUBE */ +#line 2900 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdCube); } -#line 9616 "MachineIndependent/glslang_tab.cpp" +#line 9872 "MachineIndependent/glslang_tab.cpp" break; - case 409: /* type_specifier_nonarray: UTEXTURE2DARRAY */ -#line 2853 "MachineIndependent/glslang.y" + case 418: /* type_specifier_nonarray: UTEXTURE2DARRAY */ +#line 2905 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true); } -#line 9626 "MachineIndependent/glslang_tab.cpp" +#line 9882 "MachineIndependent/glslang_tab.cpp" break; - case 410: /* type_specifier_nonarray: SAMPLER */ -#line 2858 "MachineIndependent/glslang.y" + case 419: /* type_specifier_nonarray: SAMPLER */ +#line 2910 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setPureSampler(false); } -#line 9636 "MachineIndependent/glslang_tab.cpp" +#line 9892 "MachineIndependent/glslang_tab.cpp" break; - case 411: /* type_specifier_nonarray: SAMPLERSHADOW */ -#line 2863 "MachineIndependent/glslang.y" + case 420: /* type_specifier_nonarray: SAMPLERSHADOW */ +#line 2915 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setPureSampler(true); } -#line 9646 "MachineIndependent/glslang_tab.cpp" +#line 9902 "MachineIndependent/glslang_tab.cpp" break; - case 412: /* type_specifier_nonarray: SAMPLER2DRECT */ -#line 2868 "MachineIndependent/glslang.y" + case 421: /* type_specifier_nonarray: SAMPLER2DRECT */ +#line 2920 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdRect); } -#line 9656 "MachineIndependent/glslang_tab.cpp" +#line 9912 "MachineIndependent/glslang_tab.cpp" break; - case 413: /* type_specifier_nonarray: SAMPLER2DRECTSHADOW */ -#line 2873 "MachineIndependent/glslang.y" + case 422: /* type_specifier_nonarray: SAMPLER2DRECTSHADOW */ +#line 2925 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdRect, false, true); } -#line 9666 "MachineIndependent/glslang_tab.cpp" +#line 9922 "MachineIndependent/glslang_tab.cpp" break; - case 414: /* type_specifier_nonarray: F16SAMPLER2DRECT */ -#line 2878 "MachineIndependent/glslang.y" + case 423: /* type_specifier_nonarray: F16SAMPLER2DRECT */ +#line 2930 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdRect); } -#line 9677 "MachineIndependent/glslang_tab.cpp" +#line 9933 "MachineIndependent/glslang_tab.cpp" break; - case 415: /* type_specifier_nonarray: F16SAMPLER2DRECTSHADOW */ -#line 2884 "MachineIndependent/glslang.y" + case 424: /* type_specifier_nonarray: F16SAMPLER2DRECTSHADOW */ +#line 2936 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdRect, false, true); } -#line 9688 "MachineIndependent/glslang_tab.cpp" +#line 9944 "MachineIndependent/glslang_tab.cpp" break; - case 416: /* type_specifier_nonarray: ISAMPLER2DRECT */ -#line 2890 "MachineIndependent/glslang.y" + case 425: /* type_specifier_nonarray: ISAMPLER2DRECT */ +#line 2942 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdRect); } -#line 9698 "MachineIndependent/glslang_tab.cpp" +#line 9954 "MachineIndependent/glslang_tab.cpp" break; - case 417: /* type_specifier_nonarray: USAMPLER2DRECT */ -#line 2895 "MachineIndependent/glslang.y" + case 426: /* type_specifier_nonarray: USAMPLER2DRECT */ +#line 2947 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdRect); } -#line 9708 "MachineIndependent/glslang_tab.cpp" +#line 9964 "MachineIndependent/glslang_tab.cpp" break; - case 418: /* type_specifier_nonarray: SAMPLERBUFFER */ -#line 2900 "MachineIndependent/glslang.y" + case 427: /* type_specifier_nonarray: SAMPLERBUFFER */ +#line 2952 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, EsdBuffer); } -#line 9718 "MachineIndependent/glslang_tab.cpp" +#line 9974 "MachineIndependent/glslang_tab.cpp" break; - case 419: /* type_specifier_nonarray: F16SAMPLERBUFFER */ -#line 2905 "MachineIndependent/glslang.y" + case 428: /* type_specifier_nonarray: F16SAMPLERBUFFER */ +#line 2957 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, EsdBuffer); } -#line 9729 "MachineIndependent/glslang_tab.cpp" +#line 9985 "MachineIndependent/glslang_tab.cpp" break; - case 420: /* type_specifier_nonarray: ISAMPLERBUFFER */ -#line 2911 "MachineIndependent/glslang.y" + case 429: /* type_specifier_nonarray: ISAMPLERBUFFER */ +#line 2963 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, EsdBuffer); } -#line 9739 "MachineIndependent/glslang_tab.cpp" +#line 9995 "MachineIndependent/glslang_tab.cpp" break; - case 421: /* type_specifier_nonarray: USAMPLERBUFFER */ -#line 2916 "MachineIndependent/glslang.y" + case 430: /* type_specifier_nonarray: USAMPLERBUFFER */ +#line 2968 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, EsdBuffer); } -#line 9749 "MachineIndependent/glslang_tab.cpp" +#line 10005 "MachineIndependent/glslang_tab.cpp" break; - case 422: /* type_specifier_nonarray: SAMPLER2DMS */ -#line 2921 "MachineIndependent/glslang.y" + case 431: /* type_specifier_nonarray: SAMPLER2DMS */ +#line 2973 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, false, false, true); } -#line 9759 "MachineIndependent/glslang_tab.cpp" +#line 10015 "MachineIndependent/glslang_tab.cpp" break; - case 423: /* type_specifier_nonarray: F16SAMPLER2DMS */ -#line 2926 "MachineIndependent/glslang.y" + case 432: /* type_specifier_nonarray: F16SAMPLER2DMS */ +#line 2978 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, false, false, true); } -#line 9770 "MachineIndependent/glslang_tab.cpp" +#line 10026 "MachineIndependent/glslang_tab.cpp" break; - case 424: /* type_specifier_nonarray: ISAMPLER2DMS */ -#line 2932 "MachineIndependent/glslang.y" + case 433: /* type_specifier_nonarray: ISAMPLER2DMS */ +#line 2984 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, false, false, true); } -#line 9780 "MachineIndependent/glslang_tab.cpp" +#line 10036 "MachineIndependent/glslang_tab.cpp" break; - case 425: /* type_specifier_nonarray: USAMPLER2DMS */ -#line 2937 "MachineIndependent/glslang.y" + case 434: /* type_specifier_nonarray: USAMPLER2DMS */ +#line 2989 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, false, false, true); } -#line 9790 "MachineIndependent/glslang_tab.cpp" +#line 10046 "MachineIndependent/glslang_tab.cpp" break; - case 426: /* type_specifier_nonarray: SAMPLER2DMSARRAY */ -#line 2942 "MachineIndependent/glslang.y" + case 435: /* type_specifier_nonarray: SAMPLER2DMSARRAY */ +#line 2994 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D, true, false, true); } -#line 9800 "MachineIndependent/glslang_tab.cpp" +#line 10056 "MachineIndependent/glslang_tab.cpp" break; - case 427: /* type_specifier_nonarray: F16SAMPLER2DMSARRAY */ -#line 2947 "MachineIndependent/glslang.y" + case 436: /* type_specifier_nonarray: F16SAMPLER2DMSARRAY */ +#line 2999 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat16, Esd2D, true, false, true); } -#line 9811 "MachineIndependent/glslang_tab.cpp" +#line 10067 "MachineIndependent/glslang_tab.cpp" break; - case 428: /* type_specifier_nonarray: ISAMPLER2DMSARRAY */ -#line 2953 "MachineIndependent/glslang.y" + case 437: /* type_specifier_nonarray: ISAMPLER2DMSARRAY */ +#line 3005 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtInt, Esd2D, true, false, true); } -#line 9821 "MachineIndependent/glslang_tab.cpp" +#line 10077 "MachineIndependent/glslang_tab.cpp" break; - case 429: /* type_specifier_nonarray: USAMPLER2DMSARRAY */ -#line 2958 "MachineIndependent/glslang.y" + case 438: /* type_specifier_nonarray: USAMPLER2DMSARRAY */ +#line 3010 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtUint, Esd2D, true, false, true); } -#line 9831 "MachineIndependent/glslang_tab.cpp" +#line 10087 "MachineIndependent/glslang_tab.cpp" break; - case 430: /* type_specifier_nonarray: TEXTURE1D */ -#line 2963 "MachineIndependent/glslang.y" + case 439: /* type_specifier_nonarray: TEXTURE1D */ +#line 3015 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D); } -#line 9841 "MachineIndependent/glslang_tab.cpp" +#line 10097 "MachineIndependent/glslang_tab.cpp" break; - case 431: /* type_specifier_nonarray: F16TEXTURE1D */ -#line 2968 "MachineIndependent/glslang.y" + case 440: /* type_specifier_nonarray: F16TEXTURE1D */ +#line 3020 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D); } -#line 9852 "MachineIndependent/glslang_tab.cpp" +#line 10108 "MachineIndependent/glslang_tab.cpp" break; - case 432: /* type_specifier_nonarray: F16TEXTURE2D */ -#line 2974 "MachineIndependent/glslang.y" + case 441: /* type_specifier_nonarray: F16TEXTURE2D */ +#line 3026 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D); } -#line 9863 "MachineIndependent/glslang_tab.cpp" +#line 10119 "MachineIndependent/glslang_tab.cpp" break; - case 433: /* type_specifier_nonarray: F16TEXTURE3D */ -#line 2980 "MachineIndependent/glslang.y" + case 442: /* type_specifier_nonarray: F16TEXTURE3D */ +#line 3032 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd3D); } -#line 9874 "MachineIndependent/glslang_tab.cpp" +#line 10130 "MachineIndependent/glslang_tab.cpp" break; - case 434: /* type_specifier_nonarray: F16TEXTURECUBE */ -#line 2986 "MachineIndependent/glslang.y" + case 443: /* type_specifier_nonarray: F16TEXTURECUBE */ +#line 3038 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube); } -#line 9885 "MachineIndependent/glslang_tab.cpp" +#line 10141 "MachineIndependent/glslang_tab.cpp" break; - case 435: /* type_specifier_nonarray: TEXTURE1DARRAY */ -#line 2992 "MachineIndependent/glslang.y" + case 444: /* type_specifier_nonarray: TEXTURE1DARRAY */ +#line 3044 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd1D, true); } -#line 9895 "MachineIndependent/glslang_tab.cpp" +#line 10151 "MachineIndependent/glslang_tab.cpp" break; - case 436: /* type_specifier_nonarray: F16TEXTURE1DARRAY */ -#line 2997 "MachineIndependent/glslang.y" + case 445: /* type_specifier_nonarray: F16TEXTURE1DARRAY */ +#line 3049 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd1D, true); } -#line 9906 "MachineIndependent/glslang_tab.cpp" +#line 10162 "MachineIndependent/glslang_tab.cpp" break; - case 437: /* type_specifier_nonarray: F16TEXTURE2DARRAY */ -#line 3003 "MachineIndependent/glslang.y" + case 446: /* type_specifier_nonarray: F16TEXTURE2DARRAY */ +#line 3055 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true); } -#line 9917 "MachineIndependent/glslang_tab.cpp" +#line 10173 "MachineIndependent/glslang_tab.cpp" break; - case 438: /* type_specifier_nonarray: F16TEXTURECUBEARRAY */ -#line 3009 "MachineIndependent/glslang.y" + case 447: /* type_specifier_nonarray: F16TEXTURECUBEARRAY */ +#line 3061 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdCube, true); } -#line 9928 "MachineIndependent/glslang_tab.cpp" +#line 10184 "MachineIndependent/glslang_tab.cpp" break; - case 439: /* type_specifier_nonarray: ITEXTURE1D */ -#line 3015 "MachineIndependent/glslang.y" + case 448: /* type_specifier_nonarray: ITEXTURE1D */ +#line 3067 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D); } -#line 9938 "MachineIndependent/glslang_tab.cpp" +#line 10194 "MachineIndependent/glslang_tab.cpp" break; - case 440: /* type_specifier_nonarray: ITEXTURE1DARRAY */ -#line 3020 "MachineIndependent/glslang.y" + case 449: /* type_specifier_nonarray: ITEXTURE1DARRAY */ +#line 3072 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd1D, true); } -#line 9948 "MachineIndependent/glslang_tab.cpp" +#line 10204 "MachineIndependent/glslang_tab.cpp" break; - case 441: /* type_specifier_nonarray: UTEXTURE1D */ -#line 3025 "MachineIndependent/glslang.y" + case 450: /* type_specifier_nonarray: UTEXTURE1D */ +#line 3077 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D); } -#line 9958 "MachineIndependent/glslang_tab.cpp" +#line 10214 "MachineIndependent/glslang_tab.cpp" break; - case 442: /* type_specifier_nonarray: UTEXTURE1DARRAY */ -#line 3030 "MachineIndependent/glslang.y" + case 451: /* type_specifier_nonarray: UTEXTURE1DARRAY */ +#line 3082 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd1D, true); } -#line 9968 "MachineIndependent/glslang_tab.cpp" +#line 10224 "MachineIndependent/glslang_tab.cpp" break; - case 443: /* type_specifier_nonarray: TEXTURE2DRECT */ -#line 3035 "MachineIndependent/glslang.y" + case 452: /* type_specifier_nonarray: TEXTURE2DRECT */ +#line 3087 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdRect); } -#line 9978 "MachineIndependent/glslang_tab.cpp" +#line 10234 "MachineIndependent/glslang_tab.cpp" break; - case 444: /* type_specifier_nonarray: F16TEXTURE2DRECT */ -#line 3040 "MachineIndependent/glslang.y" + case 453: /* type_specifier_nonarray: F16TEXTURE2DRECT */ +#line 3092 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdRect); } -#line 9989 "MachineIndependent/glslang_tab.cpp" +#line 10245 "MachineIndependent/glslang_tab.cpp" break; - case 445: /* type_specifier_nonarray: ITEXTURE2DRECT */ -#line 3046 "MachineIndependent/glslang.y" + case 454: /* type_specifier_nonarray: ITEXTURE2DRECT */ +#line 3098 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdRect); } -#line 9999 "MachineIndependent/glslang_tab.cpp" +#line 10255 "MachineIndependent/glslang_tab.cpp" break; - case 446: /* type_specifier_nonarray: UTEXTURE2DRECT */ -#line 3051 "MachineIndependent/glslang.y" + case 455: /* type_specifier_nonarray: UTEXTURE2DRECT */ +#line 3103 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdRect); } -#line 10009 "MachineIndependent/glslang_tab.cpp" +#line 10265 "MachineIndependent/glslang_tab.cpp" break; - case 447: /* type_specifier_nonarray: TEXTUREBUFFER */ -#line 3056 "MachineIndependent/glslang.y" + case 456: /* type_specifier_nonarray: TEXTUREBUFFER */ +#line 3108 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, EsdBuffer); } -#line 10019 "MachineIndependent/glslang_tab.cpp" +#line 10275 "MachineIndependent/glslang_tab.cpp" break; - case 448: /* type_specifier_nonarray: F16TEXTUREBUFFER */ -#line 3061 "MachineIndependent/glslang.y" + case 457: /* type_specifier_nonarray: F16TEXTUREBUFFER */ +#line 3113 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, EsdBuffer); } -#line 10030 "MachineIndependent/glslang_tab.cpp" +#line 10286 "MachineIndependent/glslang_tab.cpp" break; - case 449: /* type_specifier_nonarray: ITEXTUREBUFFER */ -#line 3067 "MachineIndependent/glslang.y" + case 458: /* type_specifier_nonarray: ITEXTUREBUFFER */ +#line 3119 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, EsdBuffer); } -#line 10040 "MachineIndependent/glslang_tab.cpp" +#line 10296 "MachineIndependent/glslang_tab.cpp" break; - case 450: /* type_specifier_nonarray: UTEXTUREBUFFER */ -#line 3072 "MachineIndependent/glslang.y" + case 459: /* type_specifier_nonarray: UTEXTUREBUFFER */ +#line 3124 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, EsdBuffer); } -#line 10050 "MachineIndependent/glslang_tab.cpp" +#line 10306 "MachineIndependent/glslang_tab.cpp" break; - case 451: /* type_specifier_nonarray: TEXTURE2DMS */ -#line 3077 "MachineIndependent/glslang.y" + case 460: /* type_specifier_nonarray: TEXTURE2DMS */ +#line 3129 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, false, false, true); } -#line 10060 "MachineIndependent/glslang_tab.cpp" +#line 10316 "MachineIndependent/glslang_tab.cpp" break; - case 452: /* type_specifier_nonarray: F16TEXTURE2DMS */ -#line 3082 "MachineIndependent/glslang.y" + case 461: /* type_specifier_nonarray: F16TEXTURE2DMS */ +#line 3134 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, false, false, true); } -#line 10071 "MachineIndependent/glslang_tab.cpp" +#line 10327 "MachineIndependent/glslang_tab.cpp" break; - case 453: /* type_specifier_nonarray: ITEXTURE2DMS */ -#line 3088 "MachineIndependent/glslang.y" + case 462: /* type_specifier_nonarray: ITEXTURE2DMS */ +#line 3140 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, false, false, true); } -#line 10081 "MachineIndependent/glslang_tab.cpp" +#line 10337 "MachineIndependent/glslang_tab.cpp" break; - case 454: /* type_specifier_nonarray: UTEXTURE2DMS */ -#line 3093 "MachineIndependent/glslang.y" + case 463: /* type_specifier_nonarray: UTEXTURE2DMS */ +#line 3145 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, false, false, true); } -#line 10091 "MachineIndependent/glslang_tab.cpp" +#line 10347 "MachineIndependent/glslang_tab.cpp" break; - case 455: /* type_specifier_nonarray: TEXTURE2DMSARRAY */ -#line 3098 "MachineIndependent/glslang.y" + case 464: /* type_specifier_nonarray: TEXTURE2DMSARRAY */ +#line 3150 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat, Esd2D, true, false, true); } -#line 10101 "MachineIndependent/glslang_tab.cpp" +#line 10357 "MachineIndependent/glslang_tab.cpp" break; - case 456: /* type_specifier_nonarray: F16TEXTURE2DMSARRAY */ -#line 3103 "MachineIndependent/glslang.y" + case 465: /* type_specifier_nonarray: F16TEXTURE2DMSARRAY */ +#line 3155 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float texture", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtFloat16, Esd2D, true, false, true); } -#line 10112 "MachineIndependent/glslang_tab.cpp" +#line 10368 "MachineIndependent/glslang_tab.cpp" break; - case 457: /* type_specifier_nonarray: ITEXTURE2DMSARRAY */ -#line 3109 "MachineIndependent/glslang.y" + case 466: /* type_specifier_nonarray: ITEXTURE2DMSARRAY */ +#line 3161 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtInt, Esd2D, true, false, true); } -#line 10122 "MachineIndependent/glslang_tab.cpp" +#line 10378 "MachineIndependent/glslang_tab.cpp" break; - case 458: /* type_specifier_nonarray: UTEXTURE2DMSARRAY */ -#line 3114 "MachineIndependent/glslang.y" + case 467: /* type_specifier_nonarray: UTEXTURE2DMSARRAY */ +#line 3166 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setTexture(EbtUint, Esd2D, true, false, true); } -#line 10132 "MachineIndependent/glslang_tab.cpp" +#line 10388 "MachineIndependent/glslang_tab.cpp" break; - case 459: /* type_specifier_nonarray: IMAGE1D */ -#line 3119 "MachineIndependent/glslang.y" + case 468: /* type_specifier_nonarray: IMAGE1D */ +#line 3171 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D); } -#line 10142 "MachineIndependent/glslang_tab.cpp" +#line 10398 "MachineIndependent/glslang_tab.cpp" break; - case 460: /* type_specifier_nonarray: F16IMAGE1D */ -#line 3124 "MachineIndependent/glslang.y" + case 469: /* type_specifier_nonarray: F16IMAGE1D */ +#line 3176 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D); } -#line 10153 "MachineIndependent/glslang_tab.cpp" +#line 10409 "MachineIndependent/glslang_tab.cpp" break; - case 461: /* type_specifier_nonarray: IIMAGE1D */ -#line 3130 "MachineIndependent/glslang.y" + case 470: /* type_specifier_nonarray: IIMAGE1D */ +#line 3182 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd1D); } -#line 10163 "MachineIndependent/glslang_tab.cpp" +#line 10419 "MachineIndependent/glslang_tab.cpp" break; - case 462: /* type_specifier_nonarray: UIMAGE1D */ -#line 3135 "MachineIndependent/glslang.y" + case 471: /* type_specifier_nonarray: UIMAGE1D */ +#line 3187 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd1D); } -#line 10173 "MachineIndependent/glslang_tab.cpp" +#line 10429 "MachineIndependent/glslang_tab.cpp" break; - case 463: /* type_specifier_nonarray: IMAGE2D */ -#line 3140 "MachineIndependent/glslang.y" + case 472: /* type_specifier_nonarray: IMAGE2D */ +#line 3192 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D); } -#line 10183 "MachineIndependent/glslang_tab.cpp" +#line 10439 "MachineIndependent/glslang_tab.cpp" break; - case 464: /* type_specifier_nonarray: F16IMAGE2D */ -#line 3145 "MachineIndependent/glslang.y" + case 473: /* type_specifier_nonarray: F16IMAGE2D */ +#line 3197 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D); } -#line 10194 "MachineIndependent/glslang_tab.cpp" +#line 10450 "MachineIndependent/glslang_tab.cpp" break; - case 465: /* type_specifier_nonarray: IIMAGE2D */ -#line 3151 "MachineIndependent/glslang.y" + case 474: /* type_specifier_nonarray: IIMAGE2D */ +#line 3203 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D); } -#line 10204 "MachineIndependent/glslang_tab.cpp" +#line 10460 "MachineIndependent/glslang_tab.cpp" break; - case 466: /* type_specifier_nonarray: UIMAGE2D */ -#line 3156 "MachineIndependent/glslang.y" + case 475: /* type_specifier_nonarray: UIMAGE2D */ +#line 3208 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D); } -#line 10214 "MachineIndependent/glslang_tab.cpp" +#line 10470 "MachineIndependent/glslang_tab.cpp" break; - case 467: /* type_specifier_nonarray: IMAGE3D */ -#line 3161 "MachineIndependent/glslang.y" + case 476: /* type_specifier_nonarray: IMAGE3D */ +#line 3213 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd3D); } -#line 10224 "MachineIndependent/glslang_tab.cpp" +#line 10480 "MachineIndependent/glslang_tab.cpp" break; - case 468: /* type_specifier_nonarray: F16IMAGE3D */ -#line 3166 "MachineIndependent/glslang.y" + case 477: /* type_specifier_nonarray: F16IMAGE3D */ +#line 3218 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd3D); } -#line 10235 "MachineIndependent/glslang_tab.cpp" +#line 10491 "MachineIndependent/glslang_tab.cpp" break; - case 469: /* type_specifier_nonarray: IIMAGE3D */ -#line 3172 "MachineIndependent/glslang.y" + case 478: /* type_specifier_nonarray: IIMAGE3D */ +#line 3224 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd3D); } -#line 10245 "MachineIndependent/glslang_tab.cpp" +#line 10501 "MachineIndependent/glslang_tab.cpp" break; - case 470: /* type_specifier_nonarray: UIMAGE3D */ -#line 3177 "MachineIndependent/glslang.y" + case 479: /* type_specifier_nonarray: UIMAGE3D */ +#line 3229 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd3D); } -#line 10255 "MachineIndependent/glslang_tab.cpp" +#line 10511 "MachineIndependent/glslang_tab.cpp" break; - case 471: /* type_specifier_nonarray: IMAGE2DRECT */ -#line 3182 "MachineIndependent/glslang.y" + case 480: /* type_specifier_nonarray: IMAGE2DRECT */ +#line 3234 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdRect); } -#line 10265 "MachineIndependent/glslang_tab.cpp" +#line 10521 "MachineIndependent/glslang_tab.cpp" break; - case 472: /* type_specifier_nonarray: F16IMAGE2DRECT */ -#line 3187 "MachineIndependent/glslang.y" + case 481: /* type_specifier_nonarray: F16IMAGE2DRECT */ +#line 3239 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdRect); } -#line 10276 "MachineIndependent/glslang_tab.cpp" +#line 10532 "MachineIndependent/glslang_tab.cpp" break; - case 473: /* type_specifier_nonarray: IIMAGE2DRECT */ -#line 3193 "MachineIndependent/glslang.y" + case 482: /* type_specifier_nonarray: IIMAGE2DRECT */ +#line 3245 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdRect); } -#line 10286 "MachineIndependent/glslang_tab.cpp" +#line 10542 "MachineIndependent/glslang_tab.cpp" break; - case 474: /* type_specifier_nonarray: UIMAGE2DRECT */ -#line 3198 "MachineIndependent/glslang.y" + case 483: /* type_specifier_nonarray: UIMAGE2DRECT */ +#line 3250 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdRect); } -#line 10296 "MachineIndependent/glslang_tab.cpp" +#line 10552 "MachineIndependent/glslang_tab.cpp" break; - case 475: /* type_specifier_nonarray: IMAGECUBE */ -#line 3203 "MachineIndependent/glslang.y" + case 484: /* type_specifier_nonarray: IMAGECUBE */ +#line 3255 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube); } -#line 10306 "MachineIndependent/glslang_tab.cpp" +#line 10562 "MachineIndependent/glslang_tab.cpp" break; - case 476: /* type_specifier_nonarray: F16IMAGECUBE */ -#line 3208 "MachineIndependent/glslang.y" + case 485: /* type_specifier_nonarray: F16IMAGECUBE */ +#line 3260 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube); } -#line 10317 "MachineIndependent/glslang_tab.cpp" +#line 10573 "MachineIndependent/glslang_tab.cpp" break; - case 477: /* type_specifier_nonarray: IIMAGECUBE */ -#line 3214 "MachineIndependent/glslang.y" + case 486: /* type_specifier_nonarray: IIMAGECUBE */ +#line 3266 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdCube); } -#line 10327 "MachineIndependent/glslang_tab.cpp" +#line 10583 "MachineIndependent/glslang_tab.cpp" break; - case 478: /* type_specifier_nonarray: UIMAGECUBE */ -#line 3219 "MachineIndependent/glslang.y" + case 487: /* type_specifier_nonarray: UIMAGECUBE */ +#line 3271 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdCube); } -#line 10337 "MachineIndependent/glslang_tab.cpp" +#line 10593 "MachineIndependent/glslang_tab.cpp" break; - case 479: /* type_specifier_nonarray: IMAGEBUFFER */ -#line 3224 "MachineIndependent/glslang.y" + case 488: /* type_specifier_nonarray: IMAGEBUFFER */ +#line 3276 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdBuffer); } -#line 10347 "MachineIndependent/glslang_tab.cpp" +#line 10603 "MachineIndependent/glslang_tab.cpp" break; - case 480: /* type_specifier_nonarray: F16IMAGEBUFFER */ -#line 3229 "MachineIndependent/glslang.y" + case 489: /* type_specifier_nonarray: F16IMAGEBUFFER */ +#line 3281 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdBuffer); } -#line 10358 "MachineIndependent/glslang_tab.cpp" +#line 10614 "MachineIndependent/glslang_tab.cpp" break; - case 481: /* type_specifier_nonarray: IIMAGEBUFFER */ -#line 3235 "MachineIndependent/glslang.y" + case 490: /* type_specifier_nonarray: IIMAGEBUFFER */ +#line 3287 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdBuffer); } -#line 10368 "MachineIndependent/glslang_tab.cpp" +#line 10624 "MachineIndependent/glslang_tab.cpp" break; - case 482: /* type_specifier_nonarray: UIMAGEBUFFER */ -#line 3240 "MachineIndependent/glslang.y" + case 491: /* type_specifier_nonarray: UIMAGEBUFFER */ +#line 3292 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdBuffer); } -#line 10378 "MachineIndependent/glslang_tab.cpp" +#line 10634 "MachineIndependent/glslang_tab.cpp" break; - case 483: /* type_specifier_nonarray: IMAGE1DARRAY */ -#line 3245 "MachineIndependent/glslang.y" + case 492: /* type_specifier_nonarray: IMAGE1DARRAY */ +#line 3297 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd1D, true); } -#line 10388 "MachineIndependent/glslang_tab.cpp" +#line 10644 "MachineIndependent/glslang_tab.cpp" break; - case 484: /* type_specifier_nonarray: F16IMAGE1DARRAY */ -#line 3250 "MachineIndependent/glslang.y" + case 493: /* type_specifier_nonarray: F16IMAGE1DARRAY */ +#line 3302 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd1D, true); } -#line 10399 "MachineIndependent/glslang_tab.cpp" +#line 10655 "MachineIndependent/glslang_tab.cpp" break; - case 485: /* type_specifier_nonarray: IIMAGE1DARRAY */ -#line 3256 "MachineIndependent/glslang.y" + case 494: /* type_specifier_nonarray: IIMAGE1DARRAY */ +#line 3308 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd1D, true); } -#line 10409 "MachineIndependent/glslang_tab.cpp" +#line 10665 "MachineIndependent/glslang_tab.cpp" break; - case 486: /* type_specifier_nonarray: UIMAGE1DARRAY */ -#line 3261 "MachineIndependent/glslang.y" + case 495: /* type_specifier_nonarray: UIMAGE1DARRAY */ +#line 3313 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd1D, true); } -#line 10419 "MachineIndependent/glslang_tab.cpp" +#line 10675 "MachineIndependent/glslang_tab.cpp" break; - case 487: /* type_specifier_nonarray: IMAGE2DARRAY */ -#line 3266 "MachineIndependent/glslang.y" + case 496: /* type_specifier_nonarray: IMAGE2DARRAY */ +#line 3318 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true); } -#line 10429 "MachineIndependent/glslang_tab.cpp" +#line 10685 "MachineIndependent/glslang_tab.cpp" break; - case 488: /* type_specifier_nonarray: F16IMAGE2DARRAY */ -#line 3271 "MachineIndependent/glslang.y" + case 497: /* type_specifier_nonarray: F16IMAGE2DARRAY */ +#line 3323 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true); } -#line 10440 "MachineIndependent/glslang_tab.cpp" +#line 10696 "MachineIndependent/glslang_tab.cpp" break; - case 489: /* type_specifier_nonarray: IIMAGE2DARRAY */ -#line 3277 "MachineIndependent/glslang.y" + case 498: /* type_specifier_nonarray: IIMAGE2DARRAY */ +#line 3329 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true); } -#line 10450 "MachineIndependent/glslang_tab.cpp" +#line 10706 "MachineIndependent/glslang_tab.cpp" break; - case 490: /* type_specifier_nonarray: UIMAGE2DARRAY */ -#line 3282 "MachineIndependent/glslang.y" + case 499: /* type_specifier_nonarray: UIMAGE2DARRAY */ +#line 3334 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true); } -#line 10460 "MachineIndependent/glslang_tab.cpp" +#line 10716 "MachineIndependent/glslang_tab.cpp" break; - case 491: /* type_specifier_nonarray: IMAGECUBEARRAY */ -#line 3287 "MachineIndependent/glslang.y" + case 500: /* type_specifier_nonarray: IMAGECUBEARRAY */ +#line 3339 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, EsdCube, true); } -#line 10470 "MachineIndependent/glslang_tab.cpp" +#line 10726 "MachineIndependent/glslang_tab.cpp" break; - case 492: /* type_specifier_nonarray: F16IMAGECUBEARRAY */ -#line 3292 "MachineIndependent/glslang.y" + case 501: /* type_specifier_nonarray: F16IMAGECUBEARRAY */ +#line 3344 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, EsdCube, true); } -#line 10481 "MachineIndependent/glslang_tab.cpp" +#line 10737 "MachineIndependent/glslang_tab.cpp" break; - case 493: /* type_specifier_nonarray: IIMAGECUBEARRAY */ -#line 3298 "MachineIndependent/glslang.y" + case 502: /* type_specifier_nonarray: IIMAGECUBEARRAY */ +#line 3350 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, EsdCube, true); } -#line 10491 "MachineIndependent/glslang_tab.cpp" +#line 10747 "MachineIndependent/glslang_tab.cpp" break; - case 494: /* type_specifier_nonarray: UIMAGECUBEARRAY */ -#line 3303 "MachineIndependent/glslang.y" + case 503: /* type_specifier_nonarray: UIMAGECUBEARRAY */ +#line 3355 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, EsdCube, true); } -#line 10501 "MachineIndependent/glslang_tab.cpp" +#line 10757 "MachineIndependent/glslang_tab.cpp" break; - case 495: /* type_specifier_nonarray: IMAGE2DMS */ -#line 3308 "MachineIndependent/glslang.y" + case 504: /* type_specifier_nonarray: IMAGE2DMS */ +#line 3360 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, false, false, true); } -#line 10511 "MachineIndependent/glslang_tab.cpp" +#line 10767 "MachineIndependent/glslang_tab.cpp" break; - case 496: /* type_specifier_nonarray: F16IMAGE2DMS */ -#line 3313 "MachineIndependent/glslang.y" + case 505: /* type_specifier_nonarray: F16IMAGE2DMS */ +#line 3365 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, false, false, true); } -#line 10522 "MachineIndependent/glslang_tab.cpp" +#line 10778 "MachineIndependent/glslang_tab.cpp" break; - case 497: /* type_specifier_nonarray: IIMAGE2DMS */ -#line 3319 "MachineIndependent/glslang.y" + case 506: /* type_specifier_nonarray: IIMAGE2DMS */ +#line 3371 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, false, false, true); } -#line 10532 "MachineIndependent/glslang_tab.cpp" +#line 10788 "MachineIndependent/glslang_tab.cpp" break; - case 498: /* type_specifier_nonarray: UIMAGE2DMS */ -#line 3324 "MachineIndependent/glslang.y" + case 507: /* type_specifier_nonarray: UIMAGE2DMS */ +#line 3376 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, false, false, true); } -#line 10542 "MachineIndependent/glslang_tab.cpp" +#line 10798 "MachineIndependent/glslang_tab.cpp" break; - case 499: /* type_specifier_nonarray: IMAGE2DMSARRAY */ -#line 3329 "MachineIndependent/glslang.y" + case 508: /* type_specifier_nonarray: IMAGE2DMSARRAY */ +#line 3381 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat, Esd2D, true, false, true); } -#line 10552 "MachineIndependent/glslang_tab.cpp" +#line 10808 "MachineIndependent/glslang_tab.cpp" break; - case 500: /* type_specifier_nonarray: F16IMAGE2DMSARRAY */ -#line 3334 "MachineIndependent/glslang.y" + case 509: /* type_specifier_nonarray: F16IMAGE2DMSARRAY */ +#line 3386 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float image", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtFloat16, Esd2D, true, false, true); } -#line 10563 "MachineIndependent/glslang_tab.cpp" +#line 10819 "MachineIndependent/glslang_tab.cpp" break; - case 501: /* type_specifier_nonarray: IIMAGE2DMSARRAY */ -#line 3340 "MachineIndependent/glslang.y" + case 510: /* type_specifier_nonarray: IIMAGE2DMSARRAY */ +#line 3392 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt, Esd2D, true, false, true); } -#line 10573 "MachineIndependent/glslang_tab.cpp" +#line 10829 "MachineIndependent/glslang_tab.cpp" break; - case 502: /* type_specifier_nonarray: UIMAGE2DMSARRAY */ -#line 3345 "MachineIndependent/glslang.y" + case 511: /* type_specifier_nonarray: UIMAGE2DMSARRAY */ +#line 3397 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint, Esd2D, true, false, true); } -#line 10583 "MachineIndependent/glslang_tab.cpp" +#line 10839 "MachineIndependent/glslang_tab.cpp" break; - case 503: /* type_specifier_nonarray: I64IMAGE1D */ -#line 3350 "MachineIndependent/glslang.y" + case 512: /* type_specifier_nonarray: I64IMAGE1D */ +#line 3402 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd1D); } -#line 10593 "MachineIndependent/glslang_tab.cpp" +#line 10849 "MachineIndependent/glslang_tab.cpp" break; - case 504: /* type_specifier_nonarray: U64IMAGE1D */ -#line 3355 "MachineIndependent/glslang.y" + case 513: /* type_specifier_nonarray: U64IMAGE1D */ +#line 3407 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd1D); } -#line 10603 "MachineIndependent/glslang_tab.cpp" +#line 10859 "MachineIndependent/glslang_tab.cpp" break; - case 505: /* type_specifier_nonarray: I64IMAGE2D */ -#line 3360 "MachineIndependent/glslang.y" + case 514: /* type_specifier_nonarray: I64IMAGE2D */ +#line 3412 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D); } -#line 10613 "MachineIndependent/glslang_tab.cpp" +#line 10869 "MachineIndependent/glslang_tab.cpp" break; - case 506: /* type_specifier_nonarray: U64IMAGE2D */ -#line 3365 "MachineIndependent/glslang.y" + case 515: /* type_specifier_nonarray: U64IMAGE2D */ +#line 3417 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D); } -#line 10623 "MachineIndependent/glslang_tab.cpp" +#line 10879 "MachineIndependent/glslang_tab.cpp" break; - case 507: /* type_specifier_nonarray: I64IMAGE3D */ -#line 3370 "MachineIndependent/glslang.y" + case 516: /* type_specifier_nonarray: I64IMAGE3D */ +#line 3422 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd3D); } -#line 10633 "MachineIndependent/glslang_tab.cpp" +#line 10889 "MachineIndependent/glslang_tab.cpp" break; - case 508: /* type_specifier_nonarray: U64IMAGE3D */ -#line 3375 "MachineIndependent/glslang.y" + case 517: /* type_specifier_nonarray: U64IMAGE3D */ +#line 3427 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd3D); } -#line 10643 "MachineIndependent/glslang_tab.cpp" +#line 10899 "MachineIndependent/glslang_tab.cpp" break; - case 509: /* type_specifier_nonarray: I64IMAGE2DRECT */ -#line 3380 "MachineIndependent/glslang.y" + case 518: /* type_specifier_nonarray: I64IMAGE2DRECT */ +#line 3432 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, EsdRect); } -#line 10653 "MachineIndependent/glslang_tab.cpp" +#line 10909 "MachineIndependent/glslang_tab.cpp" break; - case 510: /* type_specifier_nonarray: U64IMAGE2DRECT */ -#line 3385 "MachineIndependent/glslang.y" + case 519: /* type_specifier_nonarray: U64IMAGE2DRECT */ +#line 3437 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, EsdRect); } -#line 10663 "MachineIndependent/glslang_tab.cpp" +#line 10919 "MachineIndependent/glslang_tab.cpp" break; - case 511: /* type_specifier_nonarray: I64IMAGECUBE */ -#line 3390 "MachineIndependent/glslang.y" + case 520: /* type_specifier_nonarray: I64IMAGECUBE */ +#line 3442 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, EsdCube); } -#line 10673 "MachineIndependent/glslang_tab.cpp" +#line 10929 "MachineIndependent/glslang_tab.cpp" break; - case 512: /* type_specifier_nonarray: U64IMAGECUBE */ -#line 3395 "MachineIndependent/glslang.y" + case 521: /* type_specifier_nonarray: U64IMAGECUBE */ +#line 3447 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, EsdCube); } -#line 10683 "MachineIndependent/glslang_tab.cpp" +#line 10939 "MachineIndependent/glslang_tab.cpp" break; - case 513: /* type_specifier_nonarray: I64IMAGEBUFFER */ -#line 3400 "MachineIndependent/glslang.y" + case 522: /* type_specifier_nonarray: I64IMAGEBUFFER */ +#line 3452 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, EsdBuffer); } -#line 10693 "MachineIndependent/glslang_tab.cpp" +#line 10949 "MachineIndependent/glslang_tab.cpp" break; - case 514: /* type_specifier_nonarray: U64IMAGEBUFFER */ -#line 3405 "MachineIndependent/glslang.y" + case 523: /* type_specifier_nonarray: U64IMAGEBUFFER */ +#line 3457 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, EsdBuffer); } -#line 10703 "MachineIndependent/glslang_tab.cpp" +#line 10959 "MachineIndependent/glslang_tab.cpp" break; - case 515: /* type_specifier_nonarray: I64IMAGE1DARRAY */ -#line 3410 "MachineIndependent/glslang.y" + case 524: /* type_specifier_nonarray: I64IMAGE1DARRAY */ +#line 3462 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd1D, true); } -#line 10713 "MachineIndependent/glslang_tab.cpp" +#line 10969 "MachineIndependent/glslang_tab.cpp" break; - case 516: /* type_specifier_nonarray: U64IMAGE1DARRAY */ -#line 3415 "MachineIndependent/glslang.y" + case 525: /* type_specifier_nonarray: U64IMAGE1DARRAY */ +#line 3467 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd1D, true); } -#line 10723 "MachineIndependent/glslang_tab.cpp" +#line 10979 "MachineIndependent/glslang_tab.cpp" break; - case 517: /* type_specifier_nonarray: I64IMAGE2DARRAY */ -#line 3420 "MachineIndependent/glslang.y" + case 526: /* type_specifier_nonarray: I64IMAGE2DARRAY */ +#line 3472 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, true); } -#line 10733 "MachineIndependent/glslang_tab.cpp" +#line 10989 "MachineIndependent/glslang_tab.cpp" break; - case 518: /* type_specifier_nonarray: U64IMAGE2DARRAY */ -#line 3425 "MachineIndependent/glslang.y" + case 527: /* type_specifier_nonarray: U64IMAGE2DARRAY */ +#line 3477 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, true); } -#line 10743 "MachineIndependent/glslang_tab.cpp" +#line 10999 "MachineIndependent/glslang_tab.cpp" break; - case 519: /* type_specifier_nonarray: I64IMAGECUBEARRAY */ -#line 3430 "MachineIndependent/glslang.y" + case 528: /* type_specifier_nonarray: I64IMAGECUBEARRAY */ +#line 3482 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, EsdCube, true); } -#line 10753 "MachineIndependent/glslang_tab.cpp" +#line 11009 "MachineIndependent/glslang_tab.cpp" break; - case 520: /* type_specifier_nonarray: U64IMAGECUBEARRAY */ -#line 3435 "MachineIndependent/glslang.y" + case 529: /* type_specifier_nonarray: U64IMAGECUBEARRAY */ +#line 3487 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, EsdCube, true); } -#line 10763 "MachineIndependent/glslang_tab.cpp" +#line 11019 "MachineIndependent/glslang_tab.cpp" break; - case 521: /* type_specifier_nonarray: I64IMAGE2DMS */ -#line 3440 "MachineIndependent/glslang.y" + case 530: /* type_specifier_nonarray: I64IMAGE2DMS */ +#line 3492 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, false, false, true); } -#line 10773 "MachineIndependent/glslang_tab.cpp" +#line 11029 "MachineIndependent/glslang_tab.cpp" break; - case 522: /* type_specifier_nonarray: U64IMAGE2DMS */ -#line 3445 "MachineIndependent/glslang.y" + case 531: /* type_specifier_nonarray: U64IMAGE2DMS */ +#line 3497 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, false, false, true); } -#line 10783 "MachineIndependent/glslang_tab.cpp" +#line 11039 "MachineIndependent/glslang_tab.cpp" break; - case 523: /* type_specifier_nonarray: I64IMAGE2DMSARRAY */ -#line 3450 "MachineIndependent/glslang.y" + case 532: /* type_specifier_nonarray: I64IMAGE2DMSARRAY */ +#line 3502 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtInt64, Esd2D, true, false, true); } -#line 10793 "MachineIndependent/glslang_tab.cpp" +#line 11049 "MachineIndependent/glslang_tab.cpp" break; - case 524: /* type_specifier_nonarray: U64IMAGE2DMSARRAY */ -#line 3455 "MachineIndependent/glslang.y" + case 533: /* type_specifier_nonarray: U64IMAGE2DMSARRAY */ +#line 3507 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setImage(EbtUint64, Esd2D, true, false, true); } -#line 10803 "MachineIndependent/glslang_tab.cpp" +#line 11059 "MachineIndependent/glslang_tab.cpp" break; - case 525: /* type_specifier_nonarray: SAMPLEREXTERNALOES */ -#line 3460 "MachineIndependent/glslang.y" + case 534: /* type_specifier_nonarray: SAMPLEREXTERNALOES */ +#line 3512 "MachineIndependent/glslang.y" { // GL_OES_EGL_image_external (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); (yyval.interm.type).sampler.external = true; } -#line 10814 "MachineIndependent/glslang_tab.cpp" +#line 11070 "MachineIndependent/glslang_tab.cpp" break; - case 526: /* type_specifier_nonarray: SAMPLEREXTERNAL2DY2YEXT */ -#line 3466 "MachineIndependent/glslang.y" + case 535: /* type_specifier_nonarray: SAMPLEREXTERNAL2DY2YEXT */ +#line 3518 "MachineIndependent/glslang.y" { // GL_EXT_YUV_target (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.set(EbtFloat, Esd2D); (yyval.interm.type).sampler.yuv = true; } -#line 10825 "MachineIndependent/glslang_tab.cpp" +#line 11081 "MachineIndependent/glslang_tab.cpp" break; - case 527: /* type_specifier_nonarray: ATTACHMENTEXT */ -#line 3472 "MachineIndependent/glslang.y" + case 536: /* type_specifier_nonarray: ATTACHMENTEXT */ +#line 3524 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "attachmentEXT input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setAttachmentEXT(EbtFloat); } -#line 10836 "MachineIndependent/glslang_tab.cpp" +#line 11092 "MachineIndependent/glslang_tab.cpp" break; - case 528: /* type_specifier_nonarray: IATTACHMENTEXT */ -#line 3478 "MachineIndependent/glslang.y" + case 537: /* type_specifier_nonarray: IATTACHMENTEXT */ +#line 3530 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "attachmentEXT input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setAttachmentEXT(EbtInt); } -#line 10847 "MachineIndependent/glslang_tab.cpp" +#line 11103 "MachineIndependent/glslang_tab.cpp" break; - case 529: /* type_specifier_nonarray: UATTACHMENTEXT */ -#line 3484 "MachineIndependent/glslang.y" + case 538: /* type_specifier_nonarray: UATTACHMENTEXT */ +#line 3536 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "attachmentEXT input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setAttachmentEXT(EbtUint); } -#line 10858 "MachineIndependent/glslang_tab.cpp" +#line 11114 "MachineIndependent/glslang_tab.cpp" break; - case 530: /* type_specifier_nonarray: SUBPASSINPUT */ -#line 3490 "MachineIndependent/glslang.y" + case 539: /* type_specifier_nonarray: SUBPASSINPUT */ +#line 3542 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat); } -#line 10869 "MachineIndependent/glslang_tab.cpp" +#line 11125 "MachineIndependent/glslang_tab.cpp" break; - case 531: /* type_specifier_nonarray: SUBPASSINPUTMS */ -#line 3496 "MachineIndependent/glslang.y" + case 540: /* type_specifier_nonarray: SUBPASSINPUTMS */ +#line 3548 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat, true); } -#line 10880 "MachineIndependent/glslang_tab.cpp" +#line 11136 "MachineIndependent/glslang_tab.cpp" break; - case 532: /* type_specifier_nonarray: F16SUBPASSINPUT */ -#line 3502 "MachineIndependent/glslang.y" + case 541: /* type_specifier_nonarray: F16SUBPASSINPUT */ +#line 3554 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); @@ -10888,11 +11144,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat16); } -#line 10892 "MachineIndependent/glslang_tab.cpp" +#line 11148 "MachineIndependent/glslang_tab.cpp" break; - case 533: /* type_specifier_nonarray: F16SUBPASSINPUTMS */ -#line 3509 "MachineIndependent/glslang.y" + case 542: /* type_specifier_nonarray: F16SUBPASSINPUTMS */ +#line 3561 "MachineIndependent/glslang.y" { parseContext.float16OpaqueCheck((yyvsp[0].lex).loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel()); parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); @@ -10900,55 +11156,55 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtFloat16, true); } -#line 10904 "MachineIndependent/glslang_tab.cpp" +#line 11160 "MachineIndependent/glslang_tab.cpp" break; - case 534: /* type_specifier_nonarray: ISUBPASSINPUT */ -#line 3516 "MachineIndependent/glslang.y" + case 543: /* type_specifier_nonarray: ISUBPASSINPUT */ +#line 3568 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtInt); } -#line 10915 "MachineIndependent/glslang_tab.cpp" +#line 11171 "MachineIndependent/glslang_tab.cpp" break; - case 535: /* type_specifier_nonarray: ISUBPASSINPUTMS */ -#line 3522 "MachineIndependent/glslang.y" + case 544: /* type_specifier_nonarray: ISUBPASSINPUTMS */ +#line 3574 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtInt, true); } -#line 10926 "MachineIndependent/glslang_tab.cpp" +#line 11182 "MachineIndependent/glslang_tab.cpp" break; - case 536: /* type_specifier_nonarray: USUBPASSINPUT */ -#line 3528 "MachineIndependent/glslang.y" + case 545: /* type_specifier_nonarray: USUBPASSINPUT */ +#line 3580 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtUint); } -#line 10937 "MachineIndependent/glslang_tab.cpp" +#line 11193 "MachineIndependent/glslang_tab.cpp" break; - case 537: /* type_specifier_nonarray: USUBPASSINPUTMS */ -#line 3534 "MachineIndependent/glslang.y" + case 546: /* type_specifier_nonarray: USUBPASSINPUTMS */ +#line 3586 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[0].lex).loc, EShLangFragment, "subpass input"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtSampler; (yyval.interm.type).sampler.setSubpass(EbtUint, true); } -#line 10948 "MachineIndependent/glslang_tab.cpp" +#line 11204 "MachineIndependent/glslang_tab.cpp" break; - case 538: /* type_specifier_nonarray: FCOOPMATNV */ -#line 3540 "MachineIndependent/glslang.y" + case 547: /* type_specifier_nonarray: FCOOPMATNV */ +#line 3592 "MachineIndependent/glslang.y" { parseContext.fcoopmatCheckNV((yyvsp[0].lex).loc, "fcoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -10956,11 +11212,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).coopmatNV = true; (yyval.interm.type).coopmatKHR = false; } -#line 10960 "MachineIndependent/glslang_tab.cpp" +#line 11216 "MachineIndependent/glslang_tab.cpp" break; - case 539: /* type_specifier_nonarray: ICOOPMATNV */ -#line 3547 "MachineIndependent/glslang.y" + case 548: /* type_specifier_nonarray: ICOOPMATNV */ +#line 3599 "MachineIndependent/glslang.y" { parseContext.intcoopmatCheckNV((yyvsp[0].lex).loc, "icoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -10968,11 +11224,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).coopmatNV = true; (yyval.interm.type).coopmatKHR = false; } -#line 10972 "MachineIndependent/glslang_tab.cpp" +#line 11228 "MachineIndependent/glslang_tab.cpp" break; - case 540: /* type_specifier_nonarray: UCOOPMATNV */ -#line 3554 "MachineIndependent/glslang.y" + case 549: /* type_specifier_nonarray: UCOOPMATNV */ +#line 3606 "MachineIndependent/glslang.y" { parseContext.intcoopmatCheckNV((yyvsp[0].lex).loc, "ucoopmatNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -10980,11 +11236,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).coopmatNV = true; (yyval.interm.type).coopmatKHR = false; } -#line 10984 "MachineIndependent/glslang_tab.cpp" +#line 11240 "MachineIndependent/glslang_tab.cpp" break; - case 541: /* type_specifier_nonarray: COOPMAT */ -#line 3561 "MachineIndependent/glslang.y" + case 550: /* type_specifier_nonarray: COOPMAT */ +#line 3613 "MachineIndependent/glslang.y" { parseContext.coopmatCheck((yyvsp[0].lex).loc, "coopmat", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); @@ -10992,79 +11248,90 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).coopmatNV = false; (yyval.interm.type).coopmatKHR = true; } -#line 10996 "MachineIndependent/glslang_tab.cpp" +#line 11252 "MachineIndependent/glslang_tab.cpp" break; - case 542: /* type_specifier_nonarray: TENSORLAYOUTNV */ -#line 3568 "MachineIndependent/glslang.y" + case 551: /* type_specifier_nonarray: TENSORLAYOUTNV */ +#line 3620 "MachineIndependent/glslang.y" { parseContext.tensorLayoutViewCheck((yyvsp[0].lex).loc, "tensorLayoutNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtTensorLayoutNV; } -#line 11006 "MachineIndependent/glslang_tab.cpp" +#line 11262 "MachineIndependent/glslang_tab.cpp" break; - case 543: /* type_specifier_nonarray: TENSORVIEWNV */ -#line 3573 "MachineIndependent/glslang.y" + case 552: /* type_specifier_nonarray: TENSORVIEWNV */ +#line 3625 "MachineIndependent/glslang.y" { parseContext.tensorLayoutViewCheck((yyvsp[0].lex).loc, "tensorViewNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtTensorViewNV; } -#line 11016 "MachineIndependent/glslang_tab.cpp" +#line 11272 "MachineIndependent/glslang_tab.cpp" break; - case 544: /* type_specifier_nonarray: FUNCTION */ -#line 3578 "MachineIndependent/glslang.y" + case 553: /* type_specifier_nonarray: FUNCTION */ +#line 3630 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc); (yyval.interm.type).basicType = EbtFunction; } -#line 11025 "MachineIndependent/glslang_tab.cpp" +#line 11281 "MachineIndependent/glslang_tab.cpp" break; - case 545: /* type_specifier_nonarray: COOPVECNV */ -#line 3582 "MachineIndependent/glslang.y" + case 554: /* type_specifier_nonarray: COOPVECNV */ +#line 3634 "MachineIndependent/glslang.y" { parseContext.coopvecCheck((yyvsp[0].lex).loc, "coopvecNV", parseContext.symbolTable.atBuiltInLevel()); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtCoopvecNV; (yyval.interm.type).coopvecNV = true; } -#line 11036 "MachineIndependent/glslang_tab.cpp" +#line 11292 "MachineIndependent/glslang_tab.cpp" + break; + + case 555: /* type_specifier_nonarray: TENSORARM */ +#line 3640 "MachineIndependent/glslang.y" + { + parseContext.tensorCheckARM((yyvsp[0].lex).loc, "tensorARM", parseContext.symbolTable.atBuiltInLevel()); + (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); + (yyval.interm.type).tensorRankARM = 1; // placeholder value + (yyval.interm.type).basicType = EbtTensorARM; + } +#line 11303 "MachineIndependent/glslang_tab.cpp" break; - case 546: /* type_specifier_nonarray: spirv_type_specifier */ -#line 3588 "MachineIndependent/glslang.y" + case 556: /* type_specifier_nonarray: spirv_type_specifier */ +#line 3646 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].interm.type).loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier"); (yyval.interm.type) = (yyvsp[0].interm.type); } -#line 11045 "MachineIndependent/glslang_tab.cpp" +#line 11312 "MachineIndependent/glslang_tab.cpp" break; - case 547: /* type_specifier_nonarray: HITOBJECTNV */ -#line 3592 "MachineIndependent/glslang.y" + case 557: /* type_specifier_nonarray: HITOBJECTNV */ +#line 3650 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).basicType = EbtHitObjectNV; } -#line 11054 "MachineIndependent/glslang_tab.cpp" +#line 11321 "MachineIndependent/glslang_tab.cpp" break; - case 548: /* type_specifier_nonarray: struct_specifier */ -#line 3596 "MachineIndependent/glslang.y" + case 558: /* type_specifier_nonarray: struct_specifier */ +#line 3654 "MachineIndependent/glslang.y" { (yyval.interm.type) = (yyvsp[0].interm.type); (yyval.interm.type).qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary; parseContext.structTypeCheck((yyval.interm.type).loc, (yyval.interm.type)); } -#line 11064 "MachineIndependent/glslang_tab.cpp" +#line 11331 "MachineIndependent/glslang_tab.cpp" break; - case 549: /* type_specifier_nonarray: TYPE_NAME */ -#line 3601 "MachineIndependent/glslang.y" + case 559: /* type_specifier_nonarray: TYPE_NAME */ +#line 3659 "MachineIndependent/glslang.y" { // // This is for user defined type names. The lexical phase looked up the @@ -11078,47 +11345,47 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else parseContext.error((yyvsp[0].lex).loc, "expected type name", (yyvsp[0].lex).string->c_str(), ""); } -#line 11082 "MachineIndependent/glslang_tab.cpp" +#line 11349 "MachineIndependent/glslang_tab.cpp" break; - case 550: /* precision_qualifier: HIGH_PRECISION */ -#line 3617 "MachineIndependent/glslang.y" + case 560: /* precision_qualifier: HIGH_PRECISION */ +#line 3675 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "highp precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqHigh); } -#line 11092 "MachineIndependent/glslang_tab.cpp" +#line 11359 "MachineIndependent/glslang_tab.cpp" break; - case 551: /* precision_qualifier: MEDIUM_PRECISION */ -#line 3622 "MachineIndependent/glslang.y" + case 561: /* precision_qualifier: MEDIUM_PRECISION */ +#line 3680 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "mediump precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqMedium); } -#line 11102 "MachineIndependent/glslang_tab.cpp" +#line 11369 "MachineIndependent/glslang_tab.cpp" break; - case 552: /* precision_qualifier: LOW_PRECISION */ -#line 3627 "MachineIndependent/glslang.y" + case 562: /* precision_qualifier: LOW_PRECISION */ +#line 3685 "MachineIndependent/glslang.y" { parseContext.profileRequires((yyvsp[0].lex).loc, ENoProfile, 130, 0, "lowp precision qualifier"); (yyval.interm.type).init((yyvsp[0].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.handlePrecisionQualifier((yyvsp[0].lex).loc, (yyval.interm.type).qualifier, EpqLow); } -#line 11112 "MachineIndependent/glslang_tab.cpp" +#line 11379 "MachineIndependent/glslang_tab.cpp" break; - case 553: /* $@3: %empty */ -#line 3635 "MachineIndependent/glslang.y" + case 563: /* $@3: %empty */ +#line 3693 "MachineIndependent/glslang.y" { parseContext.nestedStructCheck((yyvsp[-2].lex).loc); } -#line 11118 "MachineIndependent/glslang_tab.cpp" +#line 11385 "MachineIndependent/glslang_tab.cpp" break; - case 554: /* struct_specifier: STRUCT IDENTIFIER LEFT_BRACE $@3 struct_declaration_list RIGHT_BRACE */ -#line 3635 "MachineIndependent/glslang.y" + case 564: /* struct_specifier: STRUCT IDENTIFIER LEFT_BRACE $@3 struct_declaration_list RIGHT_BRACE */ +#line 3693 "MachineIndependent/glslang.y" { TType* structure = new TType((yyvsp[-1].interm.typeList), *(yyvsp[-4].lex).string); @@ -11136,17 +11403,17 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 11140 "MachineIndependent/glslang_tab.cpp" +#line 11407 "MachineIndependent/glslang_tab.cpp" break; - case 555: /* $@4: %empty */ -#line 3652 "MachineIndependent/glslang.y" + case 565: /* $@4: %empty */ +#line 3710 "MachineIndependent/glslang.y" { parseContext.nestedStructCheck((yyvsp[-1].lex).loc); } -#line 11146 "MachineIndependent/glslang_tab.cpp" +#line 11413 "MachineIndependent/glslang_tab.cpp" break; - case 556: /* struct_specifier: STRUCT LEFT_BRACE $@4 struct_declaration_list RIGHT_BRACE */ -#line 3652 "MachineIndependent/glslang.y" + case 566: /* struct_specifier: STRUCT LEFT_BRACE $@4 struct_declaration_list RIGHT_BRACE */ +#line 3710 "MachineIndependent/glslang.y" { TType* structure = new TType((yyvsp[-1].interm.typeList), TString("")); (yyval.interm.type).init((yyvsp[-4].lex).loc); @@ -11154,19 +11421,19 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.type).userDef = structure; --parseContext.structNestingLevel; } -#line 11158 "MachineIndependent/glslang_tab.cpp" +#line 11425 "MachineIndependent/glslang_tab.cpp" break; - case 557: /* struct_declaration_list: struct_declaration */ -#line 3662 "MachineIndependent/glslang.y" + case 567: /* struct_declaration_list: struct_declaration */ +#line 3720 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = (yyvsp[0].interm.typeList); } -#line 11166 "MachineIndependent/glslang_tab.cpp" +#line 11433 "MachineIndependent/glslang_tab.cpp" break; - case 558: /* struct_declaration_list: struct_declaration_list struct_declaration */ -#line 3665 "MachineIndependent/glslang.y" + case 568: /* struct_declaration_list: struct_declaration_list struct_declaration */ +#line 3723 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); for (unsigned int i = 0; i < (yyvsp[0].interm.typeList)->size(); ++i) { @@ -11177,11 +11444,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.typeList)->push_back((*(yyvsp[0].interm.typeList))[i]); } } -#line 11181 "MachineIndependent/glslang_tab.cpp" +#line 11448 "MachineIndependent/glslang_tab.cpp" break; - case 559: /* struct_declaration: type_specifier struct_declarator_list SEMICOLON */ -#line 3678 "MachineIndependent/glslang.y" + case 569: /* struct_declaration: type_specifier struct_declarator_list SEMICOLON */ +#line 3736 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -11193,7 +11460,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.typeList) = (yyvsp[-1].interm.typeList); parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType); - parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier, (yyvsp[-2].interm.type).isCoopmatOrvec()); + parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier, (yyvsp[-2].interm.type).hasTypeParameter()); for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) { TType type((yyvsp[-2].interm.type)); @@ -11204,11 +11471,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 11208 "MachineIndependent/glslang_tab.cpp" +#line 11475 "MachineIndependent/glslang_tab.cpp" break; - case 560: /* struct_declaration: type_qualifier type_specifier struct_declarator_list SEMICOLON */ -#line 3700 "MachineIndependent/glslang.y" + case 570: /* struct_declaration: type_qualifier type_specifier struct_declarator_list SEMICOLON */ +#line 3758 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.type).arraySizes) { parseContext.profileRequires((yyvsp[-2].interm.type).loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type"); @@ -11222,7 +11489,7 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.memberQualifierCheck((yyvsp[-3].interm.type)); parseContext.voidErrorCheck((yyvsp[-2].interm.type).loc, (*(yyvsp[-1].interm.typeList))[0].type->getFieldName(), (yyvsp[-2].interm.type).basicType); parseContext.mergeQualifiers((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).qualifier, (yyvsp[-3].interm.type).qualifier, true); - parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier, (yyvsp[-2].interm.type).isCoopmatOrvec()); + parseContext.precisionQualifierCheck((yyvsp[-2].interm.type).loc, (yyvsp[-2].interm.type).basicType, (yyvsp[-2].interm.type).qualifier, (yyvsp[-2].interm.type).hasTypeParameter()); for (unsigned int i = 0; i < (yyval.interm.typeList)->size(); ++i) { TType type((yyvsp[-2].interm.type)); @@ -11233,38 +11500,38 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (*(yyval.interm.typeList))[i].type->shallowCopy(type); } } -#line 11237 "MachineIndependent/glslang_tab.cpp" +#line 11504 "MachineIndependent/glslang_tab.cpp" break; - case 561: /* struct_declarator_list: struct_declarator */ -#line 3727 "MachineIndependent/glslang.y" + case 571: /* struct_declarator_list: struct_declarator */ +#line 3785 "MachineIndependent/glslang.y" { (yyval.interm.typeList) = new TTypeList; (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 11246 "MachineIndependent/glslang_tab.cpp" +#line 11513 "MachineIndependent/glslang_tab.cpp" break; - case 562: /* struct_declarator_list: struct_declarator_list COMMA struct_declarator */ -#line 3731 "MachineIndependent/glslang.y" + case 572: /* struct_declarator_list: struct_declarator_list COMMA struct_declarator */ +#line 3789 "MachineIndependent/glslang.y" { (yyval.interm.typeList)->push_back((yyvsp[0].interm.typeLine)); } -#line 11254 "MachineIndependent/glslang_tab.cpp" +#line 11521 "MachineIndependent/glslang_tab.cpp" break; - case 563: /* struct_declarator: IDENTIFIER */ -#line 3737 "MachineIndependent/glslang.y" + case 573: /* struct_declarator: IDENTIFIER */ +#line 3795 "MachineIndependent/glslang.y" { (yyval.interm.typeLine).type = new TType(EbtVoid); (yyval.interm.typeLine).loc = (yyvsp[0].lex).loc; (yyval.interm.typeLine).type->setFieldName(*(yyvsp[0].lex).string); } -#line 11264 "MachineIndependent/glslang_tab.cpp" +#line 11531 "MachineIndependent/glslang_tab.cpp" break; - case 564: /* struct_declarator: IDENTIFIER array_specifier */ -#line 3742 "MachineIndependent/glslang.y" + case 574: /* struct_declarator: IDENTIFIER array_specifier */ +#line 3800 "MachineIndependent/glslang.y" { parseContext.arrayOfArrayVersionCheck((yyvsp[-1].lex).loc, (yyvsp[0].interm).arraySizes); @@ -11273,168 +11540,168 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.typeLine).type->setFieldName(*(yyvsp[-1].lex).string); (yyval.interm.typeLine).type->transferArraySizes((yyvsp[0].interm).arraySizes); } -#line 11277 "MachineIndependent/glslang_tab.cpp" +#line 11544 "MachineIndependent/glslang_tab.cpp" break; - case 565: /* initializer: assignment_expression */ -#line 3753 "MachineIndependent/glslang.y" + case 575: /* initializer: assignment_expression */ +#line 3811 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 11285 "MachineIndependent/glslang_tab.cpp" +#line 11552 "MachineIndependent/glslang_tab.cpp" break; - case 566: /* initializer: LEFT_BRACE initializer_list RIGHT_BRACE */ -#line 3756 "MachineIndependent/glslang.y" + case 576: /* initializer: LEFT_BRACE initializer_list RIGHT_BRACE */ +#line 3814 "MachineIndependent/glslang.y" { const char* initFeature = "{ } style initializers"; parseContext.requireProfile((yyvsp[-2].lex).loc, ~EEsProfile, initFeature); parseContext.profileRequires((yyvsp[-2].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); (yyval.interm.intermTypedNode) = (yyvsp[-1].interm.intermTypedNode); } -#line 11296 "MachineIndependent/glslang_tab.cpp" +#line 11563 "MachineIndependent/glslang_tab.cpp" break; - case 567: /* initializer: LEFT_BRACE initializer_list COMMA RIGHT_BRACE */ -#line 3762 "MachineIndependent/glslang.y" + case 577: /* initializer: LEFT_BRACE initializer_list COMMA RIGHT_BRACE */ +#line 3820 "MachineIndependent/glslang.y" { const char* initFeature = "{ } style initializers"; parseContext.requireProfile((yyvsp[-3].lex).loc, ~EEsProfile, initFeature); parseContext.profileRequires((yyvsp[-3].lex).loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, initFeature); (yyval.interm.intermTypedNode) = (yyvsp[-2].interm.intermTypedNode); } -#line 11307 "MachineIndependent/glslang_tab.cpp" +#line 11574 "MachineIndependent/glslang_tab.cpp" break; - case 568: /* initializer: LEFT_BRACE RIGHT_BRACE */ -#line 3768 "MachineIndependent/glslang.y" + case 578: /* initializer: LEFT_BRACE RIGHT_BRACE */ +#line 3826 "MachineIndependent/glslang.y" { const char* initFeature = "empty { } initializer"; parseContext.profileRequires((yyvsp[-1].lex).loc, EEsProfile, 0, E_GL_EXT_null_initializer, initFeature); parseContext.profileRequires((yyvsp[-1].lex).loc, ~EEsProfile, 0, E_GL_EXT_null_initializer, initFeature); (yyval.interm.intermTypedNode) = parseContext.intermediate.makeAggregate((yyvsp[-1].lex).loc); } -#line 11318 "MachineIndependent/glslang_tab.cpp" +#line 11585 "MachineIndependent/glslang_tab.cpp" break; - case 569: /* initializer_list: initializer */ -#line 3777 "MachineIndependent/glslang.y" + case 579: /* initializer_list: initializer */ +#line 3835 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate(0, (yyvsp[0].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)->getLoc()); } -#line 11326 "MachineIndependent/glslang_tab.cpp" +#line 11593 "MachineIndependent/glslang_tab.cpp" break; - case 570: /* initializer_list: initializer_list COMMA initializer */ -#line 3780 "MachineIndependent/glslang.y" + case 580: /* initializer_list: initializer_list COMMA initializer */ +#line 3838 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.intermTypedNode)); } -#line 11334 "MachineIndependent/glslang_tab.cpp" +#line 11601 "MachineIndependent/glslang_tab.cpp" break; - case 571: /* declaration_statement: declaration */ -#line 3786 "MachineIndependent/glslang.y" + case 581: /* declaration_statement: declaration */ +#line 3844 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11340 "MachineIndependent/glslang_tab.cpp" +#line 11607 "MachineIndependent/glslang_tab.cpp" break; - case 572: /* statement: compound_statement */ -#line 3790 "MachineIndependent/glslang.y" + case 582: /* statement: compound_statement */ +#line 3848 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11346 "MachineIndependent/glslang_tab.cpp" +#line 11613 "MachineIndependent/glslang_tab.cpp" break; - case 573: /* statement: simple_statement */ -#line 3791 "MachineIndependent/glslang.y" + case 583: /* statement: simple_statement */ +#line 3849 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11352 "MachineIndependent/glslang_tab.cpp" +#line 11619 "MachineIndependent/glslang_tab.cpp" break; - case 574: /* simple_statement: declaration_statement */ -#line 3797 "MachineIndependent/glslang.y" + case 584: /* simple_statement: declaration_statement */ +#line 3855 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11358 "MachineIndependent/glslang_tab.cpp" +#line 11625 "MachineIndependent/glslang_tab.cpp" break; - case 575: /* simple_statement: expression_statement */ -#line 3798 "MachineIndependent/glslang.y" + case 585: /* simple_statement: expression_statement */ +#line 3856 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11364 "MachineIndependent/glslang_tab.cpp" +#line 11631 "MachineIndependent/glslang_tab.cpp" break; - case 576: /* simple_statement: selection_statement */ -#line 3799 "MachineIndependent/glslang.y" + case 586: /* simple_statement: selection_statement */ +#line 3857 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11370 "MachineIndependent/glslang_tab.cpp" +#line 11637 "MachineIndependent/glslang_tab.cpp" break; - case 577: /* simple_statement: switch_statement */ -#line 3800 "MachineIndependent/glslang.y" + case 587: /* simple_statement: switch_statement */ +#line 3858 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11376 "MachineIndependent/glslang_tab.cpp" +#line 11643 "MachineIndependent/glslang_tab.cpp" break; - case 578: /* simple_statement: case_label */ -#line 3801 "MachineIndependent/glslang.y" + case 588: /* simple_statement: case_label */ +#line 3859 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11382 "MachineIndependent/glslang_tab.cpp" +#line 11649 "MachineIndependent/glslang_tab.cpp" break; - case 579: /* simple_statement: iteration_statement */ -#line 3802 "MachineIndependent/glslang.y" + case 589: /* simple_statement: iteration_statement */ +#line 3860 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11388 "MachineIndependent/glslang_tab.cpp" +#line 11655 "MachineIndependent/glslang_tab.cpp" break; - case 580: /* simple_statement: jump_statement */ -#line 3803 "MachineIndependent/glslang.y" + case 590: /* simple_statement: jump_statement */ +#line 3861 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11394 "MachineIndependent/glslang_tab.cpp" +#line 11661 "MachineIndependent/glslang_tab.cpp" break; - case 581: /* simple_statement: demote_statement */ -#line 3804 "MachineIndependent/glslang.y" + case 591: /* simple_statement: demote_statement */ +#line 3862 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11400 "MachineIndependent/glslang_tab.cpp" +#line 11667 "MachineIndependent/glslang_tab.cpp" break; - case 582: /* demote_statement: DEMOTE SEMICOLON */ -#line 3808 "MachineIndependent/glslang.y" + case 592: /* demote_statement: DEMOTE SEMICOLON */ +#line 3866 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "demote"); parseContext.requireExtensions((yyvsp[-1].lex).loc, 1, &E_GL_EXT_demote_to_helper_invocation, "demote"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDemote, (yyvsp[-1].lex).loc); } -#line 11410 "MachineIndependent/glslang_tab.cpp" +#line 11677 "MachineIndependent/glslang_tab.cpp" break; - case 583: /* compound_statement: LEFT_BRACE RIGHT_BRACE */ -#line 3816 "MachineIndependent/glslang.y" + case 593: /* compound_statement: LEFT_BRACE RIGHT_BRACE */ +#line 3874 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11416 "MachineIndependent/glslang_tab.cpp" +#line 11683 "MachineIndependent/glslang_tab.cpp" break; - case 584: /* $@5: %empty */ -#line 3817 "MachineIndependent/glslang.y" + case 594: /* $@5: %empty */ +#line 3875 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; } -#line 11425 "MachineIndependent/glslang_tab.cpp" +#line 11692 "MachineIndependent/glslang_tab.cpp" break; - case 585: /* $@6: %empty */ -#line 3821 "MachineIndependent/glslang.y" + case 595: /* $@6: %empty */ +#line 3879 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; } -#line 11434 "MachineIndependent/glslang_tab.cpp" +#line 11701 "MachineIndependent/glslang_tab.cpp" break; - case 586: /* compound_statement: LEFT_BRACE $@5 statement_list $@6 RIGHT_BRACE */ -#line 3825 "MachineIndependent/glslang.y" + case 596: /* compound_statement: LEFT_BRACE $@5 statement_list $@6 RIGHT_BRACE */ +#line 3883 "MachineIndependent/glslang.y" { if ((yyvsp[-2].interm.intermNode) && (yyvsp[-2].interm.intermNode)->getAsAggregate()) { (yyvsp[-2].interm.intermNode)->getAsAggregate()->setOperator(parseContext.intermediate.getDebugInfo() ? EOpScope : EOpSequence); @@ -11442,69 +11709,69 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } (yyval.interm.intermNode) = (yyvsp[-2].interm.intermNode); } -#line 11446 "MachineIndependent/glslang_tab.cpp" +#line 11713 "MachineIndependent/glslang_tab.cpp" break; - case 587: /* statement_no_new_scope: compound_statement_no_new_scope */ -#line 3835 "MachineIndependent/glslang.y" + case 597: /* statement_no_new_scope: compound_statement_no_new_scope */ +#line 3893 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11452 "MachineIndependent/glslang_tab.cpp" +#line 11719 "MachineIndependent/glslang_tab.cpp" break; - case 588: /* statement_no_new_scope: simple_statement */ -#line 3836 "MachineIndependent/glslang.y" + case 598: /* statement_no_new_scope: simple_statement */ +#line 3894 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11458 "MachineIndependent/glslang_tab.cpp" +#line 11725 "MachineIndependent/glslang_tab.cpp" break; - case 589: /* $@7: %empty */ -#line 3840 "MachineIndependent/glslang.y" + case 599: /* $@7: %empty */ +#line 3898 "MachineIndependent/glslang.y" { ++parseContext.controlFlowNestingLevel; } -#line 11466 "MachineIndependent/glslang_tab.cpp" +#line 11733 "MachineIndependent/glslang_tab.cpp" break; - case 590: /* statement_scoped: $@7 compound_statement */ -#line 3843 "MachineIndependent/glslang.y" + case 600: /* statement_scoped: $@7 compound_statement */ +#line 3901 "MachineIndependent/glslang.y" { --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11475 "MachineIndependent/glslang_tab.cpp" +#line 11742 "MachineIndependent/glslang_tab.cpp" break; - case 591: /* $@8: %empty */ -#line 3847 "MachineIndependent/glslang.y" + case 601: /* $@8: %empty */ +#line 3905 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 11485 "MachineIndependent/glslang_tab.cpp" +#line 11752 "MachineIndependent/glslang_tab.cpp" break; - case 592: /* statement_scoped: $@8 simple_statement */ -#line 3852 "MachineIndependent/glslang.y" + case 602: /* statement_scoped: $@8 simple_statement */ +#line 3910 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11496 "MachineIndependent/glslang_tab.cpp" +#line 11763 "MachineIndependent/glslang_tab.cpp" break; - case 593: /* compound_statement_no_new_scope: LEFT_BRACE RIGHT_BRACE */ -#line 3861 "MachineIndependent/glslang.y" + case 603: /* compound_statement_no_new_scope: LEFT_BRACE RIGHT_BRACE */ +#line 3919 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11504 "MachineIndependent/glslang_tab.cpp" +#line 11771 "MachineIndependent/glslang_tab.cpp" break; - case 594: /* compound_statement_no_new_scope: LEFT_BRACE statement_list RIGHT_BRACE */ -#line 3864 "MachineIndependent/glslang.y" + case 604: /* compound_statement_no_new_scope: LEFT_BRACE statement_list RIGHT_BRACE */ +#line 3922 "MachineIndependent/glslang.y" { if ((yyvsp[-1].interm.intermNode) && (yyvsp[-1].interm.intermNode)->getAsAggregate()) { (yyvsp[-1].interm.intermNode)->getAsAggregate()->setOperator(EOpSequence); @@ -11512,11 +11779,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } (yyval.interm.intermNode) = (yyvsp[-1].interm.intermNode); } -#line 11516 "MachineIndependent/glslang_tab.cpp" +#line 11783 "MachineIndependent/glslang_tab.cpp" break; - case 595: /* statement_list: statement */ -#line 3874 "MachineIndependent/glslang.y" + case 605: /* statement_list: statement */ +#line 3932 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || @@ -11525,11 +11792,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermNode) = 0; // start a fresh subsequence for what's after this case } } -#line 11529 "MachineIndependent/glslang_tab.cpp" +#line 11796 "MachineIndependent/glslang_tab.cpp" break; - case 596: /* statement_list: statement_list statement */ -#line 3882 "MachineIndependent/glslang.y" + case 606: /* statement_list: statement_list statement */ +#line 3940 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermNode) && (yyvsp[0].interm.intermNode)->getAsBranchNode() && ((yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpCase || (yyvsp[0].interm.intermNode)->getAsBranchNode()->getFlowOp() == EOpDefault)) { @@ -11538,77 +11805,77 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); } else (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 11542 "MachineIndependent/glslang_tab.cpp" +#line 11809 "MachineIndependent/glslang_tab.cpp" break; - case 597: /* expression_statement: SEMICOLON */ -#line 3893 "MachineIndependent/glslang.y" + case 607: /* expression_statement: SEMICOLON */ +#line 3951 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11548 "MachineIndependent/glslang_tab.cpp" +#line 11815 "MachineIndependent/glslang_tab.cpp" break; - case 598: /* expression_statement: expression SEMICOLON */ -#line 3894 "MachineIndependent/glslang.y" + case 608: /* expression_statement: expression SEMICOLON */ +#line 3952 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = static_cast((yyvsp[-1].interm.intermTypedNode)); } -#line 11554 "MachineIndependent/glslang_tab.cpp" +#line 11821 "MachineIndependent/glslang_tab.cpp" break; - case 599: /* selection_statement: selection_statement_nonattributed */ -#line 3898 "MachineIndependent/glslang.y" + case 609: /* selection_statement: selection_statement_nonattributed */ +#line 3956 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11562 "MachineIndependent/glslang_tab.cpp" +#line 11829 "MachineIndependent/glslang_tab.cpp" break; - case 600: /* selection_statement: attribute selection_statement_nonattributed */ -#line 3901 "MachineIndependent/glslang.y" + case 610: /* selection_statement: attribute selection_statement_nonattributed */ +#line 3959 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 1, &E_GL_EXT_control_flow_attributes, "attribute"); parseContext.handleSelectionAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11572 "MachineIndependent/glslang_tab.cpp" +#line 11839 "MachineIndependent/glslang_tab.cpp" break; - case 601: /* selection_statement_nonattributed: IF LEFT_PAREN expression RIGHT_PAREN selection_rest_statement */ -#line 3908 "MachineIndependent/glslang.y" + case 611: /* selection_statement_nonattributed: IF LEFT_PAREN expression RIGHT_PAREN selection_rest_statement */ +#line 3966 "MachineIndependent/glslang.y" { parseContext.boolCheck((yyvsp[-4].lex).loc, (yyvsp[-2].interm.intermTypedNode)); (yyval.interm.intermNode) = parseContext.intermediate.addSelection((yyvsp[-2].interm.intermTypedNode), (yyvsp[0].interm.nodePair), (yyvsp[-4].lex).loc); } -#line 11581 "MachineIndependent/glslang_tab.cpp" +#line 11848 "MachineIndependent/glslang_tab.cpp" break; - case 602: /* selection_rest_statement: statement_scoped ELSE statement_scoped */ -#line 3915 "MachineIndependent/glslang.y" + case 612: /* selection_rest_statement: statement_scoped ELSE statement_scoped */ +#line 3973 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermNode); } -#line 11590 "MachineIndependent/glslang_tab.cpp" +#line 11857 "MachineIndependent/glslang_tab.cpp" break; - case 603: /* selection_rest_statement: statement_scoped */ -#line 3919 "MachineIndependent/glslang.y" + case 613: /* selection_rest_statement: statement_scoped */ +#line 3977 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[0].interm.intermNode); (yyval.interm.nodePair).node2 = 0; } -#line 11599 "MachineIndependent/glslang_tab.cpp" +#line 11866 "MachineIndependent/glslang_tab.cpp" break; - case 604: /* condition: expression */ -#line 3927 "MachineIndependent/glslang.y" + case 614: /* condition: expression */ +#line 3985 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); parseContext.boolCheck((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)); } -#line 11608 "MachineIndependent/glslang_tab.cpp" +#line 11875 "MachineIndependent/glslang_tab.cpp" break; - case 605: /* condition: fully_specified_type IDENTIFIER EQUAL initializer */ -#line 3931 "MachineIndependent/glslang.y" + case 615: /* condition: fully_specified_type IDENTIFIER EQUAL initializer */ +#line 3989 "MachineIndependent/glslang.y" { parseContext.boolCheck((yyvsp[-2].lex).loc, (yyvsp[-3].interm.type)); @@ -11619,29 +11886,29 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.interm.intermTypedNode) = 0; } -#line 11623 "MachineIndependent/glslang_tab.cpp" +#line 11890 "MachineIndependent/glslang_tab.cpp" break; - case 606: /* switch_statement: switch_statement_nonattributed */ -#line 3944 "MachineIndependent/glslang.y" + case 616: /* switch_statement: switch_statement_nonattributed */ +#line 4002 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11631 "MachineIndependent/glslang_tab.cpp" +#line 11898 "MachineIndependent/glslang_tab.cpp" break; - case 607: /* switch_statement: attribute switch_statement_nonattributed */ -#line 3947 "MachineIndependent/glslang.y" + case 617: /* switch_statement: attribute switch_statement_nonattributed */ +#line 4005 "MachineIndependent/glslang.y" { parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 1, &E_GL_EXT_control_flow_attributes, "attribute"); parseContext.handleSwitchAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11641 "MachineIndependent/glslang_tab.cpp" +#line 11908 "MachineIndependent/glslang_tab.cpp" break; - case 608: /* $@9: %empty */ -#line 3954 "MachineIndependent/glslang.y" + case 618: /* $@9: %empty */ +#line 4012 "MachineIndependent/glslang.y" { // start new switch sequence on the switch stack ++parseContext.controlFlowNestingLevel; @@ -11650,11 +11917,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.switchLevel.push_back(parseContext.statementNestingLevel); parseContext.symbolTable.push(); } -#line 11654 "MachineIndependent/glslang_tab.cpp" +#line 11921 "MachineIndependent/glslang_tab.cpp" break; - case 609: /* switch_statement_nonattributed: SWITCH LEFT_PAREN expression RIGHT_PAREN $@9 LEFT_BRACE switch_statement_list RIGHT_BRACE */ -#line 3962 "MachineIndependent/glslang.y" + case 619: /* switch_statement_nonattributed: SWITCH LEFT_PAREN expression RIGHT_PAREN $@9 LEFT_BRACE switch_statement_list RIGHT_BRACE */ +#line 4020 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.addSwitch((yyvsp[-7].lex).loc, (yyvsp[-5].interm.intermTypedNode), (yyvsp[-1].interm.intermNode) ? (yyvsp[-1].interm.intermNode)->getAsAggregate() : 0); delete parseContext.switchSequenceStack.back(); @@ -11664,27 +11931,27 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 11668 "MachineIndependent/glslang_tab.cpp" +#line 11935 "MachineIndependent/glslang_tab.cpp" break; - case 610: /* switch_statement_list: %empty */ -#line 3974 "MachineIndependent/glslang.y" + case 620: /* switch_statement_list: %empty */ +#line 4032 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; } -#line 11676 "MachineIndependent/glslang_tab.cpp" +#line 11943 "MachineIndependent/glslang_tab.cpp" break; - case 611: /* switch_statement_list: statement_list */ -#line 3977 "MachineIndependent/glslang.y" + case 621: /* switch_statement_list: statement_list */ +#line 4035 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11684 "MachineIndependent/glslang_tab.cpp" +#line 11951 "MachineIndependent/glslang_tab.cpp" break; - case 612: /* case_label: CASE expression COLON */ -#line 3983 "MachineIndependent/glslang.y" + case 622: /* case_label: CASE expression COLON */ +#line 4041 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -11697,11 +11964,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpCase, (yyvsp[-1].interm.intermTypedNode), (yyvsp[-2].lex).loc); } } -#line 11701 "MachineIndependent/glslang_tab.cpp" +#line 11968 "MachineIndependent/glslang_tab.cpp" break; - case 613: /* case_label: DEFAULT COLON */ -#line 3995 "MachineIndependent/glslang.y" + case 623: /* case_label: DEFAULT COLON */ +#line 4053 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = 0; if (parseContext.switchLevel.size() == 0) @@ -11711,30 +11978,30 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); else (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpDefault, (yyvsp[-1].lex).loc); } -#line 11715 "MachineIndependent/glslang_tab.cpp" +#line 11982 "MachineIndependent/glslang_tab.cpp" break; - case 614: /* iteration_statement: iteration_statement_nonattributed */ -#line 4007 "MachineIndependent/glslang.y" + case 624: /* iteration_statement: iteration_statement_nonattributed */ +#line 4065 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11723 "MachineIndependent/glslang_tab.cpp" +#line 11990 "MachineIndependent/glslang_tab.cpp" break; - case 615: /* iteration_statement: attribute iteration_statement_nonattributed */ -#line 4010 "MachineIndependent/glslang.y" + case 625: /* iteration_statement: attribute iteration_statement_nonattributed */ +#line 4068 "MachineIndependent/glslang.y" { const char * extensions[2] = { E_GL_EXT_control_flow_attributes, E_GL_EXT_control_flow_attributes2 }; parseContext.requireExtensions((yyvsp[0].interm.intermNode)->getLoc(), 2, extensions, "attribute"); parseContext.handleLoopAttributes(*(yyvsp[-1].interm.attributes), (yyvsp[0].interm.intermNode)); (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11734 "MachineIndependent/glslang_tab.cpp" +#line 12001 "MachineIndependent/glslang_tab.cpp" break; - case 616: /* $@10: %empty */ -#line 4018 "MachineIndependent/glslang.y" + case 626: /* $@10: %empty */ +#line 4076 "MachineIndependent/glslang.y" { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-1].lex).loc, "while loops not available", "limitation", ""); @@ -11743,11 +12010,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 11747 "MachineIndependent/glslang_tab.cpp" +#line 12014 "MachineIndependent/glslang_tab.cpp" break; - case 617: /* iteration_statement_nonattributed: WHILE LEFT_PAREN $@10 condition RIGHT_PAREN statement_no_new_scope */ -#line 4026 "MachineIndependent/glslang.y" + case 627: /* iteration_statement_nonattributed: WHILE LEFT_PAREN $@10 condition RIGHT_PAREN statement_no_new_scope */ +#line 4084 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); (yyval.interm.intermNode) = parseContext.intermediate.addLoop((yyvsp[0].interm.intermNode), (yyvsp[-2].interm.intermTypedNode), 0, true, (yyvsp[-5].lex).loc); @@ -11755,22 +12022,22 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 11759 "MachineIndependent/glslang_tab.cpp" +#line 12026 "MachineIndependent/glslang_tab.cpp" break; - case 618: /* $@11: %empty */ -#line 4033 "MachineIndependent/glslang.y" + case 628: /* $@11: %empty */ +#line 4091 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 11770 "MachineIndependent/glslang_tab.cpp" +#line 12037 "MachineIndependent/glslang_tab.cpp" break; - case 619: /* iteration_statement_nonattributed: DO $@11 statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON */ -#line 4039 "MachineIndependent/glslang.y" + case 629: /* iteration_statement_nonattributed: DO $@11 statement WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON */ +#line 4097 "MachineIndependent/glslang.y" { if (! parseContext.limits.whileLoops) parseContext.error((yyvsp[-7].lex).loc, "do-while loops not available", "limitation", ""); @@ -11783,22 +12050,22 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 11787 "MachineIndependent/glslang_tab.cpp" +#line 12054 "MachineIndependent/glslang_tab.cpp" break; - case 620: /* $@12: %empty */ -#line 4051 "MachineIndependent/glslang.y" + case 630: /* $@12: %empty */ +#line 4109 "MachineIndependent/glslang.y" { parseContext.symbolTable.push(); ++parseContext.loopNestingLevel; ++parseContext.statementNestingLevel; ++parseContext.controlFlowNestingLevel; } -#line 11798 "MachineIndependent/glslang_tab.cpp" +#line 12065 "MachineIndependent/glslang_tab.cpp" break; - case 621: /* iteration_statement_nonattributed: FOR LEFT_PAREN $@12 for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope */ -#line 4057 "MachineIndependent/glslang.y" + case 631: /* iteration_statement_nonattributed: FOR LEFT_PAREN $@12 for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope */ +#line 4115 "MachineIndependent/glslang.y" { parseContext.symbolTable.pop(&parseContext.defaultPrecision[0]); (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[-3].interm.intermNode), (yyvsp[-5].lex).loc); @@ -11811,81 +12078,81 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; --parseContext.controlFlowNestingLevel; } -#line 11815 "MachineIndependent/glslang_tab.cpp" +#line 12082 "MachineIndependent/glslang_tab.cpp" break; - case 622: /* for_init_statement: expression_statement */ -#line 4072 "MachineIndependent/glslang.y" + case 632: /* for_init_statement: expression_statement */ +#line 4130 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11823 "MachineIndependent/glslang_tab.cpp" +#line 12090 "MachineIndependent/glslang_tab.cpp" break; - case 623: /* for_init_statement: declaration_statement */ -#line 4075 "MachineIndependent/glslang.y" + case 633: /* for_init_statement: declaration_statement */ +#line 4133 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11831 "MachineIndependent/glslang_tab.cpp" +#line 12098 "MachineIndependent/glslang_tab.cpp" break; - case 624: /* conditionopt: condition */ -#line 4081 "MachineIndependent/glslang.y" + case 634: /* conditionopt: condition */ +#line 4139 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = (yyvsp[0].interm.intermTypedNode); } -#line 11839 "MachineIndependent/glslang_tab.cpp" +#line 12106 "MachineIndependent/glslang_tab.cpp" break; - case 625: /* conditionopt: %empty */ -#line 4084 "MachineIndependent/glslang.y" + case 635: /* conditionopt: %empty */ +#line 4142 "MachineIndependent/glslang.y" { (yyval.interm.intermTypedNode) = 0; } -#line 11847 "MachineIndependent/glslang_tab.cpp" +#line 12114 "MachineIndependent/glslang_tab.cpp" break; - case 626: /* for_rest_statement: conditionopt SEMICOLON */ -#line 4090 "MachineIndependent/glslang.y" + case 636: /* for_rest_statement: conditionopt SEMICOLON */ +#line 4148 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[-1].interm.intermTypedNode); (yyval.interm.nodePair).node2 = 0; } -#line 11856 "MachineIndependent/glslang_tab.cpp" +#line 12123 "MachineIndependent/glslang_tab.cpp" break; - case 627: /* for_rest_statement: conditionopt SEMICOLON expression */ -#line 4094 "MachineIndependent/glslang.y" + case 637: /* for_rest_statement: conditionopt SEMICOLON expression */ +#line 4152 "MachineIndependent/glslang.y" { (yyval.interm.nodePair).node1 = (yyvsp[-2].interm.intermTypedNode); (yyval.interm.nodePair).node2 = (yyvsp[0].interm.intermTypedNode); } -#line 11865 "MachineIndependent/glslang_tab.cpp" +#line 12132 "MachineIndependent/glslang_tab.cpp" break; - case 628: /* jump_statement: CONTINUE SEMICOLON */ -#line 4101 "MachineIndependent/glslang.y" + case 638: /* jump_statement: CONTINUE SEMICOLON */ +#line 4159 "MachineIndependent/glslang.y" { if (parseContext.loopNestingLevel <= 0) parseContext.error((yyvsp[-1].lex).loc, "continue statement only allowed in loops", "", ""); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpContinue, (yyvsp[-1].lex).loc); } -#line 11875 "MachineIndependent/glslang_tab.cpp" +#line 12142 "MachineIndependent/glslang_tab.cpp" break; - case 629: /* jump_statement: BREAK SEMICOLON */ -#line 4106 "MachineIndependent/glslang.y" + case 639: /* jump_statement: BREAK SEMICOLON */ +#line 4164 "MachineIndependent/glslang.y" { if (parseContext.loopNestingLevel + parseContext.switchSequenceStack.size() <= 0) parseContext.error((yyvsp[-1].lex).loc, "break statement only allowed in switch and loops", "", ""); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpBreak, (yyvsp[-1].lex).loc); } -#line 11885 "MachineIndependent/glslang_tab.cpp" +#line 12152 "MachineIndependent/glslang_tab.cpp" break; - case 630: /* jump_statement: RETURN SEMICOLON */ -#line 4111 "MachineIndependent/glslang.y" + case 640: /* jump_statement: RETURN SEMICOLON */ +#line 4169 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpReturn, (yyvsp[-1].lex).loc); if (parseContext.currentFunctionType->getBasicType() != EbtVoid) @@ -11893,101 +12160,101 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); if (parseContext.inMain) parseContext.postEntryPointReturn = true; } -#line 11897 "MachineIndependent/glslang_tab.cpp" +#line 12164 "MachineIndependent/glslang_tab.cpp" break; - case 631: /* jump_statement: RETURN expression SEMICOLON */ -#line 4118 "MachineIndependent/glslang.y" + case 641: /* jump_statement: RETURN expression SEMICOLON */ +#line 4176 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.handleReturnValue((yyvsp[-2].lex).loc, (yyvsp[-1].interm.intermTypedNode)); } -#line 11905 "MachineIndependent/glslang_tab.cpp" +#line 12172 "MachineIndependent/glslang_tab.cpp" break; - case 632: /* jump_statement: DISCARD SEMICOLON */ -#line 4121 "MachineIndependent/glslang.y" + case 642: /* jump_statement: DISCARD SEMICOLON */ +#line 4179 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "discard"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpKill, (yyvsp[-1].lex).loc); } -#line 11914 "MachineIndependent/glslang_tab.cpp" +#line 12181 "MachineIndependent/glslang_tab.cpp" break; - case 633: /* jump_statement: TERMINATE_INVOCATION SEMICOLON */ -#line 4125 "MachineIndependent/glslang.y" + case 643: /* jump_statement: TERMINATE_INVOCATION SEMICOLON */ +#line 4183 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangFragment, "terminateInvocation"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpTerminateInvocation, (yyvsp[-1].lex).loc); } -#line 11923 "MachineIndependent/glslang_tab.cpp" +#line 12190 "MachineIndependent/glslang_tab.cpp" break; - case 634: /* jump_statement: TERMINATE_RAY SEMICOLON */ -#line 4129 "MachineIndependent/glslang.y" + case 644: /* jump_statement: TERMINATE_RAY SEMICOLON */ +#line 4187 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangAnyHit, "terminateRayEXT"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpTerminateRayKHR, (yyvsp[-1].lex).loc); } -#line 11932 "MachineIndependent/glslang_tab.cpp" +#line 12199 "MachineIndependent/glslang_tab.cpp" break; - case 635: /* jump_statement: IGNORE_INTERSECTION SEMICOLON */ -#line 4133 "MachineIndependent/glslang.y" + case 645: /* jump_statement: IGNORE_INTERSECTION SEMICOLON */ +#line 4191 "MachineIndependent/glslang.y" { parseContext.requireStage((yyvsp[-1].lex).loc, EShLangAnyHit, "ignoreIntersectionEXT"); (yyval.interm.intermNode) = parseContext.intermediate.addBranch(EOpIgnoreIntersectionKHR, (yyvsp[-1].lex).loc); } -#line 11941 "MachineIndependent/glslang_tab.cpp" +#line 12208 "MachineIndependent/glslang_tab.cpp" break; - case 636: /* translation_unit: external_declaration */ -#line 4142 "MachineIndependent/glslang.y" + case 646: /* translation_unit: external_declaration */ +#line 4200 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } -#line 11950 "MachineIndependent/glslang_tab.cpp" +#line 12217 "MachineIndependent/glslang_tab.cpp" break; - case 637: /* translation_unit: translation_unit external_declaration */ -#line 4146 "MachineIndependent/glslang.y" + case 647: /* translation_unit: translation_unit external_declaration */ +#line 4204 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermNode) != nullptr) { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-1].interm.intermNode), (yyvsp[0].interm.intermNode)); parseContext.intermediate.setTreeRoot((yyval.interm.intermNode)); } } -#line 11961 "MachineIndependent/glslang_tab.cpp" +#line 12228 "MachineIndependent/glslang_tab.cpp" break; - case 638: /* external_declaration: function_definition */ -#line 4155 "MachineIndependent/glslang.y" + case 648: /* external_declaration: function_definition */ +#line 4213 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11969 "MachineIndependent/glslang_tab.cpp" +#line 12236 "MachineIndependent/glslang_tab.cpp" break; - case 639: /* external_declaration: declaration */ -#line 4158 "MachineIndependent/glslang.y" + case 649: /* external_declaration: declaration */ +#line 4216 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = (yyvsp[0].interm.intermNode); } -#line 11977 "MachineIndependent/glslang_tab.cpp" +#line 12244 "MachineIndependent/glslang_tab.cpp" break; - case 640: /* external_declaration: SEMICOLON */ -#line 4161 "MachineIndependent/glslang.y" + case 650: /* external_declaration: SEMICOLON */ +#line 4219 "MachineIndependent/glslang.y" { parseContext.requireProfile((yyvsp[0].lex).loc, ~EEsProfile, "extraneous semicolon"); parseContext.profileRequires((yyvsp[0].lex).loc, ~EEsProfile, 460, nullptr, "extraneous semicolon"); (yyval.interm.intermNode) = nullptr; } -#line 11987 "MachineIndependent/glslang_tab.cpp" +#line 12254 "MachineIndependent/glslang_tab.cpp" break; - case 641: /* $@13: %empty */ -#line 4169 "MachineIndependent/glslang.y" + case 651: /* $@13: %empty */ +#line 4227 "MachineIndependent/glslang.y" { (yyvsp[0].interm).function = parseContext.handleFunctionDeclarator((yyvsp[0].interm).loc, *(yyvsp[0].interm).function, false /* not prototype */); (yyvsp[0].interm).intermNode = parseContext.handleFunctionDefinition((yyvsp[0].interm).loc, *(yyvsp[0].interm).function); @@ -12000,11 +12267,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ++parseContext.statementNestingLevel; } } -#line 12004 "MachineIndependent/glslang_tab.cpp" +#line 12271 "MachineIndependent/glslang_tab.cpp" break; - case 642: /* function_definition: function_prototype $@13 compound_statement_no_new_scope */ -#line 4181 "MachineIndependent/glslang.y" + case 652: /* function_definition: function_prototype $@13 compound_statement_no_new_scope */ +#line 4239 "MachineIndependent/glslang.y" { // May be best done as post process phase on intermediate code if (parseContext.currentFunctionType->getBasicType() != EbtVoid && ! parseContext.functionReturnsValue) @@ -12032,228 +12299,228 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); --parseContext.statementNestingLevel; } } -#line 12036 "MachineIndependent/glslang_tab.cpp" +#line 12303 "MachineIndependent/glslang_tab.cpp" break; - case 643: /* attribute: LEFT_BRACKET LEFT_BRACKET attribute_list RIGHT_BRACKET RIGHT_BRACKET */ -#line 4211 "MachineIndependent/glslang.y" + case 653: /* attribute: LEFT_BRACKET LEFT_BRACKET attribute_list RIGHT_BRACKET RIGHT_BRACKET */ +#line 4269 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = (yyvsp[-2].interm.attributes); } -#line 12044 "MachineIndependent/glslang_tab.cpp" +#line 12311 "MachineIndependent/glslang_tab.cpp" break; - case 644: /* attribute_list: single_attribute */ -#line 4216 "MachineIndependent/glslang.y" + case 654: /* attribute_list: single_attribute */ +#line 4274 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = (yyvsp[0].interm.attributes); } -#line 12052 "MachineIndependent/glslang_tab.cpp" +#line 12319 "MachineIndependent/glslang_tab.cpp" break; - case 645: /* attribute_list: attribute_list COMMA single_attribute */ -#line 4219 "MachineIndependent/glslang.y" + case 655: /* attribute_list: attribute_list COMMA single_attribute */ +#line 4277 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = parseContext.mergeAttributes((yyvsp[-2].interm.attributes), (yyvsp[0].interm.attributes)); } -#line 12060 "MachineIndependent/glslang_tab.cpp" +#line 12327 "MachineIndependent/glslang_tab.cpp" break; - case 646: /* single_attribute: IDENTIFIER */ -#line 4224 "MachineIndependent/glslang.y" + case 656: /* single_attribute: IDENTIFIER */ +#line 4282 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[0].lex).string); } -#line 12068 "MachineIndependent/glslang_tab.cpp" +#line 12335 "MachineIndependent/glslang_tab.cpp" break; - case 647: /* single_attribute: IDENTIFIER LEFT_PAREN constant_expression RIGHT_PAREN */ -#line 4227 "MachineIndependent/glslang.y" + case 657: /* single_attribute: IDENTIFIER LEFT_PAREN constant_expression RIGHT_PAREN */ +#line 4285 "MachineIndependent/glslang.y" { (yyval.interm.attributes) = parseContext.makeAttributes(*(yyvsp[-3].lex).string, (yyvsp[-1].interm.intermTypedNode)); } -#line 12076 "MachineIndependent/glslang_tab.cpp" +#line 12343 "MachineIndependent/glslang_tab.cpp" break; - case 648: /* spirv_requirements_list: spirv_requirements_parameter */ -#line 4232 "MachineIndependent/glslang.y" + case 658: /* spirv_requirements_list: spirv_requirements_parameter */ +#line 4290 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = (yyvsp[0].interm.spirvReq); } -#line 12084 "MachineIndependent/glslang_tab.cpp" +#line 12351 "MachineIndependent/glslang_tab.cpp" break; - case 649: /* spirv_requirements_list: spirv_requirements_list COMMA spirv_requirements_parameter */ -#line 4235 "MachineIndependent/glslang.y" + case 659: /* spirv_requirements_list: spirv_requirements_list COMMA spirv_requirements_parameter */ +#line 4293 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = parseContext.mergeSpirvRequirements((yyvsp[-1].lex).loc, (yyvsp[-2].interm.spirvReq), (yyvsp[0].interm.spirvReq)); } -#line 12092 "MachineIndependent/glslang_tab.cpp" +#line 12359 "MachineIndependent/glslang_tab.cpp" break; - case 650: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_extension_list RIGHT_BRACKET */ -#line 4240 "MachineIndependent/glslang.y" + case 660: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_extension_list RIGHT_BRACKET */ +#line 4298 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = parseContext.makeSpirvRequirement((yyvsp[-3].lex).loc, *(yyvsp[-4].lex).string, (yyvsp[-1].interm.intermNode)->getAsAggregate(), nullptr); } -#line 12100 "MachineIndependent/glslang_tab.cpp" +#line 12367 "MachineIndependent/glslang_tab.cpp" break; - case 651: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_capability_list RIGHT_BRACKET */ -#line 4243 "MachineIndependent/glslang.y" + case 661: /* spirv_requirements_parameter: IDENTIFIER EQUAL LEFT_BRACKET spirv_capability_list RIGHT_BRACKET */ +#line 4301 "MachineIndependent/glslang.y" { (yyval.interm.spirvReq) = parseContext.makeSpirvRequirement((yyvsp[-3].lex).loc, *(yyvsp[-4].lex).string, nullptr, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12108 "MachineIndependent/glslang_tab.cpp" +#line 12375 "MachineIndependent/glslang_tab.cpp" break; - case 652: /* spirv_extension_list: STRING_LITERAL */ -#line 4248 "MachineIndependent/glslang.y" + case 662: /* spirv_extension_list: STRING_LITERAL */ +#line 4306 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 12116 "MachineIndependent/glslang_tab.cpp" +#line 12383 "MachineIndependent/glslang_tab.cpp" break; - case 653: /* spirv_extension_list: spirv_extension_list COMMA STRING_LITERAL */ -#line 4251 "MachineIndependent/glslang.y" + case 663: /* spirv_extension_list: spirv_extension_list COMMA STRING_LITERAL */ +#line 4309 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 12124 "MachineIndependent/glslang_tab.cpp" +#line 12391 "MachineIndependent/glslang_tab.cpp" break; - case 654: /* spirv_capability_list: INTCONSTANT */ -#line 4256 "MachineIndependent/glslang.y" + case 664: /* spirv_capability_list: INTCONSTANT */ +#line 4314 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate(parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true)); } -#line 12132 "MachineIndependent/glslang_tab.cpp" +#line 12399 "MachineIndependent/glslang_tab.cpp" break; - case 655: /* spirv_capability_list: spirv_capability_list COMMA INTCONSTANT */ -#line 4259 "MachineIndependent/glslang.y" + case 665: /* spirv_capability_list: spirv_capability_list COMMA INTCONSTANT */ +#line 4317 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true)); } -#line 12140 "MachineIndependent/glslang_tab.cpp" +#line 12407 "MachineIndependent/glslang_tab.cpp" break; - case 656: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ -#line 4264 "MachineIndependent/glslang.y" + case 666: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ +#line 4322 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-1].lex).i); (yyval.interm.intermNode) = 0; } -#line 12149 "MachineIndependent/glslang_tab.cpp" +#line 12416 "MachineIndependent/glslang_tab.cpp" break; - case 657: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ -#line 4268 "MachineIndependent/glslang.y" + case 667: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ +#line 4326 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-1].lex).i); (yyval.interm.intermNode) = 0; } -#line 12159 "MachineIndependent/glslang_tab.cpp" +#line 12426 "MachineIndependent/glslang_tab.cpp" break; - case 658: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ -#line 4273 "MachineIndependent/glslang.y" + case 668: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ +#line 4331 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12168 "MachineIndependent/glslang_tab.cpp" +#line 12435 "MachineIndependent/glslang_tab.cpp" break; - case 659: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ -#line 4277 "MachineIndependent/glslang.y" + case 669: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_parameter_list RIGHT_PAREN */ +#line 4335 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); parseContext.intermediate.insertSpirvExecutionMode((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12178 "MachineIndependent/glslang_tab.cpp" +#line 12445 "MachineIndependent/glslang_tab.cpp" break; - case 660: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN */ -#line 4282 "MachineIndependent/glslang.y" + case 670: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN */ +#line 4340 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvExecutionModeId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12187 "MachineIndependent/glslang_tab.cpp" +#line 12454 "MachineIndependent/glslang_tab.cpp" break; - case 661: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN */ -#line 4286 "MachineIndependent/glslang.y" + case 671: /* spirv_execution_mode_qualifier: SPIRV_EXECUTION_MODE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_execution_mode_id_parameter_list RIGHT_PAREN */ +#line 4344 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); parseContext.intermediate.insertSpirvExecutionModeId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); (yyval.interm.intermNode) = 0; } -#line 12197 "MachineIndependent/glslang_tab.cpp" +#line 12464 "MachineIndependent/glslang_tab.cpp" break; - case 662: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter */ -#line 4293 "MachineIndependent/glslang.y" + case 672: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter */ +#line 4351 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); } -#line 12205 "MachineIndependent/glslang_tab.cpp" +#line 12472 "MachineIndependent/glslang_tab.cpp" break; - case 663: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter_list COMMA spirv_execution_mode_parameter */ -#line 4296 "MachineIndependent/glslang.y" + case 673: /* spirv_execution_mode_parameter_list: spirv_execution_mode_parameter_list COMMA spirv_execution_mode_parameter */ +#line 4354 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 12213 "MachineIndependent/glslang_tab.cpp" +#line 12480 "MachineIndependent/glslang_tab.cpp" break; - case 664: /* spirv_execution_mode_parameter: FLOATCONSTANT */ -#line 4301 "MachineIndependent/glslang.y" + case 674: /* spirv_execution_mode_parameter: FLOATCONSTANT */ +#line 4359 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 12221 "MachineIndependent/glslang_tab.cpp" +#line 12488 "MachineIndependent/glslang_tab.cpp" break; - case 665: /* spirv_execution_mode_parameter: INTCONSTANT */ -#line 4304 "MachineIndependent/glslang.y" + case 675: /* spirv_execution_mode_parameter: INTCONSTANT */ +#line 4362 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 12229 "MachineIndependent/glslang_tab.cpp" +#line 12496 "MachineIndependent/glslang_tab.cpp" break; - case 666: /* spirv_execution_mode_parameter: UINTCONSTANT */ -#line 4307 "MachineIndependent/glslang.y" + case 676: /* spirv_execution_mode_parameter: UINTCONSTANT */ +#line 4365 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 12237 "MachineIndependent/glslang_tab.cpp" +#line 12504 "MachineIndependent/glslang_tab.cpp" break; - case 667: /* spirv_execution_mode_parameter: BOOLCONSTANT */ -#line 4310 "MachineIndependent/glslang.y" + case 677: /* spirv_execution_mode_parameter: BOOLCONSTANT */ +#line 4368 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 12245 "MachineIndependent/glslang_tab.cpp" +#line 12512 "MachineIndependent/glslang_tab.cpp" break; - case 668: /* spirv_execution_mode_parameter: STRING_LITERAL */ -#line 4313 "MachineIndependent/glslang.y" + case 678: /* spirv_execution_mode_parameter: STRING_LITERAL */ +#line 4371 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true); } -#line 12253 "MachineIndependent/glslang_tab.cpp" +#line 12520 "MachineIndependent/glslang_tab.cpp" break; - case 669: /* spirv_execution_mode_id_parameter_list: constant_expression */ -#line 4318 "MachineIndependent/glslang.y" + case 679: /* spirv_execution_mode_id_parameter_list: constant_expression */ +#line 4376 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat && (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt && @@ -12263,11 +12530,11 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), ""); (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermTypedNode)); } -#line 12267 "MachineIndependent/glslang_tab.cpp" +#line 12534 "MachineIndependent/glslang_tab.cpp" break; - case 670: /* spirv_execution_mode_id_parameter_list: spirv_execution_mode_id_parameter_list COMMA constant_expression */ -#line 4327 "MachineIndependent/glslang.y" + case 680: /* spirv_execution_mode_id_parameter_list: spirv_execution_mode_id_parameter_list COMMA constant_expression */ +#line 4385 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtFloat && (yyvsp[0].interm.intermTypedNode)->getBasicType() != EbtInt && @@ -12277,351 +12544,351 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "this type not allowed", (yyvsp[0].interm.intermTypedNode)->getType().getBasicString(), ""); (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermTypedNode)); } -#line 12281 "MachineIndependent/glslang_tab.cpp" +#line 12548 "MachineIndependent/glslang_tab.cpp" break; - case 671: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN INTCONSTANT RIGHT_PAREN */ -#line 4338 "MachineIndependent/glslang.y" + case 681: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN INTCONSTANT RIGHT_PAREN */ +#line 4396 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-3].lex).loc); (yyval.interm.type).qualifier.storage = EvqSpirvStorageClass; (yyval.interm.type).qualifier.spirvStorageClass = (yyvsp[-1].lex).i; } -#line 12291 "MachineIndependent/glslang_tab.cpp" +#line 12558 "MachineIndependent/glslang_tab.cpp" break; - case 672: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ -#line 4343 "MachineIndependent/glslang.y" + case 682: /* spirv_storage_class_qualifier: SPIRV_STORAGE_CLASS LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ +#line 4401 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); (yyval.interm.type).qualifier.storage = EvqSpirvStorageClass; (yyval.interm.type).qualifier.spirvStorageClass = (yyvsp[-1].lex).i; } -#line 12302 "MachineIndependent/glslang_tab.cpp" +#line 12569 "MachineIndependent/glslang_tab.cpp" break; - case 673: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ -#line 4351 "MachineIndependent/glslang.y" + case 683: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT RIGHT_PAREN */ +#line 4409 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-3].lex).loc); (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-1].lex).i); } -#line 12311 "MachineIndependent/glslang_tab.cpp" +#line 12578 "MachineIndependent/glslang_tab.cpp" break; - case 674: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ -#line 4355 "MachineIndependent/glslang.y" + case 684: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT RIGHT_PAREN */ +#line 4413 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-1].lex).i); } -#line 12321 "MachineIndependent/glslang_tab.cpp" +#line 12588 "MachineIndependent/glslang_tab.cpp" break; - case 675: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ -#line 4360 "MachineIndependent/glslang.y" + case 685: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ +#line 4418 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12330 "MachineIndependent/glslang_tab.cpp" +#line 12597 "MachineIndependent/glslang_tab.cpp" break; - case 676: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ -#line 4364 "MachineIndependent/glslang.y" + case 686: /* spirv_decorate_qualifier: SPIRV_DECORATE LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_parameter_list RIGHT_PAREN */ +#line 4422 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-7].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); (yyval.interm.type).qualifier.setSpirvDecorate((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12340 "MachineIndependent/glslang_tab.cpp" +#line 12607 "MachineIndependent/glslang_tab.cpp" break; - case 677: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ -#line 4369 "MachineIndependent/glslang.y" + case 687: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ +#line 4427 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); (yyval.interm.type).qualifier.setSpirvDecorateId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12349 "MachineIndependent/glslang_tab.cpp" +#line 12616 "MachineIndependent/glslang_tab.cpp" break; - case 678: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ -#line 4373 "MachineIndependent/glslang.y" + case 688: /* spirv_decorate_qualifier: SPIRV_DECORATE_ID LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_id_parameter_list RIGHT_PAREN */ +#line 4431 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-7].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); (yyval.interm.type).qualifier.setSpirvDecorateId((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12359 "MachineIndependent/glslang_tab.cpp" +#line 12626 "MachineIndependent/glslang_tab.cpp" break; - case 679: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ -#line 4378 "MachineIndependent/glslang.y" + case 689: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ +#line 4436 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc); (yyval.interm.type).qualifier.setSpirvDecorateString((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12368 "MachineIndependent/glslang_tab.cpp" +#line 12635 "MachineIndependent/glslang_tab.cpp" break; - case 680: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ -#line 4382 "MachineIndependent/glslang.y" + case 690: /* spirv_decorate_qualifier: SPIRV_DECORATE_STRING LEFT_PAREN spirv_requirements_list COMMA INTCONSTANT COMMA spirv_decorate_string_parameter_list RIGHT_PAREN */ +#line 4440 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-7].lex).loc); parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); (yyval.interm.type).qualifier.setSpirvDecorateString((yyvsp[-3].lex).i, (yyvsp[-1].interm.intermNode)->getAsAggregate()); } -#line 12378 "MachineIndependent/glslang_tab.cpp" +#line 12645 "MachineIndependent/glslang_tab.cpp" break; - case 681: /* spirv_decorate_parameter_list: spirv_decorate_parameter */ -#line 4389 "MachineIndependent/glslang.y" + case 691: /* spirv_decorate_parameter_list: spirv_decorate_parameter */ +#line 4447 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); } -#line 12386 "MachineIndependent/glslang_tab.cpp" +#line 12653 "MachineIndependent/glslang_tab.cpp" break; - case 682: /* spirv_decorate_parameter_list: spirv_decorate_parameter_list COMMA spirv_decorate_parameter */ -#line 4392 "MachineIndependent/glslang.y" + case 692: /* spirv_decorate_parameter_list: spirv_decorate_parameter_list COMMA spirv_decorate_parameter */ +#line 4450 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 12394 "MachineIndependent/glslang_tab.cpp" +#line 12661 "MachineIndependent/glslang_tab.cpp" break; - case 683: /* spirv_decorate_parameter: FLOATCONSTANT */ -#line 4397 "MachineIndependent/glslang.y" + case 693: /* spirv_decorate_parameter: FLOATCONSTANT */ +#line 4455 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 12402 "MachineIndependent/glslang_tab.cpp" +#line 12669 "MachineIndependent/glslang_tab.cpp" break; - case 684: /* spirv_decorate_parameter: INTCONSTANT */ -#line 4400 "MachineIndependent/glslang.y" + case 694: /* spirv_decorate_parameter: INTCONSTANT */ +#line 4458 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 12410 "MachineIndependent/glslang_tab.cpp" +#line 12677 "MachineIndependent/glslang_tab.cpp" break; - case 685: /* spirv_decorate_parameter: UINTCONSTANT */ -#line 4403 "MachineIndependent/glslang.y" + case 695: /* spirv_decorate_parameter: UINTCONSTANT */ +#line 4461 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 12418 "MachineIndependent/glslang_tab.cpp" +#line 12685 "MachineIndependent/glslang_tab.cpp" break; - case 686: /* spirv_decorate_parameter: BOOLCONSTANT */ -#line 4406 "MachineIndependent/glslang.y" + case 696: /* spirv_decorate_parameter: BOOLCONSTANT */ +#line 4464 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 12426 "MachineIndependent/glslang_tab.cpp" +#line 12693 "MachineIndependent/glslang_tab.cpp" break; - case 687: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter */ -#line 4411 "MachineIndependent/glslang.y" + case 697: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter */ +#line 4469 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate((yyvsp[0].interm.intermNode)); } -#line 12434 "MachineIndependent/glslang_tab.cpp" +#line 12701 "MachineIndependent/glslang_tab.cpp" break; - case 688: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter_list COMMA spirv_decorate_id_parameter */ -#line 4414 "MachineIndependent/glslang.y" + case 698: /* spirv_decorate_id_parameter_list: spirv_decorate_id_parameter_list COMMA spirv_decorate_id_parameter */ +#line 4472 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), (yyvsp[0].interm.intermNode)); } -#line 12442 "MachineIndependent/glslang_tab.cpp" +#line 12709 "MachineIndependent/glslang_tab.cpp" break; - case 689: /* spirv_decorate_id_parameter: variable_identifier */ -#line 4419 "MachineIndependent/glslang.y" + case 699: /* spirv_decorate_id_parameter: variable_identifier */ +#line 4477 "MachineIndependent/glslang.y" { if ((yyvsp[0].interm.intermTypedNode)->getAsConstantUnion() || (yyvsp[0].interm.intermTypedNode)->getAsSymbolNode()) (yyval.interm.intermNode) = (yyvsp[0].interm.intermTypedNode); else parseContext.error((yyvsp[0].interm.intermTypedNode)->getLoc(), "only allow constants or variables which are not elements of a composite", "", ""); } -#line 12453 "MachineIndependent/glslang_tab.cpp" +#line 12720 "MachineIndependent/glslang_tab.cpp" break; - case 690: /* spirv_decorate_id_parameter: FLOATCONSTANT */ -#line 4425 "MachineIndependent/glslang.y" + case 700: /* spirv_decorate_id_parameter: FLOATCONSTANT */ +#line 4483 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).d, EbtFloat, (yyvsp[0].lex).loc, true); } -#line 12461 "MachineIndependent/glslang_tab.cpp" +#line 12728 "MachineIndependent/glslang_tab.cpp" break; - case 691: /* spirv_decorate_id_parameter: INTCONSTANT */ -#line 4428 "MachineIndependent/glslang.y" + case 701: /* spirv_decorate_id_parameter: INTCONSTANT */ +#line 4486 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).i, (yyvsp[0].lex).loc, true); } -#line 12469 "MachineIndependent/glslang_tab.cpp" +#line 12736 "MachineIndependent/glslang_tab.cpp" break; - case 692: /* spirv_decorate_id_parameter: UINTCONSTANT */ -#line 4431 "MachineIndependent/glslang.y" + case 702: /* spirv_decorate_id_parameter: UINTCONSTANT */ +#line 4489 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).u, (yyvsp[0].lex).loc, true); } -#line 12477 "MachineIndependent/glslang_tab.cpp" +#line 12744 "MachineIndependent/glslang_tab.cpp" break; - case 693: /* spirv_decorate_id_parameter: BOOLCONSTANT */ -#line 4434 "MachineIndependent/glslang.y" + case 703: /* spirv_decorate_id_parameter: BOOLCONSTANT */ +#line 4492 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.addConstantUnion((yyvsp[0].lex).b, (yyvsp[0].lex).loc, true); } -#line 12485 "MachineIndependent/glslang_tab.cpp" +#line 12752 "MachineIndependent/glslang_tab.cpp" break; - case 694: /* spirv_decorate_string_parameter_list: STRING_LITERAL */ -#line 4439 "MachineIndependent/glslang.y" + case 704: /* spirv_decorate_string_parameter_list: STRING_LITERAL */ +#line 4497 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.makeAggregate( parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 12494 "MachineIndependent/glslang_tab.cpp" +#line 12761 "MachineIndependent/glslang_tab.cpp" break; - case 695: /* spirv_decorate_string_parameter_list: spirv_decorate_string_parameter_list COMMA STRING_LITERAL */ -#line 4443 "MachineIndependent/glslang.y" + case 705: /* spirv_decorate_string_parameter_list: spirv_decorate_string_parameter_list COMMA STRING_LITERAL */ +#line 4501 "MachineIndependent/glslang.y" { (yyval.interm.intermNode) = parseContext.intermediate.growAggregate((yyvsp[-2].interm.intermNode), parseContext.intermediate.addConstantUnion((yyvsp[0].lex).string, (yyvsp[0].lex).loc, true)); } -#line 12502 "MachineIndependent/glslang_tab.cpp" +#line 12769 "MachineIndependent/glslang_tab.cpp" break; - case 696: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ -#line 4448 "MachineIndependent/glslang.y" + case 706: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ +#line 4506 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).setSpirvType(*(yyvsp[-3].interm.spirvInst), (yyvsp[-1].interm.spirvTypeParams)); } -#line 12511 "MachineIndependent/glslang_tab.cpp" +#line 12778 "MachineIndependent/glslang_tab.cpp" break; - case 697: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ -#line 4452 "MachineIndependent/glslang.y" + case 707: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list COMMA spirv_type_parameter_list RIGHT_PAREN */ +#line 4510 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-7].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.intermediate.insertSpirvRequirement((yyvsp[-5].interm.spirvReq)); (yyval.interm.type).setSpirvType(*(yyvsp[-3].interm.spirvInst), (yyvsp[-1].interm.spirvTypeParams)); } -#line 12521 "MachineIndependent/glslang_tab.cpp" +#line 12788 "MachineIndependent/glslang_tab.cpp" break; - case 698: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4457 "MachineIndependent/glslang.y" + case 708: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4515 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-3].lex).loc, parseContext.symbolTable.atGlobalLevel()); (yyval.interm.type).setSpirvType(*(yyvsp[-1].interm.spirvInst)); } -#line 12530 "MachineIndependent/glslang_tab.cpp" +#line 12797 "MachineIndependent/glslang_tab.cpp" break; - case 699: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4461 "MachineIndependent/glslang.y" + case 709: /* spirv_type_specifier: SPIRV_TYPE LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4519 "MachineIndependent/glslang.y" { (yyval.interm.type).init((yyvsp[-5].lex).loc, parseContext.symbolTable.atGlobalLevel()); parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); (yyval.interm.type).setSpirvType(*(yyvsp[-1].interm.spirvInst)); } -#line 12540 "MachineIndependent/glslang_tab.cpp" +#line 12807 "MachineIndependent/glslang_tab.cpp" break; - case 700: /* spirv_type_parameter_list: spirv_type_parameter */ -#line 4468 "MachineIndependent/glslang.y" + case 710: /* spirv_type_parameter_list: spirv_type_parameter */ +#line 4526 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = (yyvsp[0].interm.spirvTypeParams); } -#line 12548 "MachineIndependent/glslang_tab.cpp" +#line 12815 "MachineIndependent/glslang_tab.cpp" break; - case 701: /* spirv_type_parameter_list: spirv_type_parameter_list COMMA spirv_type_parameter */ -#line 4471 "MachineIndependent/glslang.y" + case 711: /* spirv_type_parameter_list: spirv_type_parameter_list COMMA spirv_type_parameter */ +#line 4529 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = parseContext.mergeSpirvTypeParameters((yyvsp[-2].interm.spirvTypeParams), (yyvsp[0].interm.spirvTypeParams)); } -#line 12556 "MachineIndependent/glslang_tab.cpp" +#line 12823 "MachineIndependent/glslang_tab.cpp" break; - case 702: /* spirv_type_parameter: constant_expression */ -#line 4476 "MachineIndependent/glslang.y" + case 712: /* spirv_type_parameter: constant_expression */ +#line 4534 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = parseContext.makeSpirvTypeParameters((yyvsp[0].interm.intermTypedNode)->getLoc(), (yyvsp[0].interm.intermTypedNode)->getAsConstantUnion()); } -#line 12564 "MachineIndependent/glslang_tab.cpp" +#line 12831 "MachineIndependent/glslang_tab.cpp" break; - case 703: /* spirv_type_parameter: type_specifier_nonarray */ -#line 4479 "MachineIndependent/glslang.y" + case 713: /* spirv_type_parameter: type_specifier_nonarray */ +#line 4537 "MachineIndependent/glslang.y" { (yyval.interm.spirvTypeParams) = parseContext.makeSpirvTypeParameters((yyvsp[0].interm.type).loc, (yyvsp[0].interm.type)); } -#line 12572 "MachineIndependent/glslang_tab.cpp" +#line 12839 "MachineIndependent/glslang_tab.cpp" break; - case 704: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4484 "MachineIndependent/glslang.y" + case 714: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4542 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = (yyvsp[-1].interm.spirvInst); } -#line 12580 "MachineIndependent/glslang_tab.cpp" +#line 12847 "MachineIndependent/glslang_tab.cpp" break; - case 705: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ -#line 4487 "MachineIndependent/glslang.y" + case 715: /* spirv_instruction_qualifier: SPIRV_INSTRUCTION LEFT_PAREN spirv_requirements_list COMMA spirv_instruction_qualifier_list RIGHT_PAREN */ +#line 4545 "MachineIndependent/glslang.y" { parseContext.intermediate.insertSpirvRequirement((yyvsp[-3].interm.spirvReq)); (yyval.interm.spirvInst) = (yyvsp[-1].interm.spirvInst); } -#line 12589 "MachineIndependent/glslang_tab.cpp" +#line 12856 "MachineIndependent/glslang_tab.cpp" break; - case 706: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_id */ -#line 4493 "MachineIndependent/glslang.y" + case 716: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_id */ +#line 4551 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = (yyvsp[0].interm.spirvInst); } -#line 12597 "MachineIndependent/glslang_tab.cpp" +#line 12864 "MachineIndependent/glslang_tab.cpp" break; - case 707: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_list COMMA spirv_instruction_qualifier_id */ -#line 4496 "MachineIndependent/glslang.y" + case 717: /* spirv_instruction_qualifier_list: spirv_instruction_qualifier_list COMMA spirv_instruction_qualifier_id */ +#line 4554 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = parseContext.mergeSpirvInstruction((yyvsp[-1].lex).loc, (yyvsp[-2].interm.spirvInst), (yyvsp[0].interm.spirvInst)); } -#line 12605 "MachineIndependent/glslang_tab.cpp" +#line 12872 "MachineIndependent/glslang_tab.cpp" break; - case 708: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL STRING_LITERAL */ -#line 4501 "MachineIndependent/glslang.y" + case 718: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL STRING_LITERAL */ +#line 4559 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = parseContext.makeSpirvInstruction((yyvsp[-1].lex).loc, *(yyvsp[-2].lex).string, *(yyvsp[0].lex).string); } -#line 12613 "MachineIndependent/glslang_tab.cpp" +#line 12880 "MachineIndependent/glslang_tab.cpp" break; - case 709: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL INTCONSTANT */ -#line 4504 "MachineIndependent/glslang.y" + case 719: /* spirv_instruction_qualifier_id: IDENTIFIER EQUAL INTCONSTANT */ +#line 4562 "MachineIndependent/glslang.y" { (yyval.interm.spirvInst) = parseContext.makeSpirvInstruction((yyvsp[-1].lex).loc, *(yyvsp[-2].lex).string, (yyvsp[0].lex).i); } -#line 12621 "MachineIndependent/glslang_tab.cpp" +#line 12888 "MachineIndependent/glslang_tab.cpp" break; -#line 12625 "MachineIndependent/glslang_tab.cpp" +#line 12892 "MachineIndependent/glslang_tab.cpp" default: break; } @@ -12845,5 +13112,5 @@ YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); return yyresult; } -#line 4508 "MachineIndependent/glslang.y" +#line 4566 "MachineIndependent/glslang.y" diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp.h b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp.h index 2ff6f78..b92ddec 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp.h +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp.h @@ -114,417 +114,426 @@ extern int yydebug; UTEXTURE2DARRAY = 315, /* UTEXTURE2DARRAY */ ATTRIBUTE = 316, /* ATTRIBUTE */ VARYING = 317, /* VARYING */ - BFLOAT16_T = 318, /* BFLOAT16_T */ - FLOAT16_T = 319, /* FLOAT16_T */ - FLOAT32_T = 320, /* FLOAT32_T */ - DOUBLE = 321, /* DOUBLE */ - FLOAT64_T = 322, /* FLOAT64_T */ - INT64_T = 323, /* INT64_T */ - UINT64_T = 324, /* UINT64_T */ - INT32_T = 325, /* INT32_T */ - UINT32_T = 326, /* UINT32_T */ - INT16_T = 327, /* INT16_T */ - UINT16_T = 328, /* UINT16_T */ - INT8_T = 329, /* INT8_T */ - UINT8_T = 330, /* UINT8_T */ - I64VEC2 = 331, /* I64VEC2 */ - I64VEC3 = 332, /* I64VEC3 */ - I64VEC4 = 333, /* I64VEC4 */ - U64VEC2 = 334, /* U64VEC2 */ - U64VEC3 = 335, /* U64VEC3 */ - U64VEC4 = 336, /* U64VEC4 */ - I32VEC2 = 337, /* I32VEC2 */ - I32VEC3 = 338, /* I32VEC3 */ - I32VEC4 = 339, /* I32VEC4 */ - U32VEC2 = 340, /* U32VEC2 */ - U32VEC3 = 341, /* U32VEC3 */ - U32VEC4 = 342, /* U32VEC4 */ - I16VEC2 = 343, /* I16VEC2 */ - I16VEC3 = 344, /* I16VEC3 */ - I16VEC4 = 345, /* I16VEC4 */ - U16VEC2 = 346, /* U16VEC2 */ - U16VEC3 = 347, /* U16VEC3 */ - U16VEC4 = 348, /* U16VEC4 */ - I8VEC2 = 349, /* I8VEC2 */ - I8VEC3 = 350, /* I8VEC3 */ - I8VEC4 = 351, /* I8VEC4 */ - U8VEC2 = 352, /* U8VEC2 */ - U8VEC3 = 353, /* U8VEC3 */ - U8VEC4 = 354, /* U8VEC4 */ - DVEC2 = 355, /* DVEC2 */ - DVEC3 = 356, /* DVEC3 */ - DVEC4 = 357, /* DVEC4 */ - DMAT2 = 358, /* DMAT2 */ - DMAT3 = 359, /* DMAT3 */ - DMAT4 = 360, /* DMAT4 */ - BF16VEC2 = 361, /* BF16VEC2 */ - BF16VEC3 = 362, /* BF16VEC3 */ - BF16VEC4 = 363, /* BF16VEC4 */ - F16VEC2 = 364, /* F16VEC2 */ - F16VEC3 = 365, /* F16VEC3 */ - F16VEC4 = 366, /* F16VEC4 */ - F16MAT2 = 367, /* F16MAT2 */ - F16MAT3 = 368, /* F16MAT3 */ - F16MAT4 = 369, /* F16MAT4 */ - F32VEC2 = 370, /* F32VEC2 */ - F32VEC3 = 371, /* F32VEC3 */ - F32VEC4 = 372, /* F32VEC4 */ - F32MAT2 = 373, /* F32MAT2 */ - F32MAT3 = 374, /* F32MAT3 */ - F32MAT4 = 375, /* F32MAT4 */ - F64VEC2 = 376, /* F64VEC2 */ - F64VEC3 = 377, /* F64VEC3 */ - F64VEC4 = 378, /* F64VEC4 */ - F64MAT2 = 379, /* F64MAT2 */ - F64MAT3 = 380, /* F64MAT3 */ - F64MAT4 = 381, /* F64MAT4 */ - DMAT2X2 = 382, /* DMAT2X2 */ - DMAT2X3 = 383, /* DMAT2X3 */ - DMAT2X4 = 384, /* DMAT2X4 */ - DMAT3X2 = 385, /* DMAT3X2 */ - DMAT3X3 = 386, /* DMAT3X3 */ - DMAT3X4 = 387, /* DMAT3X4 */ - DMAT4X2 = 388, /* DMAT4X2 */ - DMAT4X3 = 389, /* DMAT4X3 */ - DMAT4X4 = 390, /* DMAT4X4 */ - F16MAT2X2 = 391, /* F16MAT2X2 */ - F16MAT2X3 = 392, /* F16MAT2X3 */ - F16MAT2X4 = 393, /* F16MAT2X4 */ - F16MAT3X2 = 394, /* F16MAT3X2 */ - F16MAT3X3 = 395, /* F16MAT3X3 */ - F16MAT3X4 = 396, /* F16MAT3X4 */ - F16MAT4X2 = 397, /* F16MAT4X2 */ - F16MAT4X3 = 398, /* F16MAT4X3 */ - F16MAT4X4 = 399, /* F16MAT4X4 */ - F32MAT2X2 = 400, /* F32MAT2X2 */ - F32MAT2X3 = 401, /* F32MAT2X3 */ - F32MAT2X4 = 402, /* F32MAT2X4 */ - F32MAT3X2 = 403, /* F32MAT3X2 */ - F32MAT3X3 = 404, /* F32MAT3X3 */ - F32MAT3X4 = 405, /* F32MAT3X4 */ - F32MAT4X2 = 406, /* F32MAT4X2 */ - F32MAT4X3 = 407, /* F32MAT4X3 */ - F32MAT4X4 = 408, /* F32MAT4X4 */ - F64MAT2X2 = 409, /* F64MAT2X2 */ - F64MAT2X3 = 410, /* F64MAT2X3 */ - F64MAT2X4 = 411, /* F64MAT2X4 */ - F64MAT3X2 = 412, /* F64MAT3X2 */ - F64MAT3X3 = 413, /* F64MAT3X3 */ - F64MAT3X4 = 414, /* F64MAT3X4 */ - F64MAT4X2 = 415, /* F64MAT4X2 */ - F64MAT4X3 = 416, /* F64MAT4X3 */ - F64MAT4X4 = 417, /* F64MAT4X4 */ - ATOMIC_UINT = 418, /* ATOMIC_UINT */ - ACCSTRUCTNV = 419, /* ACCSTRUCTNV */ - ACCSTRUCTEXT = 420, /* ACCSTRUCTEXT */ - RAYQUERYEXT = 421, /* RAYQUERYEXT */ - FCOOPMATNV = 422, /* FCOOPMATNV */ - ICOOPMATNV = 423, /* ICOOPMATNV */ - UCOOPMATNV = 424, /* UCOOPMATNV */ - COOPMAT = 425, /* COOPMAT */ - COOPVECNV = 426, /* COOPVECNV */ - HITOBJECTNV = 427, /* HITOBJECTNV */ - HITOBJECTATTRNV = 428, /* HITOBJECTATTRNV */ - TENSORLAYOUTNV = 429, /* TENSORLAYOUTNV */ - TENSORVIEWNV = 430, /* TENSORVIEWNV */ - SAMPLERCUBEARRAY = 431, /* SAMPLERCUBEARRAY */ - SAMPLERCUBEARRAYSHADOW = 432, /* SAMPLERCUBEARRAYSHADOW */ - ISAMPLERCUBEARRAY = 433, /* ISAMPLERCUBEARRAY */ - USAMPLERCUBEARRAY = 434, /* USAMPLERCUBEARRAY */ - SAMPLER1D = 435, /* SAMPLER1D */ - SAMPLER1DARRAY = 436, /* SAMPLER1DARRAY */ - SAMPLER1DARRAYSHADOW = 437, /* SAMPLER1DARRAYSHADOW */ - ISAMPLER1D = 438, /* ISAMPLER1D */ - SAMPLER1DSHADOW = 439, /* SAMPLER1DSHADOW */ - SAMPLER2DRECT = 440, /* SAMPLER2DRECT */ - SAMPLER2DRECTSHADOW = 441, /* SAMPLER2DRECTSHADOW */ - ISAMPLER2DRECT = 442, /* ISAMPLER2DRECT */ - USAMPLER2DRECT = 443, /* USAMPLER2DRECT */ - SAMPLERBUFFER = 444, /* SAMPLERBUFFER */ - ISAMPLERBUFFER = 445, /* ISAMPLERBUFFER */ - USAMPLERBUFFER = 446, /* USAMPLERBUFFER */ - SAMPLER2DMS = 447, /* SAMPLER2DMS */ - ISAMPLER2DMS = 448, /* ISAMPLER2DMS */ - USAMPLER2DMS = 449, /* USAMPLER2DMS */ - SAMPLER2DMSARRAY = 450, /* SAMPLER2DMSARRAY */ - ISAMPLER2DMSARRAY = 451, /* ISAMPLER2DMSARRAY */ - USAMPLER2DMSARRAY = 452, /* USAMPLER2DMSARRAY */ - SAMPLEREXTERNALOES = 453, /* SAMPLEREXTERNALOES */ - SAMPLEREXTERNAL2DY2YEXT = 454, /* SAMPLEREXTERNAL2DY2YEXT */ - ISAMPLER1DARRAY = 455, /* ISAMPLER1DARRAY */ - USAMPLER1D = 456, /* USAMPLER1D */ - USAMPLER1DARRAY = 457, /* USAMPLER1DARRAY */ - F16SAMPLER1D = 458, /* F16SAMPLER1D */ - F16SAMPLER2D = 459, /* F16SAMPLER2D */ - F16SAMPLER3D = 460, /* F16SAMPLER3D */ - F16SAMPLER2DRECT = 461, /* F16SAMPLER2DRECT */ - F16SAMPLERCUBE = 462, /* F16SAMPLERCUBE */ - F16SAMPLER1DARRAY = 463, /* F16SAMPLER1DARRAY */ - F16SAMPLER2DARRAY = 464, /* F16SAMPLER2DARRAY */ - F16SAMPLERCUBEARRAY = 465, /* F16SAMPLERCUBEARRAY */ - F16SAMPLERBUFFER = 466, /* F16SAMPLERBUFFER */ - F16SAMPLER2DMS = 467, /* F16SAMPLER2DMS */ - F16SAMPLER2DMSARRAY = 468, /* F16SAMPLER2DMSARRAY */ - F16SAMPLER1DSHADOW = 469, /* F16SAMPLER1DSHADOW */ - F16SAMPLER2DSHADOW = 470, /* F16SAMPLER2DSHADOW */ - F16SAMPLER1DARRAYSHADOW = 471, /* F16SAMPLER1DARRAYSHADOW */ - F16SAMPLER2DARRAYSHADOW = 472, /* F16SAMPLER2DARRAYSHADOW */ - F16SAMPLER2DRECTSHADOW = 473, /* F16SAMPLER2DRECTSHADOW */ - F16SAMPLERCUBESHADOW = 474, /* F16SAMPLERCUBESHADOW */ - F16SAMPLERCUBEARRAYSHADOW = 475, /* F16SAMPLERCUBEARRAYSHADOW */ - IMAGE1D = 476, /* IMAGE1D */ - IIMAGE1D = 477, /* IIMAGE1D */ - UIMAGE1D = 478, /* UIMAGE1D */ - IMAGE2D = 479, /* IMAGE2D */ - IIMAGE2D = 480, /* IIMAGE2D */ - UIMAGE2D = 481, /* UIMAGE2D */ - IMAGE3D = 482, /* IMAGE3D */ - IIMAGE3D = 483, /* IIMAGE3D */ - UIMAGE3D = 484, /* UIMAGE3D */ - IMAGE2DRECT = 485, /* IMAGE2DRECT */ - IIMAGE2DRECT = 486, /* IIMAGE2DRECT */ - UIMAGE2DRECT = 487, /* UIMAGE2DRECT */ - IMAGECUBE = 488, /* IMAGECUBE */ - IIMAGECUBE = 489, /* IIMAGECUBE */ - UIMAGECUBE = 490, /* UIMAGECUBE */ - IMAGEBUFFER = 491, /* IMAGEBUFFER */ - IIMAGEBUFFER = 492, /* IIMAGEBUFFER */ - UIMAGEBUFFER = 493, /* UIMAGEBUFFER */ - IMAGE1DARRAY = 494, /* IMAGE1DARRAY */ - IIMAGE1DARRAY = 495, /* IIMAGE1DARRAY */ - UIMAGE1DARRAY = 496, /* UIMAGE1DARRAY */ - IMAGE2DARRAY = 497, /* IMAGE2DARRAY */ - IIMAGE2DARRAY = 498, /* IIMAGE2DARRAY */ - UIMAGE2DARRAY = 499, /* UIMAGE2DARRAY */ - IMAGECUBEARRAY = 500, /* IMAGECUBEARRAY */ - IIMAGECUBEARRAY = 501, /* IIMAGECUBEARRAY */ - UIMAGECUBEARRAY = 502, /* UIMAGECUBEARRAY */ - IMAGE2DMS = 503, /* IMAGE2DMS */ - IIMAGE2DMS = 504, /* IIMAGE2DMS */ - UIMAGE2DMS = 505, /* UIMAGE2DMS */ - IMAGE2DMSARRAY = 506, /* IMAGE2DMSARRAY */ - IIMAGE2DMSARRAY = 507, /* IIMAGE2DMSARRAY */ - UIMAGE2DMSARRAY = 508, /* UIMAGE2DMSARRAY */ - F16IMAGE1D = 509, /* F16IMAGE1D */ - F16IMAGE2D = 510, /* F16IMAGE2D */ - F16IMAGE3D = 511, /* F16IMAGE3D */ - F16IMAGE2DRECT = 512, /* F16IMAGE2DRECT */ - F16IMAGECUBE = 513, /* F16IMAGECUBE */ - F16IMAGE1DARRAY = 514, /* F16IMAGE1DARRAY */ - F16IMAGE2DARRAY = 515, /* F16IMAGE2DARRAY */ - F16IMAGECUBEARRAY = 516, /* F16IMAGECUBEARRAY */ - F16IMAGEBUFFER = 517, /* F16IMAGEBUFFER */ - F16IMAGE2DMS = 518, /* F16IMAGE2DMS */ - F16IMAGE2DMSARRAY = 519, /* F16IMAGE2DMSARRAY */ - I64IMAGE1D = 520, /* I64IMAGE1D */ - U64IMAGE1D = 521, /* U64IMAGE1D */ - I64IMAGE2D = 522, /* I64IMAGE2D */ - U64IMAGE2D = 523, /* U64IMAGE2D */ - I64IMAGE3D = 524, /* I64IMAGE3D */ - U64IMAGE3D = 525, /* U64IMAGE3D */ - I64IMAGE2DRECT = 526, /* I64IMAGE2DRECT */ - U64IMAGE2DRECT = 527, /* U64IMAGE2DRECT */ - I64IMAGECUBE = 528, /* I64IMAGECUBE */ - U64IMAGECUBE = 529, /* U64IMAGECUBE */ - I64IMAGEBUFFER = 530, /* I64IMAGEBUFFER */ - U64IMAGEBUFFER = 531, /* U64IMAGEBUFFER */ - I64IMAGE1DARRAY = 532, /* I64IMAGE1DARRAY */ - U64IMAGE1DARRAY = 533, /* U64IMAGE1DARRAY */ - I64IMAGE2DARRAY = 534, /* I64IMAGE2DARRAY */ - U64IMAGE2DARRAY = 535, /* U64IMAGE2DARRAY */ - I64IMAGECUBEARRAY = 536, /* I64IMAGECUBEARRAY */ - U64IMAGECUBEARRAY = 537, /* U64IMAGECUBEARRAY */ - I64IMAGE2DMS = 538, /* I64IMAGE2DMS */ - U64IMAGE2DMS = 539, /* U64IMAGE2DMS */ - I64IMAGE2DMSARRAY = 540, /* I64IMAGE2DMSARRAY */ - U64IMAGE2DMSARRAY = 541, /* U64IMAGE2DMSARRAY */ - TEXTURECUBEARRAY = 542, /* TEXTURECUBEARRAY */ - ITEXTURECUBEARRAY = 543, /* ITEXTURECUBEARRAY */ - UTEXTURECUBEARRAY = 544, /* UTEXTURECUBEARRAY */ - TEXTURE1D = 545, /* TEXTURE1D */ - ITEXTURE1D = 546, /* ITEXTURE1D */ - UTEXTURE1D = 547, /* UTEXTURE1D */ - TEXTURE1DARRAY = 548, /* TEXTURE1DARRAY */ - ITEXTURE1DARRAY = 549, /* ITEXTURE1DARRAY */ - UTEXTURE1DARRAY = 550, /* UTEXTURE1DARRAY */ - TEXTURE2DRECT = 551, /* TEXTURE2DRECT */ - ITEXTURE2DRECT = 552, /* ITEXTURE2DRECT */ - UTEXTURE2DRECT = 553, /* UTEXTURE2DRECT */ - TEXTUREBUFFER = 554, /* TEXTUREBUFFER */ - ITEXTUREBUFFER = 555, /* ITEXTUREBUFFER */ - UTEXTUREBUFFER = 556, /* UTEXTUREBUFFER */ - TEXTURE2DMS = 557, /* TEXTURE2DMS */ - ITEXTURE2DMS = 558, /* ITEXTURE2DMS */ - UTEXTURE2DMS = 559, /* UTEXTURE2DMS */ - TEXTURE2DMSARRAY = 560, /* TEXTURE2DMSARRAY */ - ITEXTURE2DMSARRAY = 561, /* ITEXTURE2DMSARRAY */ - UTEXTURE2DMSARRAY = 562, /* UTEXTURE2DMSARRAY */ - F16TEXTURE1D = 563, /* F16TEXTURE1D */ - F16TEXTURE2D = 564, /* F16TEXTURE2D */ - F16TEXTURE3D = 565, /* F16TEXTURE3D */ - F16TEXTURE2DRECT = 566, /* F16TEXTURE2DRECT */ - F16TEXTURECUBE = 567, /* F16TEXTURECUBE */ - F16TEXTURE1DARRAY = 568, /* F16TEXTURE1DARRAY */ - F16TEXTURE2DARRAY = 569, /* F16TEXTURE2DARRAY */ - F16TEXTURECUBEARRAY = 570, /* F16TEXTURECUBEARRAY */ - F16TEXTUREBUFFER = 571, /* F16TEXTUREBUFFER */ - F16TEXTURE2DMS = 572, /* F16TEXTURE2DMS */ - F16TEXTURE2DMSARRAY = 573, /* F16TEXTURE2DMSARRAY */ - SUBPASSINPUT = 574, /* SUBPASSINPUT */ - SUBPASSINPUTMS = 575, /* SUBPASSINPUTMS */ - ISUBPASSINPUT = 576, /* ISUBPASSINPUT */ - ISUBPASSINPUTMS = 577, /* ISUBPASSINPUTMS */ - USUBPASSINPUT = 578, /* USUBPASSINPUT */ - USUBPASSINPUTMS = 579, /* USUBPASSINPUTMS */ - F16SUBPASSINPUT = 580, /* F16SUBPASSINPUT */ - F16SUBPASSINPUTMS = 581, /* F16SUBPASSINPUTMS */ - SPIRV_INSTRUCTION = 582, /* SPIRV_INSTRUCTION */ - SPIRV_EXECUTION_MODE = 583, /* SPIRV_EXECUTION_MODE */ - SPIRV_EXECUTION_MODE_ID = 584, /* SPIRV_EXECUTION_MODE_ID */ - SPIRV_DECORATE = 585, /* SPIRV_DECORATE */ - SPIRV_DECORATE_ID = 586, /* SPIRV_DECORATE_ID */ - SPIRV_DECORATE_STRING = 587, /* SPIRV_DECORATE_STRING */ - SPIRV_TYPE = 588, /* SPIRV_TYPE */ - SPIRV_STORAGE_CLASS = 589, /* SPIRV_STORAGE_CLASS */ - SPIRV_BY_REFERENCE = 590, /* SPIRV_BY_REFERENCE */ - SPIRV_LITERAL = 591, /* SPIRV_LITERAL */ - ATTACHMENTEXT = 592, /* ATTACHMENTEXT */ - IATTACHMENTEXT = 593, /* IATTACHMENTEXT */ - UATTACHMENTEXT = 594, /* UATTACHMENTEXT */ - LEFT_OP = 595, /* LEFT_OP */ - RIGHT_OP = 596, /* RIGHT_OP */ - INC_OP = 597, /* INC_OP */ - DEC_OP = 598, /* DEC_OP */ - LE_OP = 599, /* LE_OP */ - GE_OP = 600, /* GE_OP */ - EQ_OP = 601, /* EQ_OP */ - NE_OP = 602, /* NE_OP */ - AND_OP = 603, /* AND_OP */ - OR_OP = 604, /* OR_OP */ - XOR_OP = 605, /* XOR_OP */ - MUL_ASSIGN = 606, /* MUL_ASSIGN */ - DIV_ASSIGN = 607, /* DIV_ASSIGN */ - ADD_ASSIGN = 608, /* ADD_ASSIGN */ - MOD_ASSIGN = 609, /* MOD_ASSIGN */ - LEFT_ASSIGN = 610, /* LEFT_ASSIGN */ - RIGHT_ASSIGN = 611, /* RIGHT_ASSIGN */ - AND_ASSIGN = 612, /* AND_ASSIGN */ - XOR_ASSIGN = 613, /* XOR_ASSIGN */ - OR_ASSIGN = 614, /* OR_ASSIGN */ - SUB_ASSIGN = 615, /* SUB_ASSIGN */ - STRING_LITERAL = 616, /* STRING_LITERAL */ - LEFT_PAREN = 617, /* LEFT_PAREN */ - RIGHT_PAREN = 618, /* RIGHT_PAREN */ - LEFT_BRACKET = 619, /* LEFT_BRACKET */ - RIGHT_BRACKET = 620, /* RIGHT_BRACKET */ - LEFT_BRACE = 621, /* LEFT_BRACE */ - RIGHT_BRACE = 622, /* RIGHT_BRACE */ - DOT = 623, /* DOT */ - COMMA = 624, /* COMMA */ - COLON = 625, /* COLON */ - EQUAL = 626, /* EQUAL */ - SEMICOLON = 627, /* SEMICOLON */ - BANG = 628, /* BANG */ - DASH = 629, /* DASH */ - TILDE = 630, /* TILDE */ - PLUS = 631, /* PLUS */ - STAR = 632, /* STAR */ - SLASH = 633, /* SLASH */ - PERCENT = 634, /* PERCENT */ - LEFT_ANGLE = 635, /* LEFT_ANGLE */ - RIGHT_ANGLE = 636, /* RIGHT_ANGLE */ - VERTICAL_BAR = 637, /* VERTICAL_BAR */ - CARET = 638, /* CARET */ - AMPERSAND = 639, /* AMPERSAND */ - QUESTION = 640, /* QUESTION */ - INVARIANT = 641, /* INVARIANT */ - HIGH_PRECISION = 642, /* HIGH_PRECISION */ - MEDIUM_PRECISION = 643, /* MEDIUM_PRECISION */ - LOW_PRECISION = 644, /* LOW_PRECISION */ - PRECISION = 645, /* PRECISION */ - PACKED = 646, /* PACKED */ - RESOURCE = 647, /* RESOURCE */ - SUPERP = 648, /* SUPERP */ - FLOATCONSTANT = 649, /* FLOATCONSTANT */ - INTCONSTANT = 650, /* INTCONSTANT */ - UINTCONSTANT = 651, /* UINTCONSTANT */ - BOOLCONSTANT = 652, /* BOOLCONSTANT */ - IDENTIFIER = 653, /* IDENTIFIER */ - TYPE_NAME = 654, /* TYPE_NAME */ - CENTROID = 655, /* CENTROID */ - IN = 656, /* IN */ - OUT = 657, /* OUT */ - INOUT = 658, /* INOUT */ - STRUCT = 659, /* STRUCT */ - VOID = 660, /* VOID */ - WHILE = 661, /* WHILE */ - BREAK = 662, /* BREAK */ - CONTINUE = 663, /* CONTINUE */ - DO = 664, /* DO */ - ELSE = 665, /* ELSE */ - FOR = 666, /* FOR */ - IF = 667, /* IF */ - DISCARD = 668, /* DISCARD */ - RETURN = 669, /* RETURN */ - SWITCH = 670, /* SWITCH */ - CASE = 671, /* CASE */ - DEFAULT = 672, /* DEFAULT */ - TERMINATE_INVOCATION = 673, /* TERMINATE_INVOCATION */ - TERMINATE_RAY = 674, /* TERMINATE_RAY */ - IGNORE_INTERSECTION = 675, /* IGNORE_INTERSECTION */ - UNIFORM = 676, /* UNIFORM */ - SHARED = 677, /* SHARED */ - BUFFER = 678, /* BUFFER */ - TILEIMAGEEXT = 679, /* TILEIMAGEEXT */ - FLAT = 680, /* FLAT */ - SMOOTH = 681, /* SMOOTH */ - LAYOUT = 682, /* LAYOUT */ - DOUBLECONSTANT = 683, /* DOUBLECONSTANT */ - INT16CONSTANT = 684, /* INT16CONSTANT */ - UINT16CONSTANT = 685, /* UINT16CONSTANT */ - FLOAT16CONSTANT = 686, /* FLOAT16CONSTANT */ - INT32CONSTANT = 687, /* INT32CONSTANT */ - UINT32CONSTANT = 688, /* UINT32CONSTANT */ - INT64CONSTANT = 689, /* INT64CONSTANT */ - UINT64CONSTANT = 690, /* UINT64CONSTANT */ - SUBROUTINE = 691, /* SUBROUTINE */ - DEMOTE = 692, /* DEMOTE */ - FUNCTION = 693, /* FUNCTION */ - PAYLOADNV = 694, /* PAYLOADNV */ - PAYLOADINNV = 695, /* PAYLOADINNV */ - HITATTRNV = 696, /* HITATTRNV */ - CALLDATANV = 697, /* CALLDATANV */ - CALLDATAINNV = 698, /* CALLDATAINNV */ - PAYLOADEXT = 699, /* PAYLOADEXT */ - PAYLOADINEXT = 700, /* PAYLOADINEXT */ - HITATTREXT = 701, /* HITATTREXT */ - CALLDATAEXT = 702, /* CALLDATAEXT */ - CALLDATAINEXT = 703, /* CALLDATAINEXT */ - PATCH = 704, /* PATCH */ - SAMPLE = 705, /* SAMPLE */ - NONUNIFORM = 706, /* NONUNIFORM */ - COHERENT = 707, /* COHERENT */ - VOLATILE = 708, /* VOLATILE */ - RESTRICT = 709, /* RESTRICT */ - READONLY = 710, /* READONLY */ - WRITEONLY = 711, /* WRITEONLY */ - NONTEMPORAL = 712, /* NONTEMPORAL */ - DEVICECOHERENT = 713, /* DEVICECOHERENT */ - QUEUEFAMILYCOHERENT = 714, /* QUEUEFAMILYCOHERENT */ - WORKGROUPCOHERENT = 715, /* WORKGROUPCOHERENT */ - SUBGROUPCOHERENT = 716, /* SUBGROUPCOHERENT */ - NONPRIVATE = 717, /* NONPRIVATE */ - SHADERCALLCOHERENT = 718, /* SHADERCALLCOHERENT */ - NOPERSPECTIVE = 719, /* NOPERSPECTIVE */ - EXPLICITINTERPAMD = 720, /* EXPLICITINTERPAMD */ - PERVERTEXEXT = 721, /* PERVERTEXEXT */ - PERVERTEXNV = 722, /* PERVERTEXNV */ - PERPRIMITIVENV = 723, /* PERPRIMITIVENV */ - PERVIEWNV = 724, /* PERVIEWNV */ - PERTASKNV = 725, /* PERTASKNV */ - PERPRIMITIVEEXT = 726, /* PERPRIMITIVEEXT */ - TASKPAYLOADWORKGROUPEXT = 727, /* TASKPAYLOADWORKGROUPEXT */ - PRECISE = 728 /* PRECISE */ + FLOATE5M2_T = 318, /* FLOATE5M2_T */ + FLOATE4M3_T = 319, /* FLOATE4M3_T */ + BFLOAT16_T = 320, /* BFLOAT16_T */ + FLOAT16_T = 321, /* FLOAT16_T */ + FLOAT32_T = 322, /* FLOAT32_T */ + DOUBLE = 323, /* DOUBLE */ + FLOAT64_T = 324, /* FLOAT64_T */ + INT64_T = 325, /* INT64_T */ + UINT64_T = 326, /* UINT64_T */ + INT32_T = 327, /* INT32_T */ + UINT32_T = 328, /* UINT32_T */ + INT16_T = 329, /* INT16_T */ + UINT16_T = 330, /* UINT16_T */ + INT8_T = 331, /* INT8_T */ + UINT8_T = 332, /* UINT8_T */ + I64VEC2 = 333, /* I64VEC2 */ + I64VEC3 = 334, /* I64VEC3 */ + I64VEC4 = 335, /* I64VEC4 */ + U64VEC2 = 336, /* U64VEC2 */ + U64VEC3 = 337, /* U64VEC3 */ + U64VEC4 = 338, /* U64VEC4 */ + I32VEC2 = 339, /* I32VEC2 */ + I32VEC3 = 340, /* I32VEC3 */ + I32VEC4 = 341, /* I32VEC4 */ + U32VEC2 = 342, /* U32VEC2 */ + U32VEC3 = 343, /* U32VEC3 */ + U32VEC4 = 344, /* U32VEC4 */ + I16VEC2 = 345, /* I16VEC2 */ + I16VEC3 = 346, /* I16VEC3 */ + I16VEC4 = 347, /* I16VEC4 */ + U16VEC2 = 348, /* U16VEC2 */ + U16VEC3 = 349, /* U16VEC3 */ + U16VEC4 = 350, /* U16VEC4 */ + I8VEC2 = 351, /* I8VEC2 */ + I8VEC3 = 352, /* I8VEC3 */ + I8VEC4 = 353, /* I8VEC4 */ + U8VEC2 = 354, /* U8VEC2 */ + U8VEC3 = 355, /* U8VEC3 */ + U8VEC4 = 356, /* U8VEC4 */ + DVEC2 = 357, /* DVEC2 */ + DVEC3 = 358, /* DVEC3 */ + DVEC4 = 359, /* DVEC4 */ + DMAT2 = 360, /* DMAT2 */ + DMAT3 = 361, /* DMAT3 */ + DMAT4 = 362, /* DMAT4 */ + BF16VEC2 = 363, /* BF16VEC2 */ + BF16VEC3 = 364, /* BF16VEC3 */ + BF16VEC4 = 365, /* BF16VEC4 */ + FE5M2VEC2 = 366, /* FE5M2VEC2 */ + FE5M2VEC3 = 367, /* FE5M2VEC3 */ + FE5M2VEC4 = 368, /* FE5M2VEC4 */ + FE4M3VEC2 = 369, /* FE4M3VEC2 */ + FE4M3VEC3 = 370, /* FE4M3VEC3 */ + FE4M3VEC4 = 371, /* FE4M3VEC4 */ + F16VEC2 = 372, /* F16VEC2 */ + F16VEC3 = 373, /* F16VEC3 */ + F16VEC4 = 374, /* F16VEC4 */ + F16MAT2 = 375, /* F16MAT2 */ + F16MAT3 = 376, /* F16MAT3 */ + F16MAT4 = 377, /* F16MAT4 */ + F32VEC2 = 378, /* F32VEC2 */ + F32VEC3 = 379, /* F32VEC3 */ + F32VEC4 = 380, /* F32VEC4 */ + F32MAT2 = 381, /* F32MAT2 */ + F32MAT3 = 382, /* F32MAT3 */ + F32MAT4 = 383, /* F32MAT4 */ + F64VEC2 = 384, /* F64VEC2 */ + F64VEC3 = 385, /* F64VEC3 */ + F64VEC4 = 386, /* F64VEC4 */ + F64MAT2 = 387, /* F64MAT2 */ + F64MAT3 = 388, /* F64MAT3 */ + F64MAT4 = 389, /* F64MAT4 */ + DMAT2X2 = 390, /* DMAT2X2 */ + DMAT2X3 = 391, /* DMAT2X3 */ + DMAT2X4 = 392, /* DMAT2X4 */ + DMAT3X2 = 393, /* DMAT3X2 */ + DMAT3X3 = 394, /* DMAT3X3 */ + DMAT3X4 = 395, /* DMAT3X4 */ + DMAT4X2 = 396, /* DMAT4X2 */ + DMAT4X3 = 397, /* DMAT4X3 */ + DMAT4X4 = 398, /* DMAT4X4 */ + F16MAT2X2 = 399, /* F16MAT2X2 */ + F16MAT2X3 = 400, /* F16MAT2X3 */ + F16MAT2X4 = 401, /* F16MAT2X4 */ + F16MAT3X2 = 402, /* F16MAT3X2 */ + F16MAT3X3 = 403, /* F16MAT3X3 */ + F16MAT3X4 = 404, /* F16MAT3X4 */ + F16MAT4X2 = 405, /* F16MAT4X2 */ + F16MAT4X3 = 406, /* F16MAT4X3 */ + F16MAT4X4 = 407, /* F16MAT4X4 */ + F32MAT2X2 = 408, /* F32MAT2X2 */ + F32MAT2X3 = 409, /* F32MAT2X3 */ + F32MAT2X4 = 410, /* F32MAT2X4 */ + F32MAT3X2 = 411, /* F32MAT3X2 */ + F32MAT3X3 = 412, /* F32MAT3X3 */ + F32MAT3X4 = 413, /* F32MAT3X4 */ + F32MAT4X2 = 414, /* F32MAT4X2 */ + F32MAT4X3 = 415, /* F32MAT4X3 */ + F32MAT4X4 = 416, /* F32MAT4X4 */ + F64MAT2X2 = 417, /* F64MAT2X2 */ + F64MAT2X3 = 418, /* F64MAT2X3 */ + F64MAT2X4 = 419, /* F64MAT2X4 */ + F64MAT3X2 = 420, /* F64MAT3X2 */ + F64MAT3X3 = 421, /* F64MAT3X3 */ + F64MAT3X4 = 422, /* F64MAT3X4 */ + F64MAT4X2 = 423, /* F64MAT4X2 */ + F64MAT4X3 = 424, /* F64MAT4X3 */ + F64MAT4X4 = 425, /* F64MAT4X4 */ + ATOMIC_UINT = 426, /* ATOMIC_UINT */ + ACCSTRUCTNV = 427, /* ACCSTRUCTNV */ + ACCSTRUCTEXT = 428, /* ACCSTRUCTEXT */ + RAYQUERYEXT = 429, /* RAYQUERYEXT */ + FCOOPMATNV = 430, /* FCOOPMATNV */ + ICOOPMATNV = 431, /* ICOOPMATNV */ + UCOOPMATNV = 432, /* UCOOPMATNV */ + COOPMAT = 433, /* COOPMAT */ + COOPVECNV = 434, /* COOPVECNV */ + HITOBJECTNV = 435, /* HITOBJECTNV */ + HITOBJECTATTRNV = 436, /* HITOBJECTATTRNV */ + TENSORLAYOUTNV = 437, /* TENSORLAYOUTNV */ + TENSORVIEWNV = 438, /* TENSORVIEWNV */ + TENSORARM = 439, /* TENSORARM */ + SAMPLERCUBEARRAY = 440, /* SAMPLERCUBEARRAY */ + SAMPLERCUBEARRAYSHADOW = 441, /* SAMPLERCUBEARRAYSHADOW */ + ISAMPLERCUBEARRAY = 442, /* ISAMPLERCUBEARRAY */ + USAMPLERCUBEARRAY = 443, /* USAMPLERCUBEARRAY */ + SAMPLER1D = 444, /* SAMPLER1D */ + SAMPLER1DARRAY = 445, /* SAMPLER1DARRAY */ + SAMPLER1DARRAYSHADOW = 446, /* SAMPLER1DARRAYSHADOW */ + ISAMPLER1D = 447, /* ISAMPLER1D */ + SAMPLER1DSHADOW = 448, /* SAMPLER1DSHADOW */ + SAMPLER2DRECT = 449, /* SAMPLER2DRECT */ + SAMPLER2DRECTSHADOW = 450, /* SAMPLER2DRECTSHADOW */ + ISAMPLER2DRECT = 451, /* ISAMPLER2DRECT */ + USAMPLER2DRECT = 452, /* USAMPLER2DRECT */ + SAMPLERBUFFER = 453, /* SAMPLERBUFFER */ + ISAMPLERBUFFER = 454, /* ISAMPLERBUFFER */ + USAMPLERBUFFER = 455, /* USAMPLERBUFFER */ + SAMPLER2DMS = 456, /* SAMPLER2DMS */ + ISAMPLER2DMS = 457, /* ISAMPLER2DMS */ + USAMPLER2DMS = 458, /* USAMPLER2DMS */ + SAMPLER2DMSARRAY = 459, /* SAMPLER2DMSARRAY */ + ISAMPLER2DMSARRAY = 460, /* ISAMPLER2DMSARRAY */ + USAMPLER2DMSARRAY = 461, /* USAMPLER2DMSARRAY */ + SAMPLEREXTERNALOES = 462, /* SAMPLEREXTERNALOES */ + SAMPLEREXTERNAL2DY2YEXT = 463, /* SAMPLEREXTERNAL2DY2YEXT */ + ISAMPLER1DARRAY = 464, /* ISAMPLER1DARRAY */ + USAMPLER1D = 465, /* USAMPLER1D */ + USAMPLER1DARRAY = 466, /* USAMPLER1DARRAY */ + F16SAMPLER1D = 467, /* F16SAMPLER1D */ + F16SAMPLER2D = 468, /* F16SAMPLER2D */ + F16SAMPLER3D = 469, /* F16SAMPLER3D */ + F16SAMPLER2DRECT = 470, /* F16SAMPLER2DRECT */ + F16SAMPLERCUBE = 471, /* F16SAMPLERCUBE */ + F16SAMPLER1DARRAY = 472, /* F16SAMPLER1DARRAY */ + F16SAMPLER2DARRAY = 473, /* F16SAMPLER2DARRAY */ + F16SAMPLERCUBEARRAY = 474, /* F16SAMPLERCUBEARRAY */ + F16SAMPLERBUFFER = 475, /* F16SAMPLERBUFFER */ + F16SAMPLER2DMS = 476, /* F16SAMPLER2DMS */ + F16SAMPLER2DMSARRAY = 477, /* F16SAMPLER2DMSARRAY */ + F16SAMPLER1DSHADOW = 478, /* F16SAMPLER1DSHADOW */ + F16SAMPLER2DSHADOW = 479, /* F16SAMPLER2DSHADOW */ + F16SAMPLER1DARRAYSHADOW = 480, /* F16SAMPLER1DARRAYSHADOW */ + F16SAMPLER2DARRAYSHADOW = 481, /* F16SAMPLER2DARRAYSHADOW */ + F16SAMPLER2DRECTSHADOW = 482, /* F16SAMPLER2DRECTSHADOW */ + F16SAMPLERCUBESHADOW = 483, /* F16SAMPLERCUBESHADOW */ + F16SAMPLERCUBEARRAYSHADOW = 484, /* F16SAMPLERCUBEARRAYSHADOW */ + IMAGE1D = 485, /* IMAGE1D */ + IIMAGE1D = 486, /* IIMAGE1D */ + UIMAGE1D = 487, /* UIMAGE1D */ + IMAGE2D = 488, /* IMAGE2D */ + IIMAGE2D = 489, /* IIMAGE2D */ + UIMAGE2D = 490, /* UIMAGE2D */ + IMAGE3D = 491, /* IMAGE3D */ + IIMAGE3D = 492, /* IIMAGE3D */ + UIMAGE3D = 493, /* UIMAGE3D */ + IMAGE2DRECT = 494, /* IMAGE2DRECT */ + IIMAGE2DRECT = 495, /* IIMAGE2DRECT */ + UIMAGE2DRECT = 496, /* UIMAGE2DRECT */ + IMAGECUBE = 497, /* IMAGECUBE */ + IIMAGECUBE = 498, /* IIMAGECUBE */ + UIMAGECUBE = 499, /* UIMAGECUBE */ + IMAGEBUFFER = 500, /* IMAGEBUFFER */ + IIMAGEBUFFER = 501, /* IIMAGEBUFFER */ + UIMAGEBUFFER = 502, /* UIMAGEBUFFER */ + IMAGE1DARRAY = 503, /* IMAGE1DARRAY */ + IIMAGE1DARRAY = 504, /* IIMAGE1DARRAY */ + UIMAGE1DARRAY = 505, /* UIMAGE1DARRAY */ + IMAGE2DARRAY = 506, /* IMAGE2DARRAY */ + IIMAGE2DARRAY = 507, /* IIMAGE2DARRAY */ + UIMAGE2DARRAY = 508, /* UIMAGE2DARRAY */ + IMAGECUBEARRAY = 509, /* IMAGECUBEARRAY */ + IIMAGECUBEARRAY = 510, /* IIMAGECUBEARRAY */ + UIMAGECUBEARRAY = 511, /* UIMAGECUBEARRAY */ + IMAGE2DMS = 512, /* IMAGE2DMS */ + IIMAGE2DMS = 513, /* IIMAGE2DMS */ + UIMAGE2DMS = 514, /* UIMAGE2DMS */ + IMAGE2DMSARRAY = 515, /* IMAGE2DMSARRAY */ + IIMAGE2DMSARRAY = 516, /* IIMAGE2DMSARRAY */ + UIMAGE2DMSARRAY = 517, /* UIMAGE2DMSARRAY */ + F16IMAGE1D = 518, /* F16IMAGE1D */ + F16IMAGE2D = 519, /* F16IMAGE2D */ + F16IMAGE3D = 520, /* F16IMAGE3D */ + F16IMAGE2DRECT = 521, /* F16IMAGE2DRECT */ + F16IMAGECUBE = 522, /* F16IMAGECUBE */ + F16IMAGE1DARRAY = 523, /* F16IMAGE1DARRAY */ + F16IMAGE2DARRAY = 524, /* F16IMAGE2DARRAY */ + F16IMAGECUBEARRAY = 525, /* F16IMAGECUBEARRAY */ + F16IMAGEBUFFER = 526, /* F16IMAGEBUFFER */ + F16IMAGE2DMS = 527, /* F16IMAGE2DMS */ + F16IMAGE2DMSARRAY = 528, /* F16IMAGE2DMSARRAY */ + I64IMAGE1D = 529, /* I64IMAGE1D */ + U64IMAGE1D = 530, /* U64IMAGE1D */ + I64IMAGE2D = 531, /* I64IMAGE2D */ + U64IMAGE2D = 532, /* U64IMAGE2D */ + I64IMAGE3D = 533, /* I64IMAGE3D */ + U64IMAGE3D = 534, /* U64IMAGE3D */ + I64IMAGE2DRECT = 535, /* I64IMAGE2DRECT */ + U64IMAGE2DRECT = 536, /* U64IMAGE2DRECT */ + I64IMAGECUBE = 537, /* I64IMAGECUBE */ + U64IMAGECUBE = 538, /* U64IMAGECUBE */ + I64IMAGEBUFFER = 539, /* I64IMAGEBUFFER */ + U64IMAGEBUFFER = 540, /* U64IMAGEBUFFER */ + I64IMAGE1DARRAY = 541, /* I64IMAGE1DARRAY */ + U64IMAGE1DARRAY = 542, /* U64IMAGE1DARRAY */ + I64IMAGE2DARRAY = 543, /* I64IMAGE2DARRAY */ + U64IMAGE2DARRAY = 544, /* U64IMAGE2DARRAY */ + I64IMAGECUBEARRAY = 545, /* I64IMAGECUBEARRAY */ + U64IMAGECUBEARRAY = 546, /* U64IMAGECUBEARRAY */ + I64IMAGE2DMS = 547, /* I64IMAGE2DMS */ + U64IMAGE2DMS = 548, /* U64IMAGE2DMS */ + I64IMAGE2DMSARRAY = 549, /* I64IMAGE2DMSARRAY */ + U64IMAGE2DMSARRAY = 550, /* U64IMAGE2DMSARRAY */ + TEXTURECUBEARRAY = 551, /* TEXTURECUBEARRAY */ + ITEXTURECUBEARRAY = 552, /* ITEXTURECUBEARRAY */ + UTEXTURECUBEARRAY = 553, /* UTEXTURECUBEARRAY */ + TEXTURE1D = 554, /* TEXTURE1D */ + ITEXTURE1D = 555, /* ITEXTURE1D */ + UTEXTURE1D = 556, /* UTEXTURE1D */ + TEXTURE1DARRAY = 557, /* TEXTURE1DARRAY */ + ITEXTURE1DARRAY = 558, /* ITEXTURE1DARRAY */ + UTEXTURE1DARRAY = 559, /* UTEXTURE1DARRAY */ + TEXTURE2DRECT = 560, /* TEXTURE2DRECT */ + ITEXTURE2DRECT = 561, /* ITEXTURE2DRECT */ + UTEXTURE2DRECT = 562, /* UTEXTURE2DRECT */ + TEXTUREBUFFER = 563, /* TEXTUREBUFFER */ + ITEXTUREBUFFER = 564, /* ITEXTUREBUFFER */ + UTEXTUREBUFFER = 565, /* UTEXTUREBUFFER */ + TEXTURE2DMS = 566, /* TEXTURE2DMS */ + ITEXTURE2DMS = 567, /* ITEXTURE2DMS */ + UTEXTURE2DMS = 568, /* UTEXTURE2DMS */ + TEXTURE2DMSARRAY = 569, /* TEXTURE2DMSARRAY */ + ITEXTURE2DMSARRAY = 570, /* ITEXTURE2DMSARRAY */ + UTEXTURE2DMSARRAY = 571, /* UTEXTURE2DMSARRAY */ + F16TEXTURE1D = 572, /* F16TEXTURE1D */ + F16TEXTURE2D = 573, /* F16TEXTURE2D */ + F16TEXTURE3D = 574, /* F16TEXTURE3D */ + F16TEXTURE2DRECT = 575, /* F16TEXTURE2DRECT */ + F16TEXTURECUBE = 576, /* F16TEXTURECUBE */ + F16TEXTURE1DARRAY = 577, /* F16TEXTURE1DARRAY */ + F16TEXTURE2DARRAY = 578, /* F16TEXTURE2DARRAY */ + F16TEXTURECUBEARRAY = 579, /* F16TEXTURECUBEARRAY */ + F16TEXTUREBUFFER = 580, /* F16TEXTUREBUFFER */ + F16TEXTURE2DMS = 581, /* F16TEXTURE2DMS */ + F16TEXTURE2DMSARRAY = 582, /* F16TEXTURE2DMSARRAY */ + SUBPASSINPUT = 583, /* SUBPASSINPUT */ + SUBPASSINPUTMS = 584, /* SUBPASSINPUTMS */ + ISUBPASSINPUT = 585, /* ISUBPASSINPUT */ + ISUBPASSINPUTMS = 586, /* ISUBPASSINPUTMS */ + USUBPASSINPUT = 587, /* USUBPASSINPUT */ + USUBPASSINPUTMS = 588, /* USUBPASSINPUTMS */ + F16SUBPASSINPUT = 589, /* F16SUBPASSINPUT */ + F16SUBPASSINPUTMS = 590, /* F16SUBPASSINPUTMS */ + SPIRV_INSTRUCTION = 591, /* SPIRV_INSTRUCTION */ + SPIRV_EXECUTION_MODE = 592, /* SPIRV_EXECUTION_MODE */ + SPIRV_EXECUTION_MODE_ID = 593, /* SPIRV_EXECUTION_MODE_ID */ + SPIRV_DECORATE = 594, /* SPIRV_DECORATE */ + SPIRV_DECORATE_ID = 595, /* SPIRV_DECORATE_ID */ + SPIRV_DECORATE_STRING = 596, /* SPIRV_DECORATE_STRING */ + SPIRV_TYPE = 597, /* SPIRV_TYPE */ + SPIRV_STORAGE_CLASS = 598, /* SPIRV_STORAGE_CLASS */ + SPIRV_BY_REFERENCE = 599, /* SPIRV_BY_REFERENCE */ + SPIRV_LITERAL = 600, /* SPIRV_LITERAL */ + ATTACHMENTEXT = 601, /* ATTACHMENTEXT */ + IATTACHMENTEXT = 602, /* IATTACHMENTEXT */ + UATTACHMENTEXT = 603, /* UATTACHMENTEXT */ + LEFT_OP = 604, /* LEFT_OP */ + RIGHT_OP = 605, /* RIGHT_OP */ + INC_OP = 606, /* INC_OP */ + DEC_OP = 607, /* DEC_OP */ + LE_OP = 608, /* LE_OP */ + GE_OP = 609, /* GE_OP */ + EQ_OP = 610, /* EQ_OP */ + NE_OP = 611, /* NE_OP */ + AND_OP = 612, /* AND_OP */ + OR_OP = 613, /* OR_OP */ + XOR_OP = 614, /* XOR_OP */ + MUL_ASSIGN = 615, /* MUL_ASSIGN */ + DIV_ASSIGN = 616, /* DIV_ASSIGN */ + ADD_ASSIGN = 617, /* ADD_ASSIGN */ + MOD_ASSIGN = 618, /* MOD_ASSIGN */ + LEFT_ASSIGN = 619, /* LEFT_ASSIGN */ + RIGHT_ASSIGN = 620, /* RIGHT_ASSIGN */ + AND_ASSIGN = 621, /* AND_ASSIGN */ + XOR_ASSIGN = 622, /* XOR_ASSIGN */ + OR_ASSIGN = 623, /* OR_ASSIGN */ + SUB_ASSIGN = 624, /* SUB_ASSIGN */ + STRING_LITERAL = 625, /* STRING_LITERAL */ + LEFT_PAREN = 626, /* LEFT_PAREN */ + RIGHT_PAREN = 627, /* RIGHT_PAREN */ + LEFT_BRACKET = 628, /* LEFT_BRACKET */ + RIGHT_BRACKET = 629, /* RIGHT_BRACKET */ + LEFT_BRACE = 630, /* LEFT_BRACE */ + RIGHT_BRACE = 631, /* RIGHT_BRACE */ + DOT = 632, /* DOT */ + COMMA = 633, /* COMMA */ + COLON = 634, /* COLON */ + EQUAL = 635, /* EQUAL */ + SEMICOLON = 636, /* SEMICOLON */ + BANG = 637, /* BANG */ + DASH = 638, /* DASH */ + TILDE = 639, /* TILDE */ + PLUS = 640, /* PLUS */ + STAR = 641, /* STAR */ + SLASH = 642, /* SLASH */ + PERCENT = 643, /* PERCENT */ + LEFT_ANGLE = 644, /* LEFT_ANGLE */ + RIGHT_ANGLE = 645, /* RIGHT_ANGLE */ + VERTICAL_BAR = 646, /* VERTICAL_BAR */ + CARET = 647, /* CARET */ + AMPERSAND = 648, /* AMPERSAND */ + QUESTION = 649, /* QUESTION */ + INVARIANT = 650, /* INVARIANT */ + HIGH_PRECISION = 651, /* HIGH_PRECISION */ + MEDIUM_PRECISION = 652, /* MEDIUM_PRECISION */ + LOW_PRECISION = 653, /* LOW_PRECISION */ + PRECISION = 654, /* PRECISION */ + PACKED = 655, /* PACKED */ + RESOURCE = 656, /* RESOURCE */ + SUPERP = 657, /* SUPERP */ + FLOATCONSTANT = 658, /* FLOATCONSTANT */ + INTCONSTANT = 659, /* INTCONSTANT */ + UINTCONSTANT = 660, /* UINTCONSTANT */ + BOOLCONSTANT = 661, /* BOOLCONSTANT */ + IDENTIFIER = 662, /* IDENTIFIER */ + TYPE_NAME = 663, /* TYPE_NAME */ + CENTROID = 664, /* CENTROID */ + IN = 665, /* IN */ + OUT = 666, /* OUT */ + INOUT = 667, /* INOUT */ + STRUCT = 668, /* STRUCT */ + VOID = 669, /* VOID */ + WHILE = 670, /* WHILE */ + BREAK = 671, /* BREAK */ + CONTINUE = 672, /* CONTINUE */ + DO = 673, /* DO */ + ELSE = 674, /* ELSE */ + FOR = 675, /* FOR */ + IF = 676, /* IF */ + DISCARD = 677, /* DISCARD */ + RETURN = 678, /* RETURN */ + SWITCH = 679, /* SWITCH */ + CASE = 680, /* CASE */ + DEFAULT = 681, /* DEFAULT */ + TERMINATE_INVOCATION = 682, /* TERMINATE_INVOCATION */ + TERMINATE_RAY = 683, /* TERMINATE_RAY */ + IGNORE_INTERSECTION = 684, /* IGNORE_INTERSECTION */ + UNIFORM = 685, /* UNIFORM */ + SHARED = 686, /* SHARED */ + BUFFER = 687, /* BUFFER */ + TILEIMAGEEXT = 688, /* TILEIMAGEEXT */ + FLAT = 689, /* FLAT */ + SMOOTH = 690, /* SMOOTH */ + LAYOUT = 691, /* LAYOUT */ + DOUBLECONSTANT = 692, /* DOUBLECONSTANT */ + INT16CONSTANT = 693, /* INT16CONSTANT */ + UINT16CONSTANT = 694, /* UINT16CONSTANT */ + FLOAT16CONSTANT = 695, /* FLOAT16CONSTANT */ + INT32CONSTANT = 696, /* INT32CONSTANT */ + UINT32CONSTANT = 697, /* UINT32CONSTANT */ + INT64CONSTANT = 698, /* INT64CONSTANT */ + UINT64CONSTANT = 699, /* UINT64CONSTANT */ + SUBROUTINE = 700, /* SUBROUTINE */ + DEMOTE = 701, /* DEMOTE */ + FUNCTION = 702, /* FUNCTION */ + PAYLOADNV = 703, /* PAYLOADNV */ + PAYLOADINNV = 704, /* PAYLOADINNV */ + HITATTRNV = 705, /* HITATTRNV */ + CALLDATANV = 706, /* CALLDATANV */ + CALLDATAINNV = 707, /* CALLDATAINNV */ + PAYLOADEXT = 708, /* PAYLOADEXT */ + PAYLOADINEXT = 709, /* PAYLOADINEXT */ + HITATTREXT = 710, /* HITATTREXT */ + CALLDATAEXT = 711, /* CALLDATAEXT */ + CALLDATAINEXT = 712, /* CALLDATAINEXT */ + PATCH = 713, /* PATCH */ + SAMPLE = 714, /* SAMPLE */ + NONUNIFORM = 715, /* NONUNIFORM */ + COHERENT = 716, /* COHERENT */ + VOLATILE = 717, /* VOLATILE */ + RESTRICT = 718, /* RESTRICT */ + READONLY = 719, /* READONLY */ + WRITEONLY = 720, /* WRITEONLY */ + NONTEMPORAL = 721, /* NONTEMPORAL */ + DEVICECOHERENT = 722, /* DEVICECOHERENT */ + QUEUEFAMILYCOHERENT = 723, /* QUEUEFAMILYCOHERENT */ + WORKGROUPCOHERENT = 724, /* WORKGROUPCOHERENT */ + SUBGROUPCOHERENT = 725, /* SUBGROUPCOHERENT */ + NONPRIVATE = 726, /* NONPRIVATE */ + SHADERCALLCOHERENT = 727, /* SHADERCALLCOHERENT */ + NOPERSPECTIVE = 728, /* NOPERSPECTIVE */ + EXPLICITINTERPAMD = 729, /* EXPLICITINTERPAMD */ + PERVERTEXEXT = 730, /* PERVERTEXEXT */ + PERVERTEXNV = 731, /* PERVERTEXNV */ + PERPRIMITIVENV = 732, /* PERPRIMITIVENV */ + PERVIEWNV = 733, /* PERVIEWNV */ + PERTASKNV = 734, /* PERTASKNV */ + PERPRIMITIVEEXT = 735, /* PERPRIMITIVEEXT */ + TASKPAYLOADWORKGROUPEXT = 736, /* TASKPAYLOADWORKGROUPEXT */ + PRECISE = 737 /* PRECISE */ }; typedef enum yytokentype yytoken_kind_t; #endif @@ -572,7 +581,7 @@ union YYSTYPE glslang::TTypeParameters* typeParameters; } interm; -#line 576 "MachineIndependent/glslang_tab.cpp.h" +#line 585 "MachineIndependent/glslang_tab.cpp.h" }; typedef union YYSTYPE YYSTYPE; diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/intermOut.cpp b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/intermOut.cpp index 7ec8ed4..b28da23 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/intermOut.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/intermOut.cpp @@ -629,6 +629,14 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpConstructBF16Vec2: out.debug << "Construct bf16vec2"; break; case EOpConstructBF16Vec3: out.debug << "Construct bf16vec3"; break; case EOpConstructBF16Vec4: out.debug << "Construct bf16vec4"; break; + case EOpConstructFloatE5M2: out.debug << "Construct floate5m2_t"; break; + case EOpConstructFloatE5M2Vec2: out.debug << "Construct fe5m2vec2"; break; + case EOpConstructFloatE5M2Vec3: out.debug << "Construct fe5m2vec3"; break; + case EOpConstructFloatE5M2Vec4: out.debug << "Construct fe5m2vec4"; break; + case EOpConstructFloatE4M3: out.debug << "Construct floate4m3_t"; break; + case EOpConstructFloatE4M3Vec2: out.debug << "Construct fe4m3vec2"; break; + case EOpConstructFloatE4M3Vec3: out.debug << "Construct fe4m3vec3"; break; + case EOpConstructFloatE4M3Vec4: out.debug << "Construct fe4m3vec4"; break; case EOpConstructFloat16: out.debug << "Construct float16_t"; break; case EOpConstructF16Vec2: out.debug << "Construct f16vec2"; break; case EOpConstructF16Vec3: out.debug << "Construct f16vec3"; break; @@ -650,6 +658,11 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpConstructCooperativeVectorNV: out.debug << "Construct cooperative vector NV"; break; case EOpConstructAccStruct: out.debug << "Construct acceleration structure"; break; + case EOpBitCastArrayQCOM: out.debug << "Bitcast To Array QCOM"; break; + case EOpExtractSubArrayQCOM: out.debug << "Extract Subarray QCOM"; break; + case EOpCompositeConstructCoopMatQCOM: out.debug << "Construct Cooperative Matrix QCOM"; break; + case EOpCompositeExtractCoopMatQCOM: out.debug << "Extract Cooperative Matrix QCOM"; break; + case EOpLessThan: out.debug << "Compare Less Than"; break; case EOpGreaterThan: out.debug << "Compare Greater Than"; break; case EOpLessThanEqual: out.debug << "Compare Less Than or Equal"; break; @@ -975,6 +988,10 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node case EOpCooperativeVectorOuterProductAccumulateNV: out.debug << "Cooperative vector outer product accumulate NV"; break; case EOpCooperativeVectorReduceSumAccumulateNV: out.debug << "Cooperative vector reduce sum accumulate NV"; break; + case EOpTensorReadARM: out.debug << "Read from tensor"; break; + case EOpTensorWriteARM: out.debug << "Write to tensor"; break; + case EOpTensorSizeARM: out.debug << "Get tensor size"; break; + case EOpIsHelperInvocation: out.debug << "IsHelperInvocation"; break; case EOpDebugPrintf: out.debug << "Debug printf"; break; @@ -1164,6 +1181,8 @@ static void OutputConstantUnion(TInfoSink& out, const TIntermTyped* node, const case EbtDouble: case EbtFloat16: case EbtBFloat16: + case EbtFloatE5M2: + case EbtFloatE4M3: OutputDouble(out, constUnion[i].getDConst(), extra); out.debug << "\n"; break; diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/iomapper.cpp b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/iomapper.cpp index 26c3eaa..0e5941a 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/iomapper.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/iomapper.cpp @@ -1019,6 +1019,7 @@ uint32_t TDefaultIoResolverBase::computeTypeLocationSize(const TType& type, EShL //TDefaultGlslIoResolver TResourceType TDefaultGlslIoResolver::getResourceType(const glslang::TType& type) { + assert(isValidGlslType(type)); if (isImageType(type)) { return EResImage; } @@ -1034,6 +1035,15 @@ TResourceType TDefaultGlslIoResolver::getResourceType(const glslang::TType& type if (isUboType(type)) { return EResUbo; } + if (isCombinedSamplerType(type)) { + return EResCombinedSampler; + } + if (isAsType(type)) { + return EResAs; + } + if (isTensorType(type)) { + return EResTensor; + } return EResCount; } @@ -1383,6 +1393,7 @@ struct TDefaultIoResolver : public TDefaultIoResolverBase { bool validateBinding(EShLanguage /*stage*/, TVarEntryInfo& /*ent*/) override { return true; } TResourceType getResourceType(const glslang::TType& type) override { + assert(isValidGlslType(type)); if (isImageType(type)) { return EResImage; } @@ -1398,6 +1409,15 @@ struct TDefaultIoResolver : public TDefaultIoResolverBase { if (isUboType(type)) { return EResUbo; } + if (isCombinedSamplerType(type)) { + return EResCombinedSampler; + } + if (isAsType(type)) { + return EResAs; + } + if (isTensorType(type)) { + return EResTensor; + } return EResCount; } @@ -1483,6 +1503,11 @@ struct TDefaultHlslIoResolver : public TDefaultIoResolverBase { if (isUboType(type)) { return EResUbo; } + // no support for combined samplers in HLSL + if (isAsType(type)) { + return EResAs; + } + // no support for tensors in HLSL return EResCount; } diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/iomapper.h b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/iomapper.h index ef513d9..de0a0d7 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/iomapper.h +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/iomapper.h @@ -120,12 +120,12 @@ struct TDefaultIoResolverBase : public glslang::TIoMapResolver { } static bool isTextureType(const glslang::TType& type) { - return (type.getBasicType() == glslang::EbtSampler && + return (type.getBasicType() == glslang::EbtSampler && !type.getSampler().isCombined() && (type.getSampler().isTexture() || type.getSampler().isSubpass())); } static bool isUboType(const glslang::TType& type) { - return type.getQualifier().storage == EvqUniform; + return type.getQualifier().storage == EvqUniform && type.isStruct(); } static bool isImageType(const glslang::TType& type) { @@ -136,6 +136,24 @@ struct TDefaultIoResolverBase : public glslang::TIoMapResolver { return type.getQualifier().storage == EvqBuffer; } + static bool isCombinedSamplerType(const glslang::TType& type) { + return type.getBasicType() == glslang::EbtSampler && type.getSampler().isCombined(); + } + + static bool isAsType(const glslang::TType& type) { + return type.getBasicType() == glslang::EbtAccStruct; + } + + static bool isTensorType(const glslang::TType& type) { + return type.isTensorARM(); + } + + static bool isValidGlslType(const glslang::TType& type) { + // at most one must be true + return (isSamplerType(type) + isTextureType(type) + isUboType(type) + isImageType(type) + + isSsboType(type) + isCombinedSamplerType(type) + isAsType(type) + isTensorType(type)) <= 1; + } + // Return true if this is a SRV (shader resource view) type: static bool isSrvType(const glslang::TType& type) { return isTextureType(type) || type.getQualifier().storage == EvqBuffer; diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/linkValidate.cpp b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/linkValidate.cpp index fa0e66e..3fd6477 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/linkValidate.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/linkValidate.cpp @@ -535,6 +535,9 @@ void TIntermediate::mergeModes(TInfoSink& infoSink, TIntermediate& unit) error(infoSink, "number of invocations must match between compilation units"); } + // The GLSL specification requires that at least one compilation unit + // must declare the vertices layout, but not all units need to do so. + // However, all declarations must match. if (vertices == TQualifier::layoutNotSet) vertices = unit.vertices; else if (unit.vertices != TQualifier::layoutNotSet && vertices != unit.vertices) { @@ -545,20 +548,30 @@ void TIntermediate::mergeModes(TInfoSink& infoSink, TIntermediate& unit) else assert(0); } + + // The mesh shader extension requires that at least one compilation unit + // must declare the max_primitives layout, but not all units need to do so. + // However, all declarations must match. if (primitives == TQualifier::layoutNotSet) primitives = unit.primitives; - else if (primitives != unit.primitives) { + else if (unit.primitives != TQualifier::layoutNotSet && primitives != unit.primitives) { if (language == EShLangMesh) error(infoSink, "Contradictory layout max_primitives values"); else assert(0); } + // The GLSL specification requires that at least one compilation unit + // must declare the input primitive layout, but not all units need to do so. + // However, all declarations must match. if (inputPrimitive == ElgNone) inputPrimitive = unit.inputPrimitive; else if (unit.inputPrimitive != ElgNone && inputPrimitive != unit.inputPrimitive) error(infoSink, "Contradictory input layout primitives"); + // The GLSL specification requires that at least one compilation unit + // must declare the output primitive layout, but not all units need to do so. + // However, all declarations must match. if (outputPrimitive == ElgNone) outputPrimitive = unit.outputPrimitive; else if (unit.outputPrimitive != ElgNone && outputPrimitive != unit.outputPrimitive) @@ -567,19 +580,27 @@ void TIntermediate::mergeModes(TInfoSink& infoSink, TIntermediate& unit) if (originUpperLeft != unit.originUpperLeft || pixelCenterInteger != unit.pixelCenterInteger) error(infoSink, "gl_FragCoord redeclarations must match across shaders"); + // The GLSL specification requires that at least one compilation unit + // must declare the vertex spacing layout, but not all units need to do so. + // However, all declarations must match. if (vertexSpacing == EvsNone) vertexSpacing = unit.vertexSpacing; - else if (vertexSpacing != unit.vertexSpacing) + else if (unit.vertexSpacing != EvsNone && vertexSpacing != unit.vertexSpacing) error(infoSink, "Contradictory input vertex spacing"); + // The GLSL specification requires that at least one compilation unit + // must declare the triangle ordering layout, but not all units need to do so. + // However, all declarations must match. if (vertexOrder == EvoNone) vertexOrder = unit.vertexOrder; - else if (vertexOrder != unit.vertexOrder) + else if (unit.vertexOrder != EvoNone && vertexOrder != unit.vertexOrder) error(infoSink, "Contradictory triangle ordering"); MERGE_TRUE(pointMode); for (int i = 0; i < 3; ++i) { + // The GLSL specification requires that all workgroup size declarations must match + // but not all units have to declare the layout. if (unit.localSizeNotDefault[i]) { if (!localSizeNotDefault[i]) { localSize[i] = unit.localSize[i]; @@ -589,9 +610,11 @@ void TIntermediate::mergeModes(TInfoSink& infoSink, TIntermediate& unit) error(infoSink, "Contradictory local size"); } + // The GLSL specification requires that all workgroup size specialization + // ids declarations must match, but not all units have to declare the layout. if (localSizeSpecId[i] == TQualifier::layoutNotSet) localSizeSpecId[i] = unit.localSizeSpecId[i]; - else if (localSizeSpecId[i] != unit.localSizeSpecId[i]) + else if (unit.localSizeSpecId[i] != TQualifier::layoutNotSet && localSizeSpecId[i] != unit.localSizeSpecId[i]) error(infoSink, "Contradictory local size specialization ids"); } @@ -602,9 +625,11 @@ void TIntermediate::mergeModes(TInfoSink& infoSink, TIntermediate& unit) MERGE_TRUE(nonCoherentStencilAttachmentReadEXT); MERGE_TRUE(nonCoherentTileAttachmentReadQCOM); + // The GLSL specification requires that all depth layout redeclarations must match, + // but not all units have to declare the layout. if (depthLayout == EldNone) depthLayout = unit.depthLayout; - else if (depthLayout != unit.depthLayout) + else if (unit.depthLayout != EldNone && depthLayout != unit.depthLayout) error(infoSink, "Contradictory depth layouts"); MERGE_TRUE(depthReplacing); @@ -615,9 +640,11 @@ void TIntermediate::mergeModes(TInfoSink& infoSink, TIntermediate& unit) MERGE_TRUE(xfbMode); for (size_t b = 0; b < xfbBuffers.size(); ++b) { + // The GLSL specification requires that all xfb_stride declarations for + // the same buffer must match, but not all units have to declare the layout. if (xfbBuffers[b].stride == TQualifier::layoutXfbStrideEnd) xfbBuffers[b].stride = unit.xfbBuffers[b].stride; - else if (xfbBuffers[b].stride != unit.xfbBuffers[b].stride) + else if (unit.xfbBuffers[b].stride != TQualifier::layoutXfbStrideEnd && xfbBuffers[b].stride != unit.xfbBuffers[b].stride) error(infoSink, "Contradictory xfb_stride"); xfbBuffers[b].implicitStride = std::max(xfbBuffers[b].implicitStride, unit.xfbBuffers[b].implicitStride); if (unit.xfbBuffers[b].contains64BitType) @@ -2386,6 +2413,8 @@ int TIntermediate::getBaseAlignmentScalar(const TType& type, int& size) case EbtDouble: size = 8; return 8; case EbtFloat16: size = 2; return 2; case EbtBFloat16: size = 2; return 2; + case EbtFloatE5M2: + case EbtFloatE4M3: case EbtInt8: case EbtUint8: size = 1; return 1; case EbtInt16: diff --git a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/parseVersions.h b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/parseVersions.h index 1deb2db..81f5f59 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/parseVersions.h +++ b/libs/bgfx/3rdparty/glslang/glslang/MachineIndependent/parseVersions.h @@ -104,6 +104,8 @@ class TParseVersions { virtual void float16Check(const TSourceLoc&, const char* op, bool builtIn = false); virtual void float16ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false); virtual void bfloat16ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false); + virtual void floate5m2ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false); + virtual void floate4m3ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false); virtual bool float16Arithmetic(); virtual void requireFloat16Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc); virtual void int16ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false); @@ -122,9 +124,11 @@ class TParseVersions { virtual void fcoopmatCheckNV(const TSourceLoc&, const char* op, bool builtIn = false); virtual void intcoopmatCheckNV(const TSourceLoc&, const char *op, bool builtIn = false); virtual void coopmatCheck(const TSourceLoc&, const char* op, bool builtIn = false); + virtual void coopmatConverisonCheckQCOM(const TSourceLoc& loc, const char* op, bool builtIn = false); virtual void tensorLayoutViewCheck(const TSourceLoc&, const char* op, bool builtIn = false); virtual void coopvecCheck(const TSourceLoc&, const char* op, bool builtIn = false); virtual void intattachmentCheck(const TSourceLoc&, const char *op, bool builtIn = false); + virtual void tensorCheckARM(const TSourceLoc&, const char *op, bool builtIn = false); bool relaxedErrors() const { return (messages & EShMsgRelaxedErrors) != 0; } bool suppressWarnings() const { return (messages & EShMsgSuppressWarnings) != 0; } bool isForwardCompatible() const { return forwardCompatible; } diff --git a/libs/bgfx/3rdparty/glslang/glslang/Public/ShaderLang.h b/libs/bgfx/3rdparty/glslang/glslang/Public/ShaderLang.h index 0536cc5..8ca4ed9 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/Public/ShaderLang.h +++ b/libs/bgfx/3rdparty/glslang/glslang/Public/ShaderLang.h @@ -434,6 +434,9 @@ enum TResourceType { EResUbo, EResSsbo, EResUav, + EResCombinedSampler, + EResAs, + EResTensor, EResCount }; @@ -463,59 +466,59 @@ enum TBlockStorageClass // // N.B.: Destruct a linked program *before* destructing the shaders linked into it. // -class TShader { +class GLSLANG_EXPORT TShader { public: - GLSLANG_EXPORT explicit TShader(EShLanguage); - GLSLANG_EXPORT virtual ~TShader(); - GLSLANG_EXPORT void setStrings(const char* const* s, int n); - GLSLANG_EXPORT void setStringsWithLengths( + explicit TShader(EShLanguage); + virtual ~TShader(); + void setStrings(const char* const* s, int n); + void setStringsWithLengths( const char* const* s, const int* l, int n); - GLSLANG_EXPORT void setStringsWithLengthsAndNames( + void setStringsWithLengthsAndNames( const char* const* s, const int* l, const char* const* names, int n); void setPreamble(const char* s) { preamble = s; } - GLSLANG_EXPORT void setEntryPoint(const char* entryPoint); - GLSLANG_EXPORT void setSourceEntryPoint(const char* sourceEntryPointName); - GLSLANG_EXPORT void addProcesses(const std::vector&); - GLSLANG_EXPORT void setUniqueId(unsigned long long id); - GLSLANG_EXPORT void setOverrideVersion(int version); - GLSLANG_EXPORT void setDebugInfo(bool debugInfo); + void setEntryPoint(const char* entryPoint); + void setSourceEntryPoint(const char* sourceEntryPointName); + void addProcesses(const std::vector&); + void setUniqueId(unsigned long long id); + void setOverrideVersion(int version); + void setDebugInfo(bool debugInfo); // IO resolver binding data: see comments in ShaderLang.cpp - GLSLANG_EXPORT void setShiftBinding(TResourceType res, unsigned int base); - GLSLANG_EXPORT void setShiftSamplerBinding(unsigned int base); // DEPRECATED: use setShiftBinding - GLSLANG_EXPORT void setShiftTextureBinding(unsigned int base); // DEPRECATED: use setShiftBinding - GLSLANG_EXPORT void setShiftImageBinding(unsigned int base); // DEPRECATED: use setShiftBinding - GLSLANG_EXPORT void setShiftUboBinding(unsigned int base); // DEPRECATED: use setShiftBinding - GLSLANG_EXPORT void setShiftUavBinding(unsigned int base); // DEPRECATED: use setShiftBinding - GLSLANG_EXPORT void setShiftCbufferBinding(unsigned int base); // synonym for setShiftUboBinding - GLSLANG_EXPORT void setShiftSsboBinding(unsigned int base); // DEPRECATED: use setShiftBinding - GLSLANG_EXPORT void setShiftBindingForSet(TResourceType res, unsigned int base, unsigned int set); - GLSLANG_EXPORT void setResourceSetBinding(const std::vector& base); - GLSLANG_EXPORT void setAutoMapBindings(bool map); - GLSLANG_EXPORT void setAutoMapLocations(bool map); - GLSLANG_EXPORT void addUniformLocationOverride(const char* name, int loc); - GLSLANG_EXPORT void setUniformLocationBase(int base); - GLSLANG_EXPORT void setInvertY(bool invert); - GLSLANG_EXPORT void setDxPositionW(bool dxPosW); - GLSLANG_EXPORT void setEnhancedMsgs(); + void setShiftBinding(TResourceType res, unsigned int base); + void setShiftSamplerBinding(unsigned int base); // DEPRECATED: use setShiftBinding + void setShiftTextureBinding(unsigned int base); // DEPRECATED: use setShiftBinding + void setShiftImageBinding(unsigned int base); // DEPRECATED: use setShiftBinding + void setShiftUboBinding(unsigned int base); // DEPRECATED: use setShiftBinding + void setShiftUavBinding(unsigned int base); // DEPRECATED: use setShiftBinding + void setShiftCbufferBinding(unsigned int base); // synonym for setShiftUboBinding + void setShiftSsboBinding(unsigned int base); // DEPRECATED: use setShiftBinding + void setShiftBindingForSet(TResourceType res, unsigned int base, unsigned int set); + void setResourceSetBinding(const std::vector& base); + void setAutoMapBindings(bool map); + void setAutoMapLocations(bool map); + void addUniformLocationOverride(const char* name, int loc); + void setUniformLocationBase(int base); + void setInvertY(bool invert); + void setDxPositionW(bool dxPosW); + void setEnhancedMsgs(); #ifdef ENABLE_HLSL - GLSLANG_EXPORT void setHlslIoMapping(bool hlslIoMap); - GLSLANG_EXPORT void setFlattenUniformArrays(bool flatten); + void setHlslIoMapping(bool hlslIoMap); + void setFlattenUniformArrays(bool flatten); #endif - GLSLANG_EXPORT void setNoStorageFormat(bool useUnknownFormat); - GLSLANG_EXPORT void setNanMinMaxClamp(bool nanMinMaxClamp); - GLSLANG_EXPORT void setTextureSamplerTransformMode(EShTextureSamplerTransformMode mode); - GLSLANG_EXPORT void addBlockStorageOverride(const char* nameStr, glslang::TBlockStorageClass backing); + void setNoStorageFormat(bool useUnknownFormat); + void setNanMinMaxClamp(bool nanMinMaxClamp); + void setTextureSamplerTransformMode(EShTextureSamplerTransformMode mode); + void addBlockStorageOverride(const char* nameStr, glslang::TBlockStorageClass backing); - GLSLANG_EXPORT void setGlobalUniformBlockName(const char* name); - GLSLANG_EXPORT void setAtomicCounterBlockName(const char* name); - GLSLANG_EXPORT void setGlobalUniformSet(unsigned int set); - GLSLANG_EXPORT void setGlobalUniformBinding(unsigned int binding); - GLSLANG_EXPORT void setAtomicCounterBlockSet(unsigned int set); - GLSLANG_EXPORT void setAtomicCounterBlockBinding(unsigned int binding); + void setGlobalUniformBlockName(const char* name); + void setAtomicCounterBlockName(const char* name); + void setGlobalUniformSet(unsigned int set); + void setGlobalUniformBinding(unsigned int binding); + void setAtomicCounterBlockSet(unsigned int set); + void setAtomicCounterBlockBinding(unsigned int binding); - GLSLANG_EXPORT void addSourceText(const char* text, size_t len); - GLSLANG_EXPORT void setSourceFile(const char* file); + void addSourceText(const char* text, size_t len); + void setSourceFile(const char* file); // For setting up the environment (cleared to nothingness in the constructor). // These must be called so that parsing is done for the right source language and @@ -664,7 +667,7 @@ class TShader { virtual void releaseInclude(IncludeResult*) override { } }; - GLSLANG_EXPORT bool parse( + bool parse( const TBuiltInResource*, int defaultVersion, EProfile defaultProfile, bool forceDefaultVersionAndProfile, bool forwardCompatible, EShMessages, Includer&); @@ -690,14 +693,14 @@ class TShader { // NOTE: Doing just preprocessing to obtain a correct preprocessed shader string // is not an officially supported or fully working path. - GLSLANG_EXPORT bool preprocess( + bool preprocess( const TBuiltInResource* builtInResources, int defaultVersion, EProfile defaultProfile, bool forceDefaultVersionAndProfile, bool forwardCompatible, EShMessages message, std::string* outputString, Includer& includer); - GLSLANG_EXPORT const char* getInfoLog(); - GLSLANG_EXPORT const char* getInfoDebugLog(); + const char* getInfoLog(); + const char* getInfoDebugLog(); EShLanguage getStage() const { return stage; } TIntermediate* getIntermediate() const { return intermediate; } @@ -744,16 +747,16 @@ class TShader { // // Data needed for just a single object at the granularity exchanged by the reflection API -class TObjectReflection { +class GLSLANG_EXPORT TObjectReflection { public: - GLSLANG_EXPORT TObjectReflection(const std::string& pName, const TType& pType, int pOffset, int pGLDefineType, int pSize, int pIndex); + TObjectReflection(const std::string& pName, const TType& pType, int pOffset, int pGLDefineType, int pSize, int pIndex); const TType* getType() const { return type; } - GLSLANG_EXPORT int getBinding() const; - GLSLANG_EXPORT void dump() const; + int getBinding() const; + void dump() const; static TObjectReflection badReflection() { return TObjectReflection(); } - GLSLANG_EXPORT unsigned int layoutLocation() const; + unsigned int layoutLocation() const; std::string name; int offset; @@ -804,8 +807,7 @@ struct TVarEntryInfo; // // NOTE: that still limit checks are applied to bindings and sets // and may result in an error. -class TIoMapResolver -{ +class GLSLANG_EXPORT TIoMapResolver { public: virtual ~TIoMapResolver() {} @@ -877,41 +879,41 @@ GLSLANG_EXPORT TIoMapper* GetGlslIoMapper(); // // N.B.: Destruct a linked program *before* destructing the shaders linked into it. // -class TProgram { +class GLSLANG_EXPORT TProgram { public: - GLSLANG_EXPORT TProgram(); - GLSLANG_EXPORT virtual ~TProgram(); + TProgram(); + virtual ~TProgram(); void addShader(TShader* shader) { stages[shader->stage].push_back(shader); } std::list& getShaders(EShLanguage stage) { return stages[stage]; } // Link Validation interface - GLSLANG_EXPORT bool link(EShMessages); - GLSLANG_EXPORT const char* getInfoLog(); - GLSLANG_EXPORT const char* getInfoDebugLog(); + bool link(EShMessages); + const char* getInfoLog(); + const char* getInfoDebugLog(); TIntermediate* getIntermediate(EShLanguage stage) const { return intermediate[stage]; } // Reflection Interface // call first, to do liveness analysis, index mapping, etc.; returns false on failure - GLSLANG_EXPORT bool buildReflection(int opts = EShReflectionDefault); - GLSLANG_EXPORT unsigned getLocalSize(int dim) const; // return dim'th local size - GLSLANG_EXPORT unsigned getTileShadingRateQCOM(int dim) const; // return dim'th tile shading rate QCOM - GLSLANG_EXPORT int getReflectionIndex(const char *name) const; - GLSLANG_EXPORT int getReflectionPipeIOIndex(const char* name, const bool inOrOut) const; - GLSLANG_EXPORT int getNumUniformVariables() const; - GLSLANG_EXPORT const TObjectReflection& getUniform(int index) const; - GLSLANG_EXPORT int getNumUniformBlocks() const; - GLSLANG_EXPORT const TObjectReflection& getUniformBlock(int index) const; - GLSLANG_EXPORT int getNumPipeInputs() const; - GLSLANG_EXPORT const TObjectReflection& getPipeInput(int index) const; - GLSLANG_EXPORT int getNumPipeOutputs() const; - GLSLANG_EXPORT const TObjectReflection& getPipeOutput(int index) const; - GLSLANG_EXPORT int getNumBufferVariables() const; - GLSLANG_EXPORT const TObjectReflection& getBufferVariable(int index) const; - GLSLANG_EXPORT int getNumBufferBlocks() const; - GLSLANG_EXPORT const TObjectReflection& getBufferBlock(int index) const; - GLSLANG_EXPORT int getNumAtomicCounters() const; - GLSLANG_EXPORT const TObjectReflection& getAtomicCounter(int index) const; + bool buildReflection(int opts = EShReflectionDefault); + unsigned getLocalSize(int dim) const; // return dim'th local size + unsigned getTileShadingRateQCOM(int dim) const; // return dim'th tile shading rate QCOM + int getReflectionIndex(const char *name) const; + int getReflectionPipeIOIndex(const char* name, const bool inOrOut) const; + int getNumUniformVariables() const; + const TObjectReflection& getUniform(int index) const; + int getNumUniformBlocks() const; + const TObjectReflection& getUniformBlock(int index) const; + int getNumPipeInputs() const; + const TObjectReflection& getPipeInput(int index) const; + int getNumPipeOutputs() const; + const TObjectReflection& getPipeOutput(int index) const; + int getNumBufferVariables() const; + const TObjectReflection& getBufferVariable(int index) const; + int getNumBufferBlocks() const; + const TObjectReflection& getBufferBlock(int index) const; + int getNumAtomicCounters() const; + const TObjectReflection& getAtomicCounter(int index) const; // Legacy Reflection Interface - expressed in terms of above interface @@ -978,19 +980,19 @@ class TProgram { // returns a TType* const TType *getAttributeTType(int index) const { return getPipeInput(index).getType(); } - GLSLANG_EXPORT void dumpReflection(); + void dumpReflection(); // Get the IO resolver to use for mapIO - GLSLANG_EXPORT TIoMapResolver* getGlslIoResolver(EShLanguage stage); + TIoMapResolver* getGlslIoResolver(EShLanguage stage); // I/O mapping: apply base offsets and map live unbound variables // If resolver is not provided it uses the previous approach // and respects auto assignment and offsets. - GLSLANG_EXPORT bool mapIO(TIoMapResolver* pResolver = nullptr, TIoMapper* pIoMapper = nullptr); + bool mapIO(TIoMapResolver* pResolver = nullptr, TIoMapper* pIoMapper = nullptr); protected: - GLSLANG_EXPORT bool linkStage(EShLanguage, EShMessages); - GLSLANG_EXPORT bool crossStageCheck(EShMessages); + bool linkStage(EShLanguage, EShMessages); + bool crossStageCheck(EShMessages); TPoolAllocator* pool; std::list stages[EShLangCount]; diff --git a/libs/bgfx/3rdparty/glslang/glslang/Public/resource_limits_c.h b/libs/bgfx/3rdparty/glslang/glslang/Public/resource_limits_c.h index 3cf7442..4ad052b 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/Public/resource_limits_c.h +++ b/libs/bgfx/3rdparty/glslang/glslang/Public/resource_limits_c.h @@ -46,7 +46,7 @@ GLSLANG_EXPORT const glslang_resource_t* glslang_default_resource(void); // Returns the DefaultTBuiltInResource as a human-readable string. // NOTE: User is responsible for freeing this string. -GLSLANG_EXPORT const char* glslang_default_resource_string(); +GLSLANG_EXPORT const char* glslang_default_resource_string(void); // Decodes the resource limits from |config| to |resources|. GLSLANG_EXPORT void glslang_decode_resource_limits(glslang_resource_t* resources, char* config); diff --git a/libs/bgfx/3rdparty/glslang/glslang/ResourceLimits/ResourceLimits.cpp b/libs/bgfx/3rdparty/glslang/glslang/ResourceLimits/ResourceLimits.cpp index 0e9d1b5..79a1b3a 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/ResourceLimits/ResourceLimits.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/ResourceLimits/ResourceLimits.cpp @@ -39,9 +39,9 @@ #include "glslang/Public/ResourceLimits.h" -TBuiltInResource Resources; +static TBuiltInResource Resources; -const TBuiltInResource DefaultTBuiltInResource = { +static const TBuiltInResource DefaultTBuiltInResource = { /* .MaxLights = */ 32, /* .MaxClipPlanes = */ 6, /* .MaxTextureUnits = */ 32, diff --git a/libs/bgfx/3rdparty/glslang/glslang/ResourceLimits/resource_limits_c.cpp b/libs/bgfx/3rdparty/glslang/glslang/ResourceLimits/resource_limits_c.cpp index 8909d9e..64b5308 100644 --- a/libs/bgfx/3rdparty/glslang/glslang/ResourceLimits/resource_limits_c.cpp +++ b/libs/bgfx/3rdparty/glslang/glslang/ResourceLimits/resource_limits_c.cpp @@ -42,7 +42,7 @@ const glslang_resource_t* glslang_default_resource(void) return reinterpret_cast(GetDefaultResources()); } -const char* glslang_default_resource_string() +const char* glslang_default_resource_string(void) { std::string cpp_str = GetDefaultTBuiltInResourceString(); char* c_str = (char*)malloc(cpp_str.length() + 1); diff --git a/libs/bgfx/3rdparty/khronos/EGL/egl.h b/libs/bgfx/3rdparty/khronos/EGL/egl.h index 97d0878..3d19de9 100644 --- a/libs/bgfx/3rdparty/khronos/EGL/egl.h +++ b/libs/bgfx/3rdparty/khronos/EGL/egl.h @@ -14,7 +14,7 @@ extern "C" { ** used to make the header, and the header can be found at ** http://www.khronos.org/registry/egl ** -** Khronos $Git commit SHA1: 6fb1daea15 $ on $Git commit date: 2022-05-25 09:41:13 -0600 $ +** Khronos $Git commit SHA1: bd4838f57c $ on $Git commit date: 2024-09-09 22:54:26 -0600 $ */ #include @@ -23,7 +23,7 @@ extern "C" { #define EGL_EGL_PROTOTYPES 1 #endif -/* Generated on date 20220525 */ +/* Generated on date 20240909 */ /* Generated C header for: * API: egl diff --git a/libs/bgfx/3rdparty/khronos/EGL/eglext.h b/libs/bgfx/3rdparty/khronos/EGL/eglext.h index d58da70..ec13857 100644 --- a/libs/bgfx/3rdparty/khronos/EGL/eglext.h +++ b/libs/bgfx/3rdparty/khronos/EGL/eglext.h @@ -14,12 +14,12 @@ extern "C" { ** used to make the header, and the header can be found at ** http://www.khronos.org/registry/egl ** -** Khronos $Git commit SHA1: 6fb1daea15 $ on $Git commit date: 2022-05-25 09:41:13 -0600 $ +** Khronos $Git commit SHA1: bd4838f57c $ on $Git commit date: 2024-09-09 22:54:26 -0600 $ */ #include -#define EGL_EGLEXT_VERSION 20220525 +#define EGL_EGLEXT_VERSION 20240909 /* Generated C header for: * API: egl @@ -551,6 +551,11 @@ EGLAPI EGLBoolean EGLAPIENTRY eglPresentationTimeANDROID (EGLDisplay dpy, EGLSur #define EGL_RECORDABLE_ANDROID 0x3142 #endif /* EGL_ANDROID_recordable */ +#ifndef EGL_ANDROID_telemetry_hint +#define EGL_ANDROID_telemetry_hint 1 +#define EGL_TELEMETRY_HINT_ANDROID 0x3570 +#endif /* EGL_ANDROID_telemetry_hint */ + #ifndef EGL_ANGLE_d3d_share_handle_client_buffer #define EGL_ANGLE_d3d_share_handle_client_buffer 1 #define EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE 0x3200 @@ -723,10 +728,24 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQueryDeviceBinaryEXT (EGLDeviceEXT device, EGLi #define EGL_RENDERER_EXT 0x335F #endif /* EGL_EXT_device_query_name */ +#ifndef EGL_EXT_display_alloc +#define EGL_EXT_display_alloc 1 +#define EGL_ALLOC_NEW_DISPLAY_EXT 0x3379 +typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYDISPLAYEXTPROC) (EGLDisplay dpy); +#ifdef EGL_EGLEXT_PROTOTYPES +EGLAPI EGLBoolean EGLAPIENTRY eglDestroyDisplayEXT (EGLDisplay dpy); +#endif +#endif /* EGL_EXT_display_alloc */ + #ifndef EGL_EXT_explicit_device #define EGL_EXT_explicit_device 1 #endif /* EGL_EXT_explicit_device */ +#ifndef EGL_EXT_gl_colorspace_bt2020_hlg +#define EGL_EXT_gl_colorspace_bt2020_hlg 1 +#define EGL_GL_COLORSPACE_BT2020_HLG_EXT 0x3540 +#endif /* EGL_EXT_gl_colorspace_bt2020_hlg */ + #ifndef EGL_EXT_gl_colorspace_bt2020_linear #define EGL_EXT_gl_colorspace_bt2020_linear 1 #define EGL_GL_COLORSPACE_BT2020_LINEAR_EXT 0x333F @@ -923,6 +942,10 @@ EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurfaceEXT (EGLDisplay dpy, #define EGL_EXT_protected_surface 1 #endif /* EGL_EXT_protected_surface */ +#ifndef EGL_EXT_query_reset_notification_strategy +#define EGL_EXT_query_reset_notification_strategy 1 +#endif /* EGL_EXT_query_reset_notification_strategy */ + #ifndef EGL_EXT_stream_consumer_egloutput #define EGL_EXT_stream_consumer_egloutput 1 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMEROUTPUTEXTPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLOutputLayerEXT layer); @@ -1223,6 +1246,11 @@ EGLAPI EGLBoolean EGLAPIENTRY eglStreamReleaseImageNV (EGLDisplay dpy, EGLStream #endif #endif /* EGL_NV_stream_consumer_eglimage */ +#ifndef EGL_NV_stream_consumer_eglimage_use_scanout_attrib +#define EGL_NV_stream_consumer_eglimage_use_scanout_attrib 1 +#define EGL_STREAM_CONSUMER_IMAGE_USE_SCANOUT_NV 0x3378 +#endif /* EGL_NV_stream_consumer_eglimage_use_scanout_attrib */ + #ifndef EGL_NV_stream_consumer_gltexture_yuv #define EGL_NV_stream_consumer_gltexture_yuv 1 #define EGL_YUV_PLANE0_TEXTURE_UNIT_NV 0x332C @@ -1432,6 +1460,16 @@ EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeNV (void); #define EGL_TRIPLE_BUFFER_NV 0x3230 #endif /* EGL_NV_triple_buffer */ +#ifndef EGL_QNX_image_native_buffer +#define EGL_QNX_image_native_buffer 1 +#define EGL_NATIVE_BUFFER_QNX 0x3551 +#endif /* EGL_QNX_image_native_buffer */ + +#ifndef EGL_QNX_platform_screen +#define EGL_QNX_platform_screen 1 +#define EGL_PLATFORM_SCREEN_QNX 0x3550 +#endif /* EGL_QNX_platform_screen */ + #ifndef EGL_TIZEN_image_native_buffer #define EGL_TIZEN_image_native_buffer 1 #define EGL_NATIVE_BUFFER_TIZEN 0x32A0 diff --git a/libs/bgfx/3rdparty/khronos/EGL/eglplatform.h b/libs/bgfx/3rdparty/khronos/EGL/eglplatform.h index 99362a2..6786afd 100644 --- a/libs/bgfx/3rdparty/khronos/EGL/eglplatform.h +++ b/libs/bgfx/3rdparty/khronos/EGL/eglplatform.h @@ -64,6 +64,12 @@ typedef HDC EGLNativeDisplayType; typedef HBITMAP EGLNativePixmapType; typedef HWND EGLNativeWindowType; +#elif defined(__QNX__) + +typedef khronos_uintptr_t EGLNativeDisplayType; +typedef struct _screen_pixmap* EGLNativePixmapType; /* screen_pixmap_t */ +typedef struct _screen_window* EGLNativeWindowType; /* screen_window_t */ + #elif defined(__EMSCRIPTEN__) typedef int EGLNativeDisplayType; diff --git a/libs/bgfx/3rdparty/khronos/GLES2/gl2.h b/libs/bgfx/3rdparty/khronos/GLES2/gl2.h index af244a7..da64b88 100644 --- a/libs/bgfx/3rdparty/khronos/GLES2/gl2.h +++ b/libs/bgfx/3rdparty/khronos/GLES2/gl2.h @@ -6,7 +6,7 @@ extern "C" { #endif /* -** Copyright 2013-2020 The Khronos Group Inc. +** Copyright 2013-2025 The Khronos Group Inc. ** SPDX-License-Identifier: MIT ** ** This header is generated from the Khronos OpenGL / OpenGL ES XML @@ -25,7 +25,7 @@ extern "C" { #define GL_GLES_PROTOTYPES 1 #endif -/* Generated on date 20220530 */ +/* Generated on date 20251023 */ /* Generated C header for: * API: gles2 diff --git a/libs/bgfx/3rdparty/khronos/GLES2/gl2ext.h b/libs/bgfx/3rdparty/khronos/GLES2/gl2ext.h index 9448ce0..29a6c51 100644 --- a/libs/bgfx/3rdparty/khronos/GLES2/gl2ext.h +++ b/libs/bgfx/3rdparty/khronos/GLES2/gl2ext.h @@ -6,7 +6,7 @@ extern "C" { #endif /* -** Copyright 2013-2020 The Khronos Group Inc. +** Copyright 2013-2025 The Khronos Group Inc. ** SPDX-License-Identifier: MIT ** ** This header is generated from the Khronos OpenGL / OpenGL ES XML @@ -19,7 +19,7 @@ extern "C" { #define GL_APIENTRYP GL_APIENTRY* #endif -/* Generated on date 20220530 */ +#define GL_GLEXT_VERSION 20251023 /* Generated C header for: * API: gles2 @@ -1052,6 +1052,21 @@ GL_APICALL void GL_APIENTRY glGetSyncivAPPLE (GLsync sync, GLenum pname, GLsizei #define GL_ARM_rgba8 1 #endif /* GL_ARM_rgba8 */ +#ifndef GL_ARM_shader_core_properties +#define GL_ARM_shader_core_properties 1 +#define GL_SHADER_CORE_COUNT_ARM 0x96F0 +#define GL_SHADER_CORE_ACTIVE_COUNT_ARM 0x96F1 +#define GL_SHADER_CORE_PRESENT_MASK_ARM 0x96F2 +#define GL_SHADER_CORE_MAX_WARP_COUNT_ARM 0x96F3 +#define GL_SHADER_CORE_PIXEL_RATE_ARM 0x96F4 +#define GL_SHADER_CORE_TEXEL_RATE_ARM 0x96F5 +#define GL_SHADER_CORE_FMA_RATE_ARM 0x96F6 +typedef void (GL_APIENTRYP PFNGLMAXACTIVESHADERCORESARMPROC) (GLuint count); +#ifdef GL_GLEXT_PROTOTYPES +GL_APICALL void GL_APIENTRY glMaxActiveShaderCoresARM (GLuint count); +#endif +#endif /* GL_ARM_shader_core_properties */ + #ifndef GL_ARM_shader_framebuffer_fetch #define GL_ARM_shader_framebuffer_fetch 1 #define GL_FETCH_PER_SAMPLE_ARM 0x8F65 @@ -1459,6 +1474,16 @@ GL_APICALL void GL_APIENTRY glFramebufferShadingRateEXT (GLenum target, GLenum a #endif #endif /* GL_EXT_fragment_shading_rate */ +#ifndef GL_EXT_framebuffer_blit_layers +#define GL_EXT_framebuffer_blit_layers 1 +typedef void (GL_APIENTRYP PFNGLBLITFRAMEBUFFERLAYERSEXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +typedef void (GL_APIENTRYP PFNGLBLITFRAMEBUFFERLAYEREXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint srcLayer, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLint dstLayer, GLbitfield mask, GLenum filter); +#ifdef GL_GLEXT_PROTOTYPES +GL_APICALL void GL_APIENTRY glBlitFramebufferLayersEXT (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GL_APICALL void GL_APIENTRY glBlitFramebufferLayerEXT (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint srcLayer, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLint dstLayer, GLbitfield mask, GLenum filter); +#endif +#endif /* GL_EXT_framebuffer_blit_layers */ + #ifndef GL_EXT_geometry_point_size #define GL_EXT_geometry_point_size 1 #endif /* GL_EXT_geometry_point_size */ @@ -1612,6 +1637,86 @@ GL_APICALL void GL_APIENTRY glImportMemoryWin32NameEXT (GLuint memory, GLuint64 #endif #endif /* GL_EXT_memory_object_win32 */ +#ifndef GL_EXT_mesh_shader +#define GL_EXT_mesh_shader 1 +#define GL_MESH_SHADER_EXT 0x9559 +#define GL_TASK_SHADER_EXT 0x955A +#define GL_MAX_MESH_UNIFORM_BLOCKS_EXT 0x8E60 +#define GL_MAX_MESH_TEXTURE_IMAGE_UNITS_EXT 0x8E61 +#define GL_MAX_MESH_IMAGE_UNIFORMS_EXT 0x8E62 +#define GL_MAX_MESH_UNIFORM_COMPONENTS_EXT 0x8E63 +#define GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_EXT 0x8E64 +#define GL_MAX_MESH_ATOMIC_COUNTERS_EXT 0x8E65 +#define GL_MAX_MESH_SHADER_STORAGE_BLOCKS_EXT 0x8E66 +#define GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_EXT 0x8E67 +#define GL_MAX_TASK_UNIFORM_BLOCKS_EXT 0x8E68 +#define GL_MAX_TASK_TEXTURE_IMAGE_UNITS_EXT 0x8E69 +#define GL_MAX_TASK_IMAGE_UNIFORMS_EXT 0x8E6A +#define GL_MAX_TASK_UNIFORM_COMPONENTS_EXT 0x8E6B +#define GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_EXT 0x8E6C +#define GL_MAX_TASK_ATOMIC_COUNTERS_EXT 0x8E6D +#define GL_MAX_TASK_SHADER_STORAGE_BLOCKS_EXT 0x8E6E +#define GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_EXT 0x8E6F +#define GL_MAX_TASK_WORK_GROUP_TOTAL_COUNT_EXT 0x9740 +#define GL_MAX_MESH_WORK_GROUP_TOTAL_COUNT_EXT 0x9741 +#define GL_MAX_MESH_WORK_GROUP_INVOCATIONS_EXT 0x9757 +#define GL_MAX_TASK_WORK_GROUP_INVOCATIONS_EXT 0x9759 +#define GL_MAX_TASK_PAYLOAD_SIZE_EXT 0x9742 +#define GL_MAX_TASK_SHARED_MEMORY_SIZE_EXT 0x9743 +#define GL_MAX_MESH_SHARED_MEMORY_SIZE_EXT 0x9744 +#define GL_MAX_TASK_PAYLOAD_AND_SHARED_MEMORY_SIZE_EXT 0x9745 +#define GL_MAX_MESH_PAYLOAD_AND_SHARED_MEMORY_SIZE_EXT 0x9746 +#define GL_MAX_MESH_OUTPUT_MEMORY_SIZE_EXT 0x9747 +#define GL_MAX_MESH_PAYLOAD_AND_OUTPUT_MEMORY_SIZE_EXT 0x9748 +#define GL_MAX_MESH_OUTPUT_VERTICES_EXT 0x9538 +#define GL_MAX_MESH_OUTPUT_PRIMITIVES_EXT 0x9756 +#define GL_MAX_MESH_OUTPUT_COMPONENTS_EXT 0x9749 +#define GL_MAX_MESH_OUTPUT_LAYERS_EXT 0x974A +#define GL_MAX_MESH_MULTIVIEW_VIEW_COUNT_EXT 0x9557 +#define GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_EXT 0x92DF +#define GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_EXT 0x9543 +#define GL_MAX_PREFERRED_TASK_WORK_GROUP_INVOCATIONS_EXT 0x974B +#define GL_MAX_PREFERRED_MESH_WORK_GROUP_INVOCATIONS_EXT 0x974C +#define GL_MESH_PREFERS_LOCAL_INVOCATION_VERTEX_OUTPUT_EXT 0x974D +#define GL_MESH_PREFERS_LOCAL_INVOCATION_PRIMITIVE_OUTPUT_EXT 0x974E +#define GL_MESH_PREFERS_COMPACT_VERTEX_OUTPUT_EXT 0x974F +#define GL_MESH_PREFERS_COMPACT_PRIMITIVE_OUTPUT_EXT 0x9750 +#define GL_MAX_TASK_WORK_GROUP_COUNT_EXT 0x9751 +#define GL_MAX_MESH_WORK_GROUP_COUNT_EXT 0x9752 +#define GL_MAX_MESH_WORK_GROUP_SIZE_EXT 0x9758 +#define GL_MAX_TASK_WORK_GROUP_SIZE_EXT 0x975A +#define GL_MESH_WORK_GROUP_SIZE_EXT 0x953E +#define GL_TASK_WORK_GROUP_SIZE_EXT 0x953F +#define GL_MESH_VERTICES_OUT_EXT 0x9579 +#define GL_MESH_PRIMITIVES_OUT_EXT 0x957A +#define GL_MESH_OUTPUT_TYPE_EXT 0x957B +#define GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_EXT 0x959C +#define GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_EXT 0x959D +#define GL_REFERENCED_BY_MESH_SHADER_EXT 0x95A0 +#define GL_REFERENCED_BY_TASK_SHADER_EXT 0x95A1 +#define GL_TASK_SHADER_INVOCATIONS_EXT 0x9753 +#define GL_MESH_SHADER_INVOCATIONS_EXT 0x9754 +#define GL_MESH_PRIMITIVES_GENERATED_EXT 0x9755 +#define GL_MESH_SHADER_BIT_EXT 0x00000040 +#define GL_TASK_SHADER_BIT_EXT 0x00000080 +#define GL_MESH_SUBROUTINE_EXT 0x957C +#define GL_TASK_SUBROUTINE_EXT 0x957D +#define GL_MESH_SUBROUTINE_UNIFORM_EXT 0x957E +#define GL_TASK_SUBROUTINE_UNIFORM_EXT 0x957F +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_EXT 0x959E +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_EXT 0x959F +typedef void (GL_APIENTRYP PFNGLDRAWMESHTASKSEXTPROC) (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z); +typedef void (GL_APIENTRYP PFNGLDRAWMESHTASKSINDIRECTEXTPROC) (GLintptr indirect); +typedef void (GL_APIENTRYP PFNGLMULTIDRAWMESHTASKSINDIRECTEXTPROC) (GLintptr indirect, GLsizei drawcount, GLsizei stride); +typedef void (GL_APIENTRYP PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTEXTPROC) (GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); +#ifdef GL_GLEXT_PROTOTYPES +GL_APICALL void GL_APIENTRY glDrawMeshTasksEXT (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z); +GL_APICALL void GL_APIENTRY glDrawMeshTasksIndirectEXT (GLintptr indirect); +GL_APICALL void GL_APIENTRY glMultiDrawMeshTasksIndirectEXT (GLintptr indirect, GLsizei drawcount, GLsizei stride); +GL_APICALL void GL_APIENTRY glMultiDrawMeshTasksIndirectCountEXT (GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); +#endif +#endif /* GL_EXT_mesh_shader */ + #ifndef GL_EXT_multi_draw_arrays #define GL_EXT_multi_draw_arrays 1 typedef void (GL_APIENTRYP PFNGLMULTIDRAWARRAYSEXTPROC) (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount); @@ -1856,7 +1961,7 @@ GL_APICALL void GL_APIENTRY glImportSemaphoreWin32NameEXT (GLuint semaphore, GLe #define GL_PROGRAM_PIPELINE_BINDING_EXT 0x825A typedef void (GL_APIENTRYP PFNGLACTIVESHADERPROGRAMEXTPROC) (GLuint pipeline, GLuint program); typedef void (GL_APIENTRYP PFNGLBINDPROGRAMPIPELINEEXTPROC) (GLuint pipeline); -typedef GLuint (GL_APIENTRYP PFNGLCREATESHADERPROGRAMVEXTPROC) (GLenum type, GLsizei count, const GLchar **strings); +typedef GLuint (GL_APIENTRYP PFNGLCREATESHADERPROGRAMVEXTPROC) (GLenum type, GLsizei count, const GLchar *const*strings); typedef void (GL_APIENTRYP PFNGLDELETEPROGRAMPIPELINESEXTPROC) (GLsizei n, const GLuint *pipelines); typedef void (GL_APIENTRYP PFNGLGENPROGRAMPIPELINESEXTPROC) (GLsizei n, GLuint *pipelines); typedef void (GL_APIENTRYP PFNGLGETPROGRAMPIPELINEINFOLOGEXTPROC) (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog); @@ -1901,7 +2006,7 @@ typedef void (GL_APIENTRYP PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC) (GLuint progra #ifdef GL_GLEXT_PROTOTYPES GL_APICALL void GL_APIENTRY glActiveShaderProgramEXT (GLuint pipeline, GLuint program); GL_APICALL void GL_APIENTRY glBindProgramPipelineEXT (GLuint pipeline); -GL_APICALL GLuint GL_APIENTRY glCreateShaderProgramvEXT (GLenum type, GLsizei count, const GLchar **strings); +GL_APICALL GLuint GL_APIENTRY glCreateShaderProgramvEXT (GLenum type, GLsizei count, const GLchar *const*strings); GL_APICALL void GL_APIENTRY glDeleteProgramPipelinesEXT (GLsizei n, const GLuint *pipelines); GL_APICALL void GL_APIENTRY glGenProgramPipelinesEXT (GLsizei n, GLuint *pipelines); GL_APICALL void GL_APIENTRY glGetProgramPipelineInfoLogEXT (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog); @@ -2009,6 +2114,10 @@ GL_APICALL void GL_APIENTRY glClearPixelLocalStorageuiEXT (GLsizei offset, GLsiz #define GL_EXT_shader_texture_lod 1 #endif /* GL_EXT_shader_texture_lod */ +#ifndef GL_EXT_shader_texture_samples +#define GL_EXT_shader_texture_samples 1 +#endif /* GL_EXT_shader_texture_samples */ + #ifndef GL_EXT_shadow_samplers #define GL_EXT_shadow_samplers 1 #define GL_TEXTURE_COMPARE_MODE_EXT 0x884C @@ -2375,6 +2484,16 @@ GL_APICALL void GL_APIENTRY glWindowRectanglesEXT (GLenum mode, GLsizei count, c #define GL_GCCSO_SHADER_BINARY_FJ 0x9260 #endif /* GL_FJ_shader_binary_GCCSO */ +#ifndef GL_HUAWEI_program_binary +#define GL_HUAWEI_program_binary 1 +#define GL_HUAWEI_PROGRAM_BINARY 0x9771 +#endif /* GL_HUAWEI_program_binary */ + +#ifndef GL_HUAWEI_shader_binary +#define GL_HUAWEI_shader_binary 1 +#define GL_HUAWEI_SHADER_BINARY 0x9770 +#endif /* GL_HUAWEI_shader_binary */ + #ifndef GL_IMG_bindless_texture #define GL_IMG_bindless_texture 1 typedef GLuint64 (GL_APIENTRYP PFNGLGETTEXTUREHANDLEIMGPROC) (GLuint texture); @@ -2553,10 +2672,42 @@ GL_APICALL void GL_APIENTRY glGetFramebufferParameterivMESA (GLenum target, GLen #define GL_PROGRAM_BINARY_FORMAT_MESA 0x875F #endif /* GL_MESA_program_binary_formats */ +#ifndef GL_MESA_sampler_objects +#define GL_MESA_sampler_objects 1 +#define GL_SAMPLER_BINDING 0x8919 +typedef void (GL_APIENTRYP PFNGLGENSAMPLERSPROC) (GLsizei count, GLuint *samplers); +typedef void (GL_APIENTRYP PFNGLDELETESAMPLERSPROC) (GLsizei count, const GLuint *samplers); +typedef GLboolean (GL_APIENTRYP PFNGLISSAMPLERPROC) (GLuint sampler); +typedef void (GL_APIENTRYP PFNGLBINDSAMPLERPROC) (GLuint unit, GLuint sampler); +typedef void (GL_APIENTRYP PFNGLSAMPLERPARAMETERIPROC) (GLuint sampler, GLenum pname, GLint param); +typedef void (GL_APIENTRYP PFNGLSAMPLERPARAMETERIVPROC) (GLuint sampler, GLenum pname, const GLint *param); +typedef void (GL_APIENTRYP PFNGLSAMPLERPARAMETERFPROC) (GLuint sampler, GLenum pname, GLfloat param); +typedef void (GL_APIENTRYP PFNGLSAMPLERPARAMETERFVPROC) (GLuint sampler, GLenum pname, const GLfloat *param); +typedef void (GL_APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC) (GLuint sampler, GLenum pname, GLint *params); +typedef void (GL_APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC) (GLuint sampler, GLenum pname, GLfloat *params); +#ifdef GL_GLEXT_PROTOTYPES +GL_APICALL void GL_APIENTRY glGenSamplers (GLsizei count, GLuint *samplers); +GL_APICALL void GL_APIENTRY glDeleteSamplers (GLsizei count, const GLuint *samplers); +GL_APICALL GLboolean GL_APIENTRY glIsSampler (GLuint sampler); +GL_APICALL void GL_APIENTRY glBindSampler (GLuint unit, GLuint sampler); +GL_APICALL void GL_APIENTRY glSamplerParameteri (GLuint sampler, GLenum pname, GLint param); +GL_APICALL void GL_APIENTRY glSamplerParameteriv (GLuint sampler, GLenum pname, const GLint *param); +GL_APICALL void GL_APIENTRY glSamplerParameterf (GLuint sampler, GLenum pname, GLfloat param); +GL_APICALL void GL_APIENTRY glSamplerParameterfv (GLuint sampler, GLenum pname, const GLfloat *param); +GL_APICALL void GL_APIENTRY glGetSamplerParameteriv (GLuint sampler, GLenum pname, GLint *params); +GL_APICALL void GL_APIENTRY glGetSamplerParameterfv (GLuint sampler, GLenum pname, GLfloat *params); +#endif +#endif /* GL_MESA_sampler_objects */ + #ifndef GL_MESA_shader_integer_functions #define GL_MESA_shader_integer_functions 1 #endif /* GL_MESA_shader_integer_functions */ +#ifndef GL_MESA_texture_const_bandwidth +#define GL_MESA_texture_const_bandwidth 1 +#define GL_CONST_BW_TILING_MESA 0x8BBE +#endif /* GL_MESA_texture_const_bandwidth */ + #ifndef GL_NVX_blend_equation_advanced_multi_draw_buffers #define GL_NVX_blend_equation_advanced_multi_draw_buffers 1 #endif /* GL_NVX_blend_equation_advanced_multi_draw_buffers */ @@ -3186,6 +3337,13 @@ GL_APICALL void GL_APIENTRY glUniformMatrix4x3fvNV (GLint location, GLsizei coun #endif #endif /* GL_NV_non_square_matrices */ +#ifndef GL_NV_pack_subimage +#define GL_NV_pack_subimage 1 +#define GL_PACK_ROW_LENGTH_NV 0x0D02 +#define GL_PACK_SKIP_ROWS_NV 0x0D03 +#define GL_PACK_SKIP_PIXELS_NV 0x0D04 +#endif /* GL_NV_pack_subimage */ + #ifndef GL_NV_path_rendering #define GL_NV_path_rendering 1 typedef double GLdouble; @@ -3683,6 +3841,14 @@ GL_APICALL void GL_APIENTRY glShadingRateSampleOrderCustomNV (GLenum rate, GLuin #define GL_NV_stereo_view_rendering 1 #endif /* GL_NV_stereo_view_rendering */ +#ifndef GL_NV_texture_barrier +#define GL_NV_texture_barrier 1 +typedef void (GL_APIENTRYP PFNGLTEXTUREBARRIERNVPROC) (void); +#ifdef GL_GLEXT_PROTOTYPES +GL_APICALL void GL_APIENTRY glTextureBarrierNV (void); +#endif +#endif /* GL_NV_texture_barrier */ + #ifndef GL_NV_texture_border_clamp #define GL_NV_texture_border_clamp 1 #define GL_TEXTURE_BORDER_COLOR_NV 0x1004 @@ -3779,8 +3945,10 @@ GL_APICALL void GL_APIENTRY glViewportSwizzleNV (GLuint index, GLenum swizzlex, #define GL_MAX_VIEWS_OVR 0x9631 #define GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR 0x9633 typedef void (GL_APIENTRYP PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); +typedef void (GL_APIENTRYP PFNGLNAMEDFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); #ifdef GL_GLEXT_PROTOTYPES GL_APICALL void GL_APIENTRY glFramebufferTextureMultiviewOVR (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); +GL_APICALL void GL_APIENTRY glNamedFramebufferTextureMultiviewOVR (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); #endif #endif /* GL_OVR_multiview */ @@ -3917,6 +4085,10 @@ GL_APICALL void GL_APIENTRY glTexEstimateMotionRegionsQCOM (GLuint ref, GLuint t #define GL_PERFMON_GLOBAL_MODE_QCOM 0x8FA0 #endif /* GL_QCOM_perfmon_global_mode */ +#ifndef GL_QCOM_render_sRGB_R8_RG8 +#define GL_QCOM_render_sRGB_R8_RG8 1 +#endif /* GL_QCOM_render_sRGB_R8_RG8 */ + #ifndef GL_QCOM_render_shared_exponent #define GL_QCOM_render_shared_exponent 1 #endif /* GL_QCOM_render_shared_exponent */ @@ -3974,6 +4146,11 @@ GL_APICALL void GL_APIENTRY glTextureFoveationParametersQCOM (GLuint texture, GL #define GL_MAX_SHADER_SUBSAMPLED_IMAGE_UNITS_QCOM 0x8FA1 #endif /* GL_QCOM_texture_foveated_subsampled_layout */ +#ifndef GL_QCOM_texture_lod_bias +#define GL_QCOM_texture_lod_bias 1 +#define GL_TEXTURE_LOD_BIAS_QCOM 0x8C96 +#endif /* GL_QCOM_texture_lod_bias */ + #ifndef GL_QCOM_tiled_rendering #define GL_QCOM_tiled_rendering 1 #define GL_COLOR_BUFFER_BIT0_QCOM 0x00000001 @@ -4021,6 +4198,12 @@ GL_APICALL void GL_APIENTRY glEndTilingQCOM (GLbitfield preserveMask); #define GL_WRITEONLY_RENDERING_QCOM 0x8823 #endif /* GL_QCOM_writeonly_rendering */ +#ifndef GL_QCOM_ycbcr_degamma +#define GL_QCOM_ycbcr_degamma 1 +#define GL_TEXTURE_Y_DEGAMMA_QCOM 0x9710 +#define GL_TEXTURE_CBCR_DEGAMMA_QCOM 0x9711 +#endif /* GL_QCOM_ycbcr_degamma */ + #ifndef GL_VIV_shader_binary #define GL_VIV_shader_binary 1 #define GL_SHADER_BINARY_VIV 0x8FC4 diff --git a/libs/bgfx/3rdparty/khronos/GLES3/gl3.h b/libs/bgfx/3rdparty/khronos/GLES3/gl3.h index eaf5efd..10a3ffb 100644 --- a/libs/bgfx/3rdparty/khronos/GLES3/gl3.h +++ b/libs/bgfx/3rdparty/khronos/GLES3/gl3.h @@ -6,7 +6,7 @@ extern "C" { #endif /* -** Copyright 2013-2020 The Khronos Group Inc. +** Copyright 2013-2025 The Khronos Group Inc. ** SPDX-License-Identifier: MIT ** ** This header is generated from the Khronos OpenGL / OpenGL ES XML @@ -25,7 +25,7 @@ extern "C" { #define GL_GLES_PROTOTYPES 1 #endif -/* Generated on date 20220530 */ +/* Generated on date 20251023 */ /* Generated C header for: * API: gles2 diff --git a/libs/bgfx/3rdparty/khronos/gl/glcorearb.h b/libs/bgfx/3rdparty/khronos/gl/glcorearb.h index 07517e7..fa82d66 100644 --- a/libs/bgfx/3rdparty/khronos/gl/glcorearb.h +++ b/libs/bgfx/3rdparty/khronos/gl/glcorearb.h @@ -6,7 +6,7 @@ extern "C" { #endif /* -** Copyright 2013-2020 The Khronos Group Inc. +** Copyright 2013-2025 The Khronos Group Inc. ** SPDX-License-Identifier: MIT ** ** This header is generated from the Khronos OpenGL / OpenGL ES XML @@ -4574,6 +4574,127 @@ GLAPI void APIENTRY glDrawElementsInstancedEXT (GLenum mode, GLsizei count, GLen #endif #endif /* GL_EXT_draw_instanced */ +#ifndef GL_EXT_fragment_shading_rate +#define GL_EXT_fragment_shading_rate 1 +#define GL_SHADING_RATE_1X1_PIXELS_EXT 0x96A6 +#define GL_SHADING_RATE_1X2_PIXELS_EXT 0x96A7 +#define GL_SHADING_RATE_2X1_PIXELS_EXT 0x96A8 +#define GL_SHADING_RATE_2X2_PIXELS_EXT 0x96A9 +#define GL_SHADING_RATE_1X4_PIXELS_EXT 0x96AA +#define GL_SHADING_RATE_4X1_PIXELS_EXT 0x96AB +#define GL_SHADING_RATE_4X2_PIXELS_EXT 0x96AC +#define GL_SHADING_RATE_2X4_PIXELS_EXT 0x96AD +#define GL_SHADING_RATE_4X4_PIXELS_EXT 0x96AE +#define GL_SHADING_RATE_EXT 0x96D0 +#define GL_SHADING_RATE_ATTACHMENT_EXT 0x96D1 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_EXT 0x96D2 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_EXT 0x96D3 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_EXT 0x96D4 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_EXT 0x96D5 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_EXT 0x96D6 +#define GL_MIN_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_WIDTH_EXT 0x96D7 +#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_WIDTH_EXT 0x96D8 +#define GL_MIN_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_HEIGHT_EXT 0x96D9 +#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_HEIGHT_EXT 0x96DA +#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_ASPECT_RATIO_EXT 0x96DB +#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_LAYERS_EXT 0x96DC +#define GL_FRAGMENT_SHADING_RATE_WITH_SHADER_DEPTH_STENCIL_WRITES_SUPPORTED_EXT 0x96DD +#define GL_FRAGMENT_SHADING_RATE_WITH_SAMPLE_MASK_SUPPORTED_EXT 0x96DE +#define GL_FRAGMENT_SHADING_RATE_ATTACHMENT_WITH_DEFAULT_FRAMEBUFFER_SUPPORTED_EXT 0x96DF +#define GL_FRAGMENT_SHADING_RATE_NON_TRIVIAL_COMBINERS_SUPPORTED_EXT 0x8F6F +#define GL_FRAGMENT_SHADING_RATE_PRIMITIVE_RATE_WITH_MULTI_VIEWPORT_SUPPORTED_EXT 0x9780 +typedef void (APIENTRYP PFNGLGETFRAGMENTSHADINGRATESEXTPROC) (GLsizei samples, GLsizei maxCount, GLsizei *count, GLenum *shadingRates); +typedef void (APIENTRYP PFNGLSHADINGRATEEXTPROC) (GLenum rate); +typedef void (APIENTRYP PFNGLSHADINGRATECOMBINEROPSEXTPROC) (GLenum combinerOp0, GLenum combinerOp1); +typedef void (APIENTRYP PFNGLFRAMEBUFFERSHADINGRATEEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint baseLayer, GLsizei numLayers, GLsizei texelWidth, GLsizei texelHeight); +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glGetFragmentShadingRatesEXT (GLsizei samples, GLsizei maxCount, GLsizei *count, GLenum *shadingRates); +GLAPI void APIENTRY glShadingRateEXT (GLenum rate); +GLAPI void APIENTRY glShadingRateCombinerOpsEXT (GLenum combinerOp0, GLenum combinerOp1); +GLAPI void APIENTRY glFramebufferShadingRateEXT (GLenum target, GLenum attachment, GLuint texture, GLint baseLayer, GLsizei numLayers, GLsizei texelWidth, GLsizei texelHeight); +#endif +#endif /* GL_EXT_fragment_shading_rate */ + +#ifndef GL_EXT_mesh_shader +#define GL_EXT_mesh_shader 1 +#define GL_MESH_SHADER_EXT 0x9559 +#define GL_TASK_SHADER_EXT 0x955A +#define GL_MAX_MESH_UNIFORM_BLOCKS_EXT 0x8E60 +#define GL_MAX_MESH_TEXTURE_IMAGE_UNITS_EXT 0x8E61 +#define GL_MAX_MESH_IMAGE_UNIFORMS_EXT 0x8E62 +#define GL_MAX_MESH_UNIFORM_COMPONENTS_EXT 0x8E63 +#define GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_EXT 0x8E64 +#define GL_MAX_MESH_ATOMIC_COUNTERS_EXT 0x8E65 +#define GL_MAX_MESH_SHADER_STORAGE_BLOCKS_EXT 0x8E66 +#define GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_EXT 0x8E67 +#define GL_MAX_TASK_UNIFORM_BLOCKS_EXT 0x8E68 +#define GL_MAX_TASK_TEXTURE_IMAGE_UNITS_EXT 0x8E69 +#define GL_MAX_TASK_IMAGE_UNIFORMS_EXT 0x8E6A +#define GL_MAX_TASK_UNIFORM_COMPONENTS_EXT 0x8E6B +#define GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_EXT 0x8E6C +#define GL_MAX_TASK_ATOMIC_COUNTERS_EXT 0x8E6D +#define GL_MAX_TASK_SHADER_STORAGE_BLOCKS_EXT 0x8E6E +#define GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_EXT 0x8E6F +#define GL_MAX_TASK_WORK_GROUP_TOTAL_COUNT_EXT 0x9740 +#define GL_MAX_MESH_WORK_GROUP_TOTAL_COUNT_EXT 0x9741 +#define GL_MAX_MESH_WORK_GROUP_INVOCATIONS_EXT 0x9757 +#define GL_MAX_TASK_WORK_GROUP_INVOCATIONS_EXT 0x9759 +#define GL_MAX_TASK_PAYLOAD_SIZE_EXT 0x9742 +#define GL_MAX_TASK_SHARED_MEMORY_SIZE_EXT 0x9743 +#define GL_MAX_MESH_SHARED_MEMORY_SIZE_EXT 0x9744 +#define GL_MAX_TASK_PAYLOAD_AND_SHARED_MEMORY_SIZE_EXT 0x9745 +#define GL_MAX_MESH_PAYLOAD_AND_SHARED_MEMORY_SIZE_EXT 0x9746 +#define GL_MAX_MESH_OUTPUT_MEMORY_SIZE_EXT 0x9747 +#define GL_MAX_MESH_PAYLOAD_AND_OUTPUT_MEMORY_SIZE_EXT 0x9748 +#define GL_MAX_MESH_OUTPUT_VERTICES_EXT 0x9538 +#define GL_MAX_MESH_OUTPUT_PRIMITIVES_EXT 0x9756 +#define GL_MAX_MESH_OUTPUT_COMPONENTS_EXT 0x9749 +#define GL_MAX_MESH_OUTPUT_LAYERS_EXT 0x974A +#define GL_MAX_MESH_MULTIVIEW_VIEW_COUNT_EXT 0x9557 +#define GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_EXT 0x92DF +#define GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_EXT 0x9543 +#define GL_MAX_PREFERRED_TASK_WORK_GROUP_INVOCATIONS_EXT 0x974B +#define GL_MAX_PREFERRED_MESH_WORK_GROUP_INVOCATIONS_EXT 0x974C +#define GL_MESH_PREFERS_LOCAL_INVOCATION_VERTEX_OUTPUT_EXT 0x974D +#define GL_MESH_PREFERS_LOCAL_INVOCATION_PRIMITIVE_OUTPUT_EXT 0x974E +#define GL_MESH_PREFERS_COMPACT_VERTEX_OUTPUT_EXT 0x974F +#define GL_MESH_PREFERS_COMPACT_PRIMITIVE_OUTPUT_EXT 0x9750 +#define GL_MAX_TASK_WORK_GROUP_COUNT_EXT 0x9751 +#define GL_MAX_MESH_WORK_GROUP_COUNT_EXT 0x9752 +#define GL_MAX_MESH_WORK_GROUP_SIZE_EXT 0x9758 +#define GL_MAX_TASK_WORK_GROUP_SIZE_EXT 0x975A +#define GL_MESH_WORK_GROUP_SIZE_EXT 0x953E +#define GL_TASK_WORK_GROUP_SIZE_EXT 0x953F +#define GL_MESH_VERTICES_OUT_EXT 0x9579 +#define GL_MESH_PRIMITIVES_OUT_EXT 0x957A +#define GL_MESH_OUTPUT_TYPE_EXT 0x957B +#define GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_EXT 0x959C +#define GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_EXT 0x959D +#define GL_REFERENCED_BY_MESH_SHADER_EXT 0x95A0 +#define GL_REFERENCED_BY_TASK_SHADER_EXT 0x95A1 +#define GL_TASK_SHADER_INVOCATIONS_EXT 0x9753 +#define GL_MESH_SHADER_INVOCATIONS_EXT 0x9754 +#define GL_MESH_PRIMITIVES_GENERATED_EXT 0x9755 +#define GL_MESH_SHADER_BIT_EXT 0x00000040 +#define GL_TASK_SHADER_BIT_EXT 0x00000080 +#define GL_MESH_SUBROUTINE_EXT 0x957C +#define GL_TASK_SUBROUTINE_EXT 0x957D +#define GL_MESH_SUBROUTINE_UNIFORM_EXT 0x957E +#define GL_TASK_SUBROUTINE_UNIFORM_EXT 0x957F +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_EXT 0x959E +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_EXT 0x959F +typedef void (APIENTRYP PFNGLDRAWMESHTASKSEXTPROC) (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z); +typedef void (APIENTRYP PFNGLDRAWMESHTASKSINDIRECTEXTPROC) (GLintptr indirect); +typedef void (APIENTRYP PFNGLMULTIDRAWMESHTASKSINDIRECTEXTPROC) (GLintptr indirect, GLsizei drawcount, GLsizei stride); +typedef void (APIENTRYP PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTEXTPROC) (GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glDrawMeshTasksEXT (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z); +GLAPI void APIENTRY glDrawMeshTasksIndirectEXT (GLintptr indirect); +GLAPI void APIENTRY glMultiDrawMeshTasksIndirectEXT (GLintptr indirect, GLsizei drawcount, GLsizei stride); +GLAPI void APIENTRY glMultiDrawMeshTasksIndirectCountEXT (GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); +#endif +#endif /* GL_EXT_mesh_shader */ + #ifndef GL_EXT_multiview_tessellation_geometry_shader #define GL_EXT_multiview_tessellation_geometry_shader 1 #endif /* GL_EXT_multiview_tessellation_geometry_shader */ @@ -4657,6 +4778,26 @@ GLAPI void APIENTRY glFramebufferFetchBarrierEXT (void); #define GL_WEIGHTED_AVERAGE_EXT 0x9367 #endif /* GL_EXT_texture_filter_minmax */ +#ifndef GL_EXT_texture_sRGB +#define GL_EXT_texture_sRGB 1 +#define GL_SRGB_EXT 0x8C40 +#define GL_SRGB8_EXT 0x8C41 +#define GL_SRGB_ALPHA_EXT 0x8C42 +#define GL_SRGB8_ALPHA8_EXT 0x8C43 +#define GL_SLUMINANCE_ALPHA_EXT 0x8C44 +#define GL_SLUMINANCE8_ALPHA8_EXT 0x8C45 +#define GL_SLUMINANCE_EXT 0x8C46 +#define GL_SLUMINANCE8_EXT 0x8C47 +#define GL_COMPRESSED_SRGB_EXT 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA_EXT 0x8C49 +#define GL_COMPRESSED_SLUMINANCE_EXT 0x8C4A +#define GL_COMPRESSED_SLUMINANCE_ALPHA_EXT 0x8C4B +#define GL_COMPRESSED_SRGB_S3TC_DXT1_EXT 0x8C4C +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT 0x8C4D +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT 0x8C4E +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT 0x8C4F +#endif /* GL_EXT_texture_sRGB */ + #ifndef GL_EXT_texture_sRGB_R8 #define GL_EXT_texture_sRGB_R8 1 #define GL_SR8_EXT 0x8FBD @@ -5838,6 +5979,10 @@ GLAPI void APIENTRY glTextureBarrierNV (void); #define GL_NV_texture_rectangle_compressed 1 #endif /* GL_NV_texture_rectangle_compressed */ +#ifndef GL_NV_uniform_buffer_std430_layout +#define GL_NV_uniform_buffer_std430_layout 1 +#endif /* GL_NV_uniform_buffer_std430_layout */ + #ifndef GL_NV_uniform_buffer_unified_memory #define GL_NV_uniform_buffer_unified_memory 1 #define GL_UNIFORM_BUFFER_UNIFIED_NV 0x936E @@ -5975,8 +6120,10 @@ GLAPI void APIENTRY glViewportSwizzleNV (GLuint index, GLenum swizzlex, GLenum s #define GL_MAX_VIEWS_OVR 0x9631 #define GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR 0x9633 typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); +typedef void (APIENTRYP PFNGLNAMEDFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glFramebufferTextureMultiviewOVR (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); +GLAPI void APIENTRY glNamedFramebufferTextureMultiviewOVR (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); #endif #endif /* GL_OVR_multiview */ diff --git a/libs/bgfx/3rdparty/khronos/gl/glext.h b/libs/bgfx/3rdparty/khronos/gl/glext.h index 61ff1b0..9eae435 100644 --- a/libs/bgfx/3rdparty/khronos/gl/glext.h +++ b/libs/bgfx/3rdparty/khronos/gl/glext.h @@ -6,7 +6,7 @@ extern "C" { #endif /* -** Copyright 2013-2020 The Khronos Group Inc. +** Copyright 2013-2025 The Khronos Group Inc. ** SPDX-License-Identifier: MIT ** ** This header is generated from the Khronos OpenGL / OpenGL ES XML @@ -32,7 +32,7 @@ extern "C" { #define GLAPI extern #endif -#define GL_GLEXT_VERSION 20220530 +#define GL_GLEXT_VERSION 20251023 #include @@ -5397,12 +5397,12 @@ typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severi typedef void (APIENTRYP PFNGLDEBUGMESSAGEENABLEAMDPROC) (GLenum category, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled); typedef void (APIENTRYP PFNGLDEBUGMESSAGEINSERTAMDPROC) (GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar *buf); typedef void (APIENTRYP PFNGLDEBUGMESSAGECALLBACKAMDPROC) (GLDEBUGPROCAMD callback, void *userParam); -typedef GLuint (APIENTRYP PFNGLGETDEBUGMESSAGELOGAMDPROC) (GLuint count, GLsizei bufSize, GLenum *categories, GLuint *severities, GLuint *ids, GLsizei *lengths, GLchar *message); +typedef GLuint (APIENTRYP PFNGLGETDEBUGMESSAGELOGAMDPROC) (GLuint count, GLsizei bufSize, GLenum *categories, GLenum *severities, GLuint *ids, GLsizei *lengths, GLchar *message); #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glDebugMessageEnableAMD (GLenum category, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled); GLAPI void APIENTRY glDebugMessageInsertAMD (GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar *buf); GLAPI void APIENTRY glDebugMessageCallbackAMD (GLDEBUGPROCAMD callback, void *userParam); -GLAPI GLuint APIENTRY glGetDebugMessageLogAMD (GLuint count, GLsizei bufSize, GLenum *categories, GLuint *severities, GLuint *ids, GLsizei *lengths, GLchar *message); +GLAPI GLuint APIENTRY glGetDebugMessageLogAMD (GLuint count, GLsizei bufSize, GLenum *categories, GLenum *severities, GLuint *ids, GLsizei *lengths, GLchar *message); #endif #endif /* GL_AMD_debug_output */ @@ -7358,6 +7358,47 @@ GLAPI void APIENTRY glFogCoordPointerEXT (GLenum type, GLsizei stride, const voi #endif #endif /* GL_EXT_fog_coord */ +#ifndef GL_EXT_fragment_shading_rate +#define GL_EXT_fragment_shading_rate 1 +#define GL_SHADING_RATE_1X1_PIXELS_EXT 0x96A6 +#define GL_SHADING_RATE_1X2_PIXELS_EXT 0x96A7 +#define GL_SHADING_RATE_2X1_PIXELS_EXT 0x96A8 +#define GL_SHADING_RATE_2X2_PIXELS_EXT 0x96A9 +#define GL_SHADING_RATE_1X4_PIXELS_EXT 0x96AA +#define GL_SHADING_RATE_4X1_PIXELS_EXT 0x96AB +#define GL_SHADING_RATE_4X2_PIXELS_EXT 0x96AC +#define GL_SHADING_RATE_2X4_PIXELS_EXT 0x96AD +#define GL_SHADING_RATE_4X4_PIXELS_EXT 0x96AE +#define GL_SHADING_RATE_EXT 0x96D0 +#define GL_SHADING_RATE_ATTACHMENT_EXT 0x96D1 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_EXT 0x96D2 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_EXT 0x96D3 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_EXT 0x96D4 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_EXT 0x96D5 +#define GL_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_EXT 0x96D6 +#define GL_MIN_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_WIDTH_EXT 0x96D7 +#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_WIDTH_EXT 0x96D8 +#define GL_MIN_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_HEIGHT_EXT 0x96D9 +#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_HEIGHT_EXT 0x96DA +#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_TEXEL_ASPECT_RATIO_EXT 0x96DB +#define GL_MAX_FRAGMENT_SHADING_RATE_ATTACHMENT_LAYERS_EXT 0x96DC +#define GL_FRAGMENT_SHADING_RATE_WITH_SHADER_DEPTH_STENCIL_WRITES_SUPPORTED_EXT 0x96DD +#define GL_FRAGMENT_SHADING_RATE_WITH_SAMPLE_MASK_SUPPORTED_EXT 0x96DE +#define GL_FRAGMENT_SHADING_RATE_ATTACHMENT_WITH_DEFAULT_FRAMEBUFFER_SUPPORTED_EXT 0x96DF +#define GL_FRAGMENT_SHADING_RATE_NON_TRIVIAL_COMBINERS_SUPPORTED_EXT 0x8F6F +#define GL_FRAGMENT_SHADING_RATE_PRIMITIVE_RATE_WITH_MULTI_VIEWPORT_SUPPORTED_EXT 0x9780 +typedef void (APIENTRYP PFNGLGETFRAGMENTSHADINGRATESEXTPROC) (GLsizei samples, GLsizei maxCount, GLsizei *count, GLenum *shadingRates); +typedef void (APIENTRYP PFNGLSHADINGRATEEXTPROC) (GLenum rate); +typedef void (APIENTRYP PFNGLSHADINGRATECOMBINEROPSEXTPROC) (GLenum combinerOp0, GLenum combinerOp1); +typedef void (APIENTRYP PFNGLFRAMEBUFFERSHADINGRATEEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint baseLayer, GLsizei numLayers, GLsizei texelWidth, GLsizei texelHeight); +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glGetFragmentShadingRatesEXT (GLsizei samples, GLsizei maxCount, GLsizei *count, GLenum *shadingRates); +GLAPI void APIENTRY glShadingRateEXT (GLenum rate); +GLAPI void APIENTRY glShadingRateCombinerOpsEXT (GLenum combinerOp0, GLenum combinerOp1); +GLAPI void APIENTRY glFramebufferShadingRateEXT (GLenum target, GLenum attachment, GLuint texture, GLint baseLayer, GLsizei numLayers, GLsizei texelWidth, GLsizei texelHeight); +#endif +#endif /* GL_EXT_fragment_shading_rate */ + #ifndef GL_EXT_framebuffer_blit #define GL_EXT_framebuffer_blit 1 #define GL_READ_FRAMEBUFFER_EXT 0x8CA8 @@ -7370,6 +7411,16 @@ GLAPI void APIENTRY glBlitFramebufferEXT (GLint srcX0, GLint srcY0, GLint srcX1, #endif #endif /* GL_EXT_framebuffer_blit */ +#ifndef GL_EXT_framebuffer_blit_layers +#define GL_EXT_framebuffer_blit_layers 1 +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERLAYERSEXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERLAYEREXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint srcLayer, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLint dstLayer, GLbitfield mask, GLenum filter); +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBlitFramebufferLayersEXT (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI void APIENTRY glBlitFramebufferLayerEXT (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint srcLayer, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLint dstLayer, GLbitfield mask, GLenum filter); +#endif +#endif /* GL_EXT_framebuffer_blit_layers */ + #ifndef GL_EXT_framebuffer_multisample #define GL_EXT_framebuffer_multisample 1 #define GL_RENDERBUFFER_SAMPLES_EXT 0x8CAB @@ -7806,6 +7857,86 @@ GLAPI void APIENTRY glImportMemoryWin32NameEXT (GLuint memory, GLuint64 size, GL #endif #endif /* GL_EXT_memory_object_win32 */ +#ifndef GL_EXT_mesh_shader +#define GL_EXT_mesh_shader 1 +#define GL_MESH_SHADER_EXT 0x9559 +#define GL_TASK_SHADER_EXT 0x955A +#define GL_MAX_MESH_UNIFORM_BLOCKS_EXT 0x8E60 +#define GL_MAX_MESH_TEXTURE_IMAGE_UNITS_EXT 0x8E61 +#define GL_MAX_MESH_IMAGE_UNIFORMS_EXT 0x8E62 +#define GL_MAX_MESH_UNIFORM_COMPONENTS_EXT 0x8E63 +#define GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_EXT 0x8E64 +#define GL_MAX_MESH_ATOMIC_COUNTERS_EXT 0x8E65 +#define GL_MAX_MESH_SHADER_STORAGE_BLOCKS_EXT 0x8E66 +#define GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_EXT 0x8E67 +#define GL_MAX_TASK_UNIFORM_BLOCKS_EXT 0x8E68 +#define GL_MAX_TASK_TEXTURE_IMAGE_UNITS_EXT 0x8E69 +#define GL_MAX_TASK_IMAGE_UNIFORMS_EXT 0x8E6A +#define GL_MAX_TASK_UNIFORM_COMPONENTS_EXT 0x8E6B +#define GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_EXT 0x8E6C +#define GL_MAX_TASK_ATOMIC_COUNTERS_EXT 0x8E6D +#define GL_MAX_TASK_SHADER_STORAGE_BLOCKS_EXT 0x8E6E +#define GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_EXT 0x8E6F +#define GL_MAX_TASK_WORK_GROUP_TOTAL_COUNT_EXT 0x9740 +#define GL_MAX_MESH_WORK_GROUP_TOTAL_COUNT_EXT 0x9741 +#define GL_MAX_MESH_WORK_GROUP_INVOCATIONS_EXT 0x9757 +#define GL_MAX_TASK_WORK_GROUP_INVOCATIONS_EXT 0x9759 +#define GL_MAX_TASK_PAYLOAD_SIZE_EXT 0x9742 +#define GL_MAX_TASK_SHARED_MEMORY_SIZE_EXT 0x9743 +#define GL_MAX_MESH_SHARED_MEMORY_SIZE_EXT 0x9744 +#define GL_MAX_TASK_PAYLOAD_AND_SHARED_MEMORY_SIZE_EXT 0x9745 +#define GL_MAX_MESH_PAYLOAD_AND_SHARED_MEMORY_SIZE_EXT 0x9746 +#define GL_MAX_MESH_OUTPUT_MEMORY_SIZE_EXT 0x9747 +#define GL_MAX_MESH_PAYLOAD_AND_OUTPUT_MEMORY_SIZE_EXT 0x9748 +#define GL_MAX_MESH_OUTPUT_VERTICES_EXT 0x9538 +#define GL_MAX_MESH_OUTPUT_PRIMITIVES_EXT 0x9756 +#define GL_MAX_MESH_OUTPUT_COMPONENTS_EXT 0x9749 +#define GL_MAX_MESH_OUTPUT_LAYERS_EXT 0x974A +#define GL_MAX_MESH_MULTIVIEW_VIEW_COUNT_EXT 0x9557 +#define GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_EXT 0x92DF +#define GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_EXT 0x9543 +#define GL_MAX_PREFERRED_TASK_WORK_GROUP_INVOCATIONS_EXT 0x974B +#define GL_MAX_PREFERRED_MESH_WORK_GROUP_INVOCATIONS_EXT 0x974C +#define GL_MESH_PREFERS_LOCAL_INVOCATION_VERTEX_OUTPUT_EXT 0x974D +#define GL_MESH_PREFERS_LOCAL_INVOCATION_PRIMITIVE_OUTPUT_EXT 0x974E +#define GL_MESH_PREFERS_COMPACT_VERTEX_OUTPUT_EXT 0x974F +#define GL_MESH_PREFERS_COMPACT_PRIMITIVE_OUTPUT_EXT 0x9750 +#define GL_MAX_TASK_WORK_GROUP_COUNT_EXT 0x9751 +#define GL_MAX_MESH_WORK_GROUP_COUNT_EXT 0x9752 +#define GL_MAX_MESH_WORK_GROUP_SIZE_EXT 0x9758 +#define GL_MAX_TASK_WORK_GROUP_SIZE_EXT 0x975A +#define GL_MESH_WORK_GROUP_SIZE_EXT 0x953E +#define GL_TASK_WORK_GROUP_SIZE_EXT 0x953F +#define GL_MESH_VERTICES_OUT_EXT 0x9579 +#define GL_MESH_PRIMITIVES_OUT_EXT 0x957A +#define GL_MESH_OUTPUT_TYPE_EXT 0x957B +#define GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_EXT 0x959C +#define GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_EXT 0x959D +#define GL_REFERENCED_BY_MESH_SHADER_EXT 0x95A0 +#define GL_REFERENCED_BY_TASK_SHADER_EXT 0x95A1 +#define GL_TASK_SHADER_INVOCATIONS_EXT 0x9753 +#define GL_MESH_SHADER_INVOCATIONS_EXT 0x9754 +#define GL_MESH_PRIMITIVES_GENERATED_EXT 0x9755 +#define GL_MESH_SHADER_BIT_EXT 0x00000040 +#define GL_TASK_SHADER_BIT_EXT 0x00000080 +#define GL_MESH_SUBROUTINE_EXT 0x957C +#define GL_TASK_SUBROUTINE_EXT 0x957D +#define GL_MESH_SUBROUTINE_UNIFORM_EXT 0x957E +#define GL_TASK_SUBROUTINE_UNIFORM_EXT 0x957F +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_EXT 0x959E +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_EXT 0x959F +typedef void (APIENTRYP PFNGLDRAWMESHTASKSEXTPROC) (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z); +typedef void (APIENTRYP PFNGLDRAWMESHTASKSINDIRECTEXTPROC) (GLintptr indirect); +typedef void (APIENTRYP PFNGLMULTIDRAWMESHTASKSINDIRECTEXTPROC) (GLintptr indirect, GLsizei drawcount, GLsizei stride); +typedef void (APIENTRYP PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTEXTPROC) (GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glDrawMeshTasksEXT (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z); +GLAPI void APIENTRY glDrawMeshTasksIndirectEXT (GLintptr indirect); +GLAPI void APIENTRY glMultiDrawMeshTasksIndirectEXT (GLintptr indirect, GLsizei drawcount, GLsizei stride); +GLAPI void APIENTRY glMultiDrawMeshTasksIndirectCountEXT (GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); +#endif +#endif /* GL_EXT_mesh_shader */ + #ifndef GL_EXT_misc_attribute #define GL_EXT_misc_attribute 1 #endif /* GL_EXT_misc_attribute */ @@ -9394,6 +9525,11 @@ GLAPI void APIENTRY glResizeBuffersMESA (void); #define GL_MESA_shader_integer_functions 1 #endif /* GL_MESA_shader_integer_functions */ +#ifndef GL_MESA_texture_const_bandwidth +#define GL_MESA_texture_const_bandwidth 1 +#define GL_CONST_BW_TILING_MESA 0x8BBE +#endif /* GL_MESA_texture_const_bandwidth */ + #ifndef GL_MESA_tile_raster_order #define GL_MESA_tile_raster_order 1 #define GL_TILE_RASTER_ORDER_FIXED_MESA 0x8BB8 @@ -10248,12 +10384,6 @@ typedef void (APIENTRYP PFNGLMULTITEXCOORD3HNVPROC) (GLenum target, GLhalfNV s, typedef void (APIENTRYP PFNGLMULTITEXCOORD3HVNVPROC) (GLenum target, const GLhalfNV *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD4HNVPROC) (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q); typedef void (APIENTRYP PFNGLMULTITEXCOORD4HVNVPROC) (GLenum target, const GLhalfNV *v); -typedef void (APIENTRYP PFNGLFOGCOORDHNVPROC) (GLhalfNV fog); -typedef void (APIENTRYP PFNGLFOGCOORDHVNVPROC) (const GLhalfNV *fog); -typedef void (APIENTRYP PFNGLSECONDARYCOLOR3HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue); -typedef void (APIENTRYP PFNGLSECONDARYCOLOR3HVNVPROC) (const GLhalfNV *v); -typedef void (APIENTRYP PFNGLVERTEXWEIGHTHNVPROC) (GLhalfNV weight); -typedef void (APIENTRYP PFNGLVERTEXWEIGHTHVNVPROC) (const GLhalfNV *weight); typedef void (APIENTRYP PFNGLVERTEXATTRIB1HNVPROC) (GLuint index, GLhalfNV x); typedef void (APIENTRYP PFNGLVERTEXATTRIB1HVNVPROC) (GLuint index, const GLhalfNV *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB2HNVPROC) (GLuint index, GLhalfNV x, GLhalfNV y); @@ -10266,6 +10396,12 @@ typedef void (APIENTRYP PFNGLVERTEXATTRIBS1HVNVPROC) (GLuint index, GLsizei n, c typedef void (APIENTRYP PFNGLVERTEXATTRIBS2HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS3HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS4HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v); +typedef void (APIENTRYP PFNGLFOGCOORDHNVPROC) (GLhalfNV fog); +typedef void (APIENTRYP PFNGLFOGCOORDHVNVPROC) (const GLhalfNV *fog); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3HVNVPROC) (const GLhalfNV *v); +typedef void (APIENTRYP PFNGLVERTEXWEIGHTHNVPROC) (GLhalfNV weight); +typedef void (APIENTRYP PFNGLVERTEXWEIGHTHVNVPROC) (const GLhalfNV *weight); #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glVertex2hNV (GLhalfNV x, GLhalfNV y); GLAPI void APIENTRY glVertex2hvNV (const GLhalfNV *v); @@ -10295,12 +10431,6 @@ GLAPI void APIENTRY glMultiTexCoord3hNV (GLenum target, GLhalfNV s, GLhalfNV t, GLAPI void APIENTRY glMultiTexCoord3hvNV (GLenum target, const GLhalfNV *v); GLAPI void APIENTRY glMultiTexCoord4hNV (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q); GLAPI void APIENTRY glMultiTexCoord4hvNV (GLenum target, const GLhalfNV *v); -GLAPI void APIENTRY glFogCoordhNV (GLhalfNV fog); -GLAPI void APIENTRY glFogCoordhvNV (const GLhalfNV *fog); -GLAPI void APIENTRY glSecondaryColor3hNV (GLhalfNV red, GLhalfNV green, GLhalfNV blue); -GLAPI void APIENTRY glSecondaryColor3hvNV (const GLhalfNV *v); -GLAPI void APIENTRY glVertexWeighthNV (GLhalfNV weight); -GLAPI void APIENTRY glVertexWeighthvNV (const GLhalfNV *weight); GLAPI void APIENTRY glVertexAttrib1hNV (GLuint index, GLhalfNV x); GLAPI void APIENTRY glVertexAttrib1hvNV (GLuint index, const GLhalfNV *v); GLAPI void APIENTRY glVertexAttrib2hNV (GLuint index, GLhalfNV x, GLhalfNV y); @@ -10313,6 +10443,12 @@ GLAPI void APIENTRY glVertexAttribs1hvNV (GLuint index, GLsizei n, const GLhalfN GLAPI void APIENTRY glVertexAttribs2hvNV (GLuint index, GLsizei n, const GLhalfNV *v); GLAPI void APIENTRY glVertexAttribs3hvNV (GLuint index, GLsizei n, const GLhalfNV *v); GLAPI void APIENTRY glVertexAttribs4hvNV (GLuint index, GLsizei n, const GLhalfNV *v); +GLAPI void APIENTRY glFogCoordhNV (GLhalfNV fog); +GLAPI void APIENTRY glFogCoordhvNV (const GLhalfNV *fog); +GLAPI void APIENTRY glSecondaryColor3hNV (GLhalfNV red, GLhalfNV green, GLhalfNV blue); +GLAPI void APIENTRY glSecondaryColor3hvNV (const GLhalfNV *v); +GLAPI void APIENTRY glVertexWeighthNV (GLhalfNV weight); +GLAPI void APIENTRY glVertexWeighthvNV (const GLhalfNV *weight); #endif #endif /* GL_NV_half_float */ @@ -11449,6 +11585,10 @@ GLAPI void APIENTRY glDrawTransformFeedbackNV (GLenum mode, GLuint id); #endif #endif /* GL_NV_transform_feedback2 */ +#ifndef GL_NV_uniform_buffer_std430_layout +#define GL_NV_uniform_buffer_std430_layout 1 +#endif /* GL_NV_uniform_buffer_std430_layout */ + #ifndef GL_NV_uniform_buffer_unified_memory #define GL_NV_uniform_buffer_unified_memory 1 #define GL_UNIFORM_BUFFER_UNIFIED_NV 0x936E @@ -11964,8 +12104,10 @@ GLAPI void APIENTRY glViewportSwizzleNV (GLuint index, GLenum swizzlex, GLenum s #define GL_MAX_VIEWS_OVR 0x9631 #define GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR 0x9633 typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); +typedef void (APIENTRYP PFNGLNAMEDFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glFramebufferTextureMultiviewOVR (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); +GLAPI void APIENTRY glNamedFramebufferTextureMultiviewOVR (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); #endif #endif /* GL_OVR_multiview */ diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_av1std.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_av1std.h index 347e0d2..932d0f6 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_av1std.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_av1std.h @@ -22,27 +22,27 @@ extern "C" { // vulkan_video_codec_av1std is a preprocessor guard. Do not pass it to API calls. #define vulkan_video_codec_av1std 1 #include "vulkan_video_codecs_common.h" -#define STD_VIDEO_AV1_NUM_REF_FRAMES 8 -#define STD_VIDEO_AV1_REFS_PER_FRAME 7 -#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8 -#define STD_VIDEO_AV1_MAX_TILE_COLS 64 -#define STD_VIDEO_AV1_MAX_TILE_ROWS 64 -#define STD_VIDEO_AV1_MAX_SEGMENTS 8 -#define STD_VIDEO_AV1_SEG_LVL_MAX 8 -#define STD_VIDEO_AV1_PRIMARY_REF_NONE 7 -#define STD_VIDEO_AV1_SELECT_INTEGER_MV 2 -#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2 -#define STD_VIDEO_AV1_SKIP_MODE_FRAMES 2 -#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4 -#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2 -#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8 -#define STD_VIDEO_AV1_MAX_NUM_PLANES 3 -#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6 -#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS 14 -#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS 10 -#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS 10 -#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA 24 -#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA 25 +#define STD_VIDEO_AV1_NUM_REF_FRAMES 8U +#define STD_VIDEO_AV1_REFS_PER_FRAME 7U +#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8U +#define STD_VIDEO_AV1_MAX_TILE_COLS 64U +#define STD_VIDEO_AV1_MAX_TILE_ROWS 64U +#define STD_VIDEO_AV1_MAX_SEGMENTS 8U +#define STD_VIDEO_AV1_SEG_LVL_MAX 8U +#define STD_VIDEO_AV1_PRIMARY_REF_NONE 7U +#define STD_VIDEO_AV1_SELECT_INTEGER_MV 2U +#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2U +#define STD_VIDEO_AV1_SKIP_MODE_FRAMES 2U +#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4U +#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2U +#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8U +#define STD_VIDEO_AV1_MAX_NUM_PLANES 3U +#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6U +#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS 14U +#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS 10U +#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS 10U +#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA 24U +#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA 25U typedef enum StdVideoAV1Profile { STD_VIDEO_AV1_PROFILE_MAIN = 0, @@ -144,7 +144,7 @@ typedef enum StdVideoAV1ColorPrimaries { STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12, STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22, STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF, - // STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED is a deprecated alias + // STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED is a legacy alias STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED, STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF } StdVideoAV1ColorPrimaries; diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h264std.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h264std.h index 6fd3810..7e8da7d 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h264std.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h264std.h @@ -22,14 +22,14 @@ extern "C" { // vulkan_video_codec_h264std is a preprocessor guard. Do not pass it to API calls. #define vulkan_video_codec_h264std 1 #include "vulkan_video_codecs_common.h" -#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 -#define STD_VIDEO_H264_NO_REFERENCE_PICTURE 0xFF +#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32U +#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6U +#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16U +#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 6U +#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64U +#define STD_VIDEO_H264_MAX_NUM_LIST_REF 32U +#define STD_VIDEO_H264_MAX_CHROMA_PLANES 2U +#define STD_VIDEO_H264_NO_REFERENCE_PICTURE 0xFFU typedef enum StdVideoH264ChromaFormatIdc { STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0, diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h264std_decode.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h264std_decode.h index d6a90b4..01facd7 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h264std_decode.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h264std_decode.h @@ -27,7 +27,7 @@ extern "C" { #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" -#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2 +#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2U typedef enum StdVideoDecodeH264FieldOrderCount { STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0, diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h265std.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h265std.h index 3eecd60..20e97e3 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h265std.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h265std.h @@ -22,29 +22,29 @@ extern "C" { // vulkan_video_codec_h265std is a preprocessor guard. Do not pass it to API calls. #define vulkan_video_codec_h265std 1 #include "vulkan_video_codecs_common.h" -#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32 -#define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7 -#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_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_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3 -#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128 -#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_DPB_SIZE 16 -#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32 -#define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16 -#define STD_VIDEO_H265_MAX_DELTA_POC 48 -#define STD_VIDEO_H265_NO_REFERENCE_PICTURE 0xFF +#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32U +#define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7U +#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6U +#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16U +#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6U +#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS 64U +#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS 6U +#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64U +#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2U +#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64U +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6U +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19U +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21U +#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3U +#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128U +#define STD_VIDEO_H265_MAX_NUM_LIST_REF 15U +#define STD_VIDEO_H265_MAX_CHROMA_PLANES 2U +#define STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS 64U +#define STD_VIDEO_H265_MAX_DPB_SIZE 16U +#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32U +#define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16U +#define STD_VIDEO_H265_MAX_DELTA_POC 48U +#define STD_VIDEO_H265_NO_REFERENCE_PICTURE 0xFFU typedef enum StdVideoH265ChromaFormatIdc { STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0, diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h265std_decode.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h265std_decode.h index a9e1a09..a2ddcaa 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h265std_decode.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_h265std_decode.h @@ -27,7 +27,7 @@ extern "C" { #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" -#define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8 +#define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8U typedef struct StdVideoDecodeH265PictureInfoFlags { uint32_t IrapPicFlag : 1; uint32_t IdrPicFlag : 1; diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_vp9std.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_vp9std.h index 61743cd..3d10e39 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_vp9std.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vk_video/vulkan_video_codec_vp9std.h @@ -22,14 +22,14 @@ extern "C" { // vulkan_video_codec_vp9std is a preprocessor guard. Do not pass it to API calls. #define vulkan_video_codec_vp9std 1 #include "vulkan_video_codecs_common.h" -#define STD_VIDEO_VP9_NUM_REF_FRAMES 8 -#define STD_VIDEO_VP9_REFS_PER_FRAME 3 -#define STD_VIDEO_VP9_MAX_REF_FRAMES 4 -#define STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS 2 -#define STD_VIDEO_VP9_MAX_SEGMENTS 8 -#define STD_VIDEO_VP9_SEG_LVL_MAX 4 -#define STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS 7 -#define STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB 3 +#define STD_VIDEO_VP9_NUM_REF_FRAMES 8U +#define STD_VIDEO_VP9_REFS_PER_FRAME 3U +#define STD_VIDEO_VP9_MAX_REF_FRAMES 4U +#define STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS 2U +#define STD_VIDEO_VP9_MAX_SEGMENTS 8U +#define STD_VIDEO_VP9_SEG_LVL_MAX 4U +#define STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS 7U +#define STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB 3U typedef enum StdVideoVP9Profile { STD_VIDEO_VP9_PROFILE_0 = 0, diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan.h index 9060581..9457a52 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan.h @@ -96,4 +96,8 @@ #include "vulkan_beta.h" #endif +#ifdef VK_USE_PLATFORM_OHOS +#include "vulkan_ohos.h" +#endif + #endif // VULKAN_H_ diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_android.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_android.h index a2ba3ad..9b1e493 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_android.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_android.h @@ -35,12 +35,14 @@ typedef struct VkAndroidSurfaceCreateInfoKHR { typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif +#endif // VK_ANDROID_external_memory_android_hardware_buffer is a preprocessor guard. Do not pass it to API calls. @@ -109,16 +111,20 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(Vk typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer); #endif +#endif // VK_ANDROID_external_format_resolve is a preprocessor guard. Do not pass it to API calls. diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_beta.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_beta.h index 4b4826e..0f48f87 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_beta.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_beta.h @@ -120,7 +120,7 @@ typedef struct VkPipelineShaderStageNodeCreateInfoAMDX { uint32_t index; } VkPipelineShaderStageNodeCreateInfoAMDX; -typedef VkResult (VKAPI_PTR *PFN_vkCreateExecutionGraphPipelinesAMDX)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkCreateExecutionGraphPipelinesAMDX)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineScratchSizeAMDX)(VkDevice device, VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo); typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineNodeIndexAMDX)(VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex); typedef void (VKAPI_PTR *PFN_vkCmdInitializeGraphScratchMemoryAMDX)(VkCommandBuffer commandBuffer, VkPipeline executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize); @@ -129,6 +129,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectAMDX)(VkCommandBuffer typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectCountAMDX)(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateExecutionGraphPipelinesAMDX( VkDevice device, VkPipelineCache pipelineCache, @@ -136,42 +137,55 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateExecutionGraphPipelinesAMDX( const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineScratchSizeAMDX( VkDevice device, VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineNodeIndexAMDX( VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdInitializeGraphScratchMemoryAMDX( VkCommandBuffer commandBuffer, VkPipeline executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphAMDX( VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectAMDX( VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectCountAMDX( VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo); #endif +#endif // VK_NV_cuda_kernel_launch is a preprocessor guard. Do not pass it to API calls. @@ -232,38 +246,50 @@ typedef void (VKAPI_PTR *PFN_vkDestroyCudaFunctionNV)(VkDevice device, VkCudaFun typedef void (VKAPI_PTR *PFN_vkCmdCudaLaunchKernelNV)(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaModuleNV( VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetCudaModuleCacheNV( VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaFunctionNV( VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyCudaModuleNV( VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyCudaFunctionNV( VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCudaLaunchKernelNV( VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo); #endif +#endif // VK_NV_displacement_micromap is a preprocessor guard. Do not pass it to API calls. @@ -311,6 +337,37 @@ typedef struct VkAccelerationStructureTrianglesDisplacementMicromapNV { } VkAccelerationStructureTrianglesDisplacementMicromapNV; + +// VK_AMDX_dense_geometry_format is a preprocessor guard. Do not pass it to API calls. +#define VK_AMDX_dense_geometry_format 1 +#define VK_AMDX_DENSE_GEOMETRY_FORMAT_SPEC_VERSION 1 +#define VK_AMDX_DENSE_GEOMETRY_FORMAT_EXTENSION_NAME "VK_AMDX_dense_geometry_format" +#define VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX 128U +#define VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX 128U + +typedef enum VkCompressedTriangleFormatAMDX { + VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX = 0, + VK_COMPRESSED_TRIANGLE_FORMAT_MAX_ENUM_AMDX = 0x7FFFFFFF +} VkCompressedTriangleFormatAMDX; +typedef struct VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX { + VkStructureType sType; + void* pNext; + VkBool32 denseGeometryFormat; +} VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX; + +typedef struct VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR compressedData; + VkDeviceSize dataSize; + uint32_t numTriangles; + uint32_t numVertices; + uint32_t maxPrimitiveIndex; + uint32_t maxGeometryIndex; + VkCompressedTriangleFormatAMDX format; +} VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX; + + #ifdef __cplusplus } #endif diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_core.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_core.h index fa027c8..78c9957 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_core.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_core.h @@ -62,39 +62,35 @@ extern "C" { #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_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 +//#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 317 +#define VK_HEADER_VERSION 331 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) -// VK_MAKE_VERSION is deprecated, but no reason was given in the API XML -// 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))) -// VK_VERSION_MAJOR is deprecated, but no reason was given in the API XML -// DEPRECATED: This define is deprecated. VK_API_VERSION_MAJOR should be used instead. + #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22U) -// VK_VERSION_MINOR is deprecated, but no reason was given in the API XML -// DEPRECATED: This define is deprecated. VK_API_VERSION_MINOR should be used instead. + #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU) -// VK_VERSION_PATCH is deprecated, but no reason was given in the API XML -// 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) >> 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) +// 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 + typedef uint32_t VkBool32; typedef uint64_t VkDeviceAddress; typedef uint64_t VkDeviceSize; @@ -110,28 +106,26 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) VK_DEFINE_HANDLE(VkCommandBuffer) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) 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_ATTACHMENT_UNUSED (~0U) #define VK_FALSE 0U #define VK_LOD_CLAMP_NONE 1000.0F #define VK_QUEUE_FAMILY_IGNORED (~0U) #define VK_REMAINING_ARRAY_LAYERS (~0U) #define VK_REMAINING_MIP_LEVELS (~0U) -#define VK_SUBPASS_EXTERNAL (~0U) #define VK_TRUE 1U #define VK_WHOLE_SIZE (~0ULL) #define VK_MAX_MEMORY_TYPES 32U @@ -140,6 +134,8 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) #define VK_MAX_EXTENSION_NAME_SIZE 256U #define VK_MAX_DESCRIPTION_SIZE 256U #define VK_MAX_MEMORY_HEAPS 16U +#define VK_ATTACHMENT_UNUSED (~0U) +#define VK_SUBPASS_EXTERNAL (~0U) typedef enum VkResult { VK_SUCCESS = 0, @@ -161,10 +157,11 @@ typedef enum VkResult { VK_ERROR_FORMAT_NOT_SUPPORTED = -11, VK_ERROR_FRAGMENTED_POOL = -12, VK_ERROR_UNKNOWN = -13, + VK_ERROR_VALIDATION_FAILED = -1000011001, VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, - VK_ERROR_FRAGMENTATION = -1000161000, VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, + VK_ERROR_FRAGMENTATION = -1000161000, VK_PIPELINE_COMPILE_REQUIRED = 1000297000, VK_ERROR_NOT_PERMITTED = -1000174001, VK_ERROR_SURFACE_LOST_KHR = -1000000000, @@ -172,7 +169,6 @@ typedef enum VkResult { VK_SUBOPTIMAL_KHR = 1000001003, VK_ERROR_OUT_OF_DATE_KHR = -1000001004, 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, @@ -191,6 +187,7 @@ typedef enum VkResult { VK_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, VK_PIPELINE_BINARY_MISSING_KHR = 1000483000, VK_ERROR_NOT_ENOUGH_SPACE_KHR = -1000483000, + VK_ERROR_VALIDATION_FAILED_EXT = VK_ERROR_VALIDATION_FAILED, 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, @@ -200,7 +197,7 @@ typedef enum VkResult { VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, VK_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, - // VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT is a deprecated alias + // VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT is a legacy alias VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = VK_INCOMPATIBLE_SHADER_BINARY_EXT, VK_RESULT_MAX_ENUM = 0x7FFFFFFF } VkResult; @@ -255,14 +252,11 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, @@ -284,25 +278,11 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, - VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, - VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, - VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, - VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, - VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, @@ -317,23 +297,46 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, - VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, - VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, - VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, + VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, + VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, @@ -342,44 +345,34 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, - VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, - VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, - VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, - VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, - VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, - VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, - VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, - VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES = 53, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES = 54, - VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES = 1000245000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000, VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO = 1000295001, VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO = 1000295002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000, VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 = 1000314000, VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 = 1000314001, VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 = 1000314002, @@ -388,19 +381,25 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO = 1000314005, VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO = 1000314006, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000, VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 = 1000337000, VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 = 1000337001, VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 = 1000337002, VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 = 1000337003, - VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 = 1000337004, - VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 = 1000337005, VK_STRUCTURE_TYPE_BUFFER_COPY_2 = 1000337006, VK_STRUCTURE_TYPE_IMAGE_COPY_2 = 1000337007, - VK_STRUCTURE_TYPE_IMAGE_BLIT_2 = 1000337008, VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 = 1000337009, - VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 = 1000337010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001, + VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002, + VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003, + VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES = 1000225000, VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO = 1000225001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES = 1000225002, @@ -408,60 +407,35 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES = 1000138001, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK = 1000138002, VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO = 1000138003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001, + VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 = 1000337004, + VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 = 1000337005, + VK_STRUCTURE_TYPE_IMAGE_BLIT_2 = 1000337008, + VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 = 1000337010, VK_STRUCTURE_TYPE_RENDERING_INFO = 1000044000, VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO = 1000044001, VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO = 1000044002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES = 1000044003, VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO = 1000044004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001, - VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002, - VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES = 55, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES = 56, VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO = 1000174000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES = 1000388000, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES = 1000388001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES = 1000416000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES = 1000528000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES = 1000544000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES = 1000259000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO = 1000259001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES = 1000259002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES = 1000525000, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO = 1000190001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES = 1000190002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES = 1000265000, VK_STRUCTURE_TYPE_MEMORY_MAP_INFO = 1000271000, VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO = 1000271001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES = 1000470000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES = 1000470001, - VK_STRUCTURE_TYPE_RENDERING_AREA_INFO = 1000470003, VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO = 1000470004, VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2 = 1000338002, VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2 = 1000338003, - VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO = 1000470005, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO = 1000470006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES = 1000080000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES = 1000232000, - VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO = 1000232001, - VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO = 1000232002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES = 1000545000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES = 1000545001, VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS = 1000545002, - VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO = 1000545003, - VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO = 1000545004, - VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO = 1000545005, - VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO = 1000545006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES = 1000466000, - VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO = 1000068000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES = 1000068001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES = 1000068002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES = 1000270000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES = 1000270001, VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY = 1000270002, @@ -472,6 +446,29 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO = 1000270007, VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE = 1000270008, VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY = 1000270009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES = 1000416000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES = 1000528000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES = 1000544000, + VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO = 1000470005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES = 1000080000, + VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO = 1000545003, + VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO = 1000545004, + VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO = 1000545005, + VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO = 1000545006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES = 1000466000, + VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO = 1000068000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES = 1000068001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES = 1000068002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES = 1000259000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO = 1000259001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES = 1000259002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES = 1000525000, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO = 1000190001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES = 1000190002, + VK_STRUCTURE_TYPE_RENDERING_AREA_INFO = 1000470003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES = 1000232000, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO = 1000232001, + VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO = 1000232002, VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, @@ -811,15 +808,6 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT = 1000272001, VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT = 1000272002, 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, @@ -947,7 +935,6 @@ typedef enum VkStructureType { 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, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT = 1000361000, VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000, VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001, VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002, @@ -982,6 +969,11 @@ typedef enum VkStructureType { 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_SHADER_UNTYPED_POINTERS_FEATURES_KHR = 1000387000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE = 1000390000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE = 1000390001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE = 1000390002, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE = 1000390003, 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, @@ -1030,9 +1022,6 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM = 1000424003, VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM = 1000424004, 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_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV = 1000428000, VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV = 1000428001, VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV = 1000428002, @@ -1047,6 +1036,12 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT = 1000451000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT = 1000451001, + VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS = 1000452000, + VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS = 1000452001, + VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS = 1000452002, + VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS = 1000452003, + VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS = 1000452004, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS = 1000452005, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT = 1000453000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001, @@ -1099,6 +1094,12 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD = 1000476000, VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD = 1000476001, VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD = 1000476002, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX = 1000478000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX = 1000478001, +#endif VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR = 1000479000, VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR = 1000479001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR = 1000479002, @@ -1123,6 +1124,15 @@ typedef enum VkStructureType { 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_SURFACE_PRESENT_MODE_KHR = 1000274000, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR = 1000274001, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR = 1000274002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR = 1000275000, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR = 1000275001, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR = 1000275002, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR = 1000275003, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR = 1000275004, + VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR = 1000275005, 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, @@ -1153,6 +1163,26 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR = 1000506000, VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM = 1000507000, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM = 1000507001, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM = 1000507002, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM = 1000507003, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM = 1000507004, + VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM = 1000507005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM = 1000507006, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM = 1000507007, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM = 1000507008, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM = 1000507009, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM = 1000507010, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM = 1000507011, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM = 1000507012, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM = 1000507013, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM = 1000507014, + VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM = 1000507016, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM = 1000507017, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM = 1000507018, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM = 1000507019, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM = 1000507015, 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_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR = 1000201000, @@ -1207,8 +1237,20 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM = 1000547002, VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM = 1000547003, VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM = 1000547004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR = 1000549000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR = 1000426001, + VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR = 1000549002, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR = 1000549003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT = 1000427000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT = 1000427001, + VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT = 1000550002, VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV = 1000551000, VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV = 1000551001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR = 1000552000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR = 1000552001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR = 1000552002, + VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR = 1000552003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR = 1000552004, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553000, VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553001, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR = 1000553002, @@ -1268,6 +1310,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = 1000575001, VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR = 1000579000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000, VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = 1000582001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR = 1000584000, @@ -1277,6 +1320,10 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586001, VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586002, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586003, + VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS = 1000685000, + VK_STRUCTURE_TYPE_NATIVE_BUFFER_OHOS = 1000453001, + VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_OHOS = 1000453002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_OHOS = 1000453003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI = 1000590000, VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI = 1000590001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV = 1000593000, @@ -1287,8 +1334,16 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT = 1000602001, VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT = 1000602002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR = 1000421000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM = 1000605000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM = 1000605001, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM = 1000605002, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM = 1000605003, + VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM = 1000605004, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM = 1000609000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE = 1000611000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE = 1000611001, + VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE = 1000611002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR = 1000286000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR = 1000286001, #ifdef VK_ENABLE_BETA_EXTENSIONS @@ -1300,11 +1355,19 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT = 1000425000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT = 1000425001, VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT = 1000425002, - VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT = 1000619003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT = 1000620000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR = 1000361000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT = 1000627000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR = 1000630000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR = 1000630001, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR = 1000630002, + VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR = 1000619003, + VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR = 1000630004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC = 1000637000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT = 1000642000, 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 is a deprecated alias + // VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a legacy alias VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_INFO, VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, @@ -1352,7 +1415,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, - // VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT is a deprecated alias + // VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT is a legacy alias VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, @@ -1427,7 +1490,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, - // VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL is a deprecated alias + // VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL is a legacy alias VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, @@ -1468,6 +1531,15 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY, VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO, VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR, + VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, @@ -1505,6 +1577,7 @@ typedef enum VkStructureType { 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_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR, 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, VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES, @@ -1517,6 +1590,9 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT, VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES, @@ -1543,14 +1619,10 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO, VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO, VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO, + VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR, 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, @@ -1624,8 +1696,8 @@ typedef enum VkObjectType { VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, VK_OBJECT_TYPE_FRAMEBUFFER = 24, VK_OBJECT_TYPE_COMMAND_POOL = 25, - VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000, VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, @@ -1656,6 +1728,7 @@ typedef enum VkObjectType { VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, VK_OBJECT_TYPE_SHADER_EXT = 1000482000, VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = 1000483000, + VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM = 1000507000, VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV = 1000556000, VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT = 1000572000, VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT = 1000572001, @@ -2011,7 +2084,7 @@ typedef enum VkFormat { VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM, VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16, VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16, - // VK_FORMAT_R16G16_S10_5_NV is a deprecated alias + // VK_FORMAT_R16G16_S10_5_NV is a legacy alias VK_FORMAT_R16G16_S10_5_NV = VK_FORMAT_R16G16_SFIXED5_NV, VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR = VK_FORMAT_A1B5G5R5_UNORM_PACK16, VK_FORMAT_A8_UNORM_KHR = VK_FORMAT_A8_UNORM, @@ -2090,50 +2163,159 @@ typedef enum VkImageViewType { VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF } VkImageViewType; -typedef enum VkBlendFactor { - VK_BLEND_FACTOR_ZERO = 0, - VK_BLEND_FACTOR_ONE = 1, - VK_BLEND_FACTOR_SRC_COLOR = 2, - VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, - VK_BLEND_FACTOR_DST_COLOR = 4, - VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, - VK_BLEND_FACTOR_SRC_ALPHA = 6, - VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, - VK_BLEND_FACTOR_DST_ALPHA = 8, - VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, - VK_BLEND_FACTOR_CONSTANT_COLOR = 10, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, - VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, - VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, - VK_BLEND_FACTOR_SRC1_COLOR = 15, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, - VK_BLEND_FACTOR_SRC1_ALPHA = 17, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, - VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF -} VkBlendFactor; +typedef enum VkCommandBufferLevel { + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferLevel; -typedef enum VkBlendOp { - VK_BLEND_OP_ADD = 0, - VK_BLEND_OP_SUBTRACT = 1, - VK_BLEND_OP_REVERSE_SUBTRACT = 2, - VK_BLEND_OP_MIN = 3, - VK_BLEND_OP_MAX = 4, - VK_BLEND_OP_ZERO_EXT = 1000148000, - VK_BLEND_OP_SRC_EXT = 1000148001, - VK_BLEND_OP_DST_EXT = 1000148002, - VK_BLEND_OP_SRC_OVER_EXT = 1000148003, - VK_BLEND_OP_DST_OVER_EXT = 1000148004, - VK_BLEND_OP_SRC_IN_EXT = 1000148005, - VK_BLEND_OP_DST_IN_EXT = 1000148006, - VK_BLEND_OP_SRC_OUT_EXT = 1000148007, - VK_BLEND_OP_DST_OUT_EXT = 1000148008, - VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, - VK_BLEND_OP_DST_ATOP_EXT = 1000148010, - VK_BLEND_OP_XOR_EXT = 1000148011, - VK_BLEND_OP_MULTIPLY_EXT = 1000148012, - VK_BLEND_OP_SCREEN_EXT = 1000148013, - VK_BLEND_OP_OVERLAY_EXT = 1000148014, +typedef enum VkIndexType { + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_UINT8 = 1000265000, + VK_INDEX_TYPE_NONE_KHR = 1000165000, + VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR, + VK_INDEX_TYPE_UINT8_EXT = VK_INDEX_TYPE_UINT8, + VK_INDEX_TYPE_UINT8_KHR = VK_INDEX_TYPE_UINT8, + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkIndexType; + +typedef enum VkPipelineCacheHeaderVersion { + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheHeaderVersion; + +typedef enum VkBorderColor { + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003, + VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004, + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} VkBorderColor; + +typedef enum VkFilter { + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_CUBIC_EXT = 1000015000, + VK_FILTER_CUBIC_IMG = VK_FILTER_CUBIC_EXT, + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} VkFilter; + +typedef enum VkSamplerAddressMode { + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + // VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR is a legacy alias + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, + VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerAddressMode; + +typedef enum VkSamplerMipmapMode { + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerMipmapMode; + +typedef enum VkCompareOp { + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} VkCompareOp; + +typedef enum VkDescriptorType { + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000, + VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, + VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, + VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000, + VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001, + VK_DESCRIPTOR_TYPE_TENSOR_ARM = 1000460000, + VK_DESCRIPTOR_TYPE_MUTABLE_EXT = 1000351000, + VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV = 1000570000, + 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; + +typedef enum VkPipelineBindPoint { + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX = 1000134000, +#endif + VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000, + VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003, + VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM = 1000507000, + VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} VkPipelineBindPoint; + +typedef enum VkBlendFactor { + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} VkBlendFactor; + +typedef enum VkBlendOp { + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_ZERO_EXT = 1000148000, + VK_BLEND_OP_SRC_EXT = 1000148001, + VK_BLEND_OP_DST_EXT = 1000148002, + VK_BLEND_OP_SRC_OVER_EXT = 1000148003, + VK_BLEND_OP_DST_OVER_EXT = 1000148004, + VK_BLEND_OP_SRC_IN_EXT = 1000148005, + VK_BLEND_OP_DST_IN_EXT = 1000148006, + VK_BLEND_OP_SRC_OUT_EXT = 1000148007, + VK_BLEND_OP_DST_OUT_EXT = 1000148008, + VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, + VK_BLEND_OP_DST_ATOP_EXT = 1000148010, + VK_BLEND_OP_XOR_EXT = 1000148011, + VK_BLEND_OP_MULTIPLY_EXT = 1000148012, + VK_BLEND_OP_SCREEN_EXT = 1000148013, + VK_BLEND_OP_OVERLAY_EXT = 1000148014, VK_BLEND_OP_DARKEN_EXT = 1000148015, VK_BLEND_OP_LIGHTEN_EXT = 1000148016, VK_BLEND_OP_COLORDODGE_EXT = 1000148017, @@ -2168,18 +2350,6 @@ typedef enum VkBlendOp { VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF } VkBlendOp; -typedef enum VkCompareOp { - VK_COMPARE_OP_NEVER = 0, - VK_COMPARE_OP_LESS = 1, - VK_COMPARE_OP_EQUAL = 2, - VK_COMPARE_OP_LESS_OR_EQUAL = 3, - VK_COMPARE_OP_GREATER = 4, - VK_COMPARE_OP_NOT_EQUAL = 5, - VK_COMPARE_OP_GREATER_OR_EQUAL = 6, - VK_COMPARE_OP_ALWAYS = 7, - VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF -} VkCompareOp; - typedef enum VkDynamicState { VK_DYNAMIC_STATE_VIEWPORT = 0, VK_DYNAMIC_STATE_SCISSOR = 1, @@ -2341,68 +2511,6 @@ typedef enum VkLogicOp { VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF } VkLogicOp; -typedef enum VkBorderColor { - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, - VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, - VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, - VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, - VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, - VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, - VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003, - VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004, - VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF -} VkBorderColor; - -typedef enum VkFilter { - VK_FILTER_NEAREST = 0, - VK_FILTER_LINEAR = 1, - VK_FILTER_CUBIC_EXT = 1000015000, - VK_FILTER_CUBIC_IMG = VK_FILTER_CUBIC_EXT, - VK_FILTER_MAX_ENUM = 0x7FFFFFFF -} VkFilter; - -typedef enum VkSamplerAddressMode { - VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, - VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, - VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, - // VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR is a deprecated alias - VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, - VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerAddressMode; - -typedef enum VkSamplerMipmapMode { - VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, - VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, - VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerMipmapMode; - -typedef enum VkDescriptorType { - VK_DESCRIPTOR_TYPE_SAMPLER = 0, - VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, - VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, - VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, - VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, - VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, - VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, - VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000, - VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, - VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, - VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000, - VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001, - VK_DESCRIPTOR_TYPE_TENSOR_ARM = 1000460000, - VK_DESCRIPTOR_TYPE_MUTABLE_EXT = 1000351000, - VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV = 1000570000, - 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; - typedef enum VkAttachmentLoadOp { VK_ATTACHMENT_LOAD_OP_LOAD = 0, VK_ATTACHMENT_LOAD_OP_CLEAR = 1, @@ -2423,35 +2531,6 @@ typedef enum VkAttachmentStoreOp { VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF } VkAttachmentStoreOp; -typedef enum VkPipelineBindPoint { - VK_PIPELINE_BIND_POINT_GRAPHICS = 0, - VK_PIPELINE_BIND_POINT_COMPUTE = 1, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX = 1000134000, -#endif - VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000, - VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003, - VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, - VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF -} VkPipelineBindPoint; - -typedef enum VkCommandBufferLevel { - VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, - VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, - VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferLevel; - -typedef enum VkIndexType { - VK_INDEX_TYPE_UINT16 = 0, - VK_INDEX_TYPE_UINT32 = 1, - VK_INDEX_TYPE_UINT8 = 1000265000, - VK_INDEX_TYPE_NONE_KHR = 1000165000, - VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR, - VK_INDEX_TYPE_UINT8_EXT = VK_INDEX_TYPE_UINT8, - VK_INDEX_TYPE_UINT8_KHR = VK_INDEX_TYPE_UINT8, - VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkIndexType; - typedef enum VkSubpassContents { VK_SUBPASS_CONTENTS_INLINE = 0, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, @@ -2682,6 +2761,7 @@ typedef enum VkQueueFlagBits { VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020, VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040, VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0x00000100, + VK_QUEUE_DATA_GRAPH_BIT_ARM = 0x00000400, VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkQueueFlagBits; typedef VkFlags VkQueueFlags; @@ -2759,15 +2839,14 @@ typedef enum VkFenceCreateFlagBits { typedef VkFlags VkFenceCreateFlags; typedef VkFlags VkSemaphoreCreateFlags; -typedef enum VkEventCreateFlagBits { - VK_EVENT_CREATE_DEVICE_ONLY_BIT = 0x00000001, - VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT, - VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkEventCreateFlagBits; -typedef VkFlags VkEventCreateFlags; - -typedef enum VkQueryPipelineStatisticFlagBits { - VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, +typedef enum VkQueryPoolCreateFlagBits { + VK_QUERY_POOL_CREATE_RESET_BIT_KHR = 0x00000001, + VK_QUERY_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryPoolCreateFlagBits; +typedef VkFlags VkQueryPoolCreateFlags; + +typedef enum VkQueryPipelineStatisticFlagBits { + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, @@ -2785,12 +2864,6 @@ typedef enum VkQueryPipelineStatisticFlagBits { } VkQueryPipelineStatisticFlagBits; typedef VkFlags VkQueryPipelineStatisticFlags; -typedef enum VkQueryPoolCreateFlagBits { - VK_QUERY_POOL_CREATE_RESET_BIT_KHR = 0x00000001, - VK_QUERY_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryPoolCreateFlagBits; -typedef VkFlags VkQueryPoolCreateFlags; - typedef enum VkQueryResultFlagBits { VK_QUERY_RESULT_64_BIT = 0x00000001, VK_QUERY_RESULT_WAIT_BIT = 0x00000002, @@ -2851,7 +2924,6 @@ typedef enum VkBufferUsageFlagBits { VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkBufferUsageFlagBits; typedef VkFlags VkBufferUsageFlags; -typedef VkFlags VkBufferViewCreateFlags; typedef enum VkImageViewCreateFlagBits { VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, @@ -2860,6 +2932,61 @@ typedef enum VkImageViewCreateFlagBits { VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkImageViewCreateFlagBits; typedef VkFlags VkImageViewCreateFlags; + +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_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR = 0x00000020, + VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR = 0x00000040, + 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 +} VkDependencyFlagBits; +typedef VkFlags VkDependencyFlags; + +typedef enum VkCommandPoolCreateFlagBits { + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, + VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, + VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolCreateFlagBits; +typedef VkFlags VkCommandPoolCreateFlags; + +typedef enum VkCommandPoolResetFlagBits { + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolResetFlagBits; +typedef VkFlags VkCommandPoolResetFlags; + +typedef enum VkCommandBufferUsageFlagBits { + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, + VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, + VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, + VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferUsageFlagBits; +typedef VkFlags VkCommandBufferUsageFlags; + +typedef enum VkQueryControlFlagBits { + VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, + VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryControlFlagBits; +typedef VkFlags VkQueryControlFlags; + +typedef enum VkCommandBufferResetFlagBits { + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferResetFlagBits; +typedef VkFlags VkCommandBufferResetFlags; + +typedef enum VkEventCreateFlagBits { + VK_EVENT_CREATE_DEVICE_ONLY_BIT = 0x00000001, + VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT, + VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkEventCreateFlagBits; +typedef VkFlags VkEventCreateFlags; +typedef VkFlags VkBufferViewCreateFlags; typedef VkFlags VkShaderModuleCreateFlags; typedef enum VkPipelineCacheCreateFlagBits { @@ -2870,21 +2997,12 @@ typedef enum VkPipelineCacheCreateFlagBits { } VkPipelineCacheCreateFlagBits; typedef VkFlags VkPipelineCacheCreateFlags; -typedef enum VkColorComponentFlagBits { - VK_COLOR_COMPONENT_R_BIT = 0x00000001, - VK_COLOR_COMPONENT_G_BIT = 0x00000002, - VK_COLOR_COMPONENT_B_BIT = 0x00000004, - VK_COLOR_COMPONENT_A_BIT = 0x00000008, - VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkColorComponentFlagBits; -typedef VkFlags VkColorComponentFlags; - typedef enum VkPipelineCreateFlagBits { VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, - VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0x00000100, VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT = 0x00000200, VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT = 0x08000000, @@ -2913,15 +3031,15 @@ typedef enum VkPipelineCreateFlagBits { #ifdef VK_ENABLE_BETA_EXTENSIONS VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000, #endif - // VK_PIPELINE_CREATE_DISPATCH_BASE is a deprecated alias + // VK_PIPELINE_CREATE_DISPATCH_BASE is a legacy alias VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, - // VK_PIPELINE_CREATE_DISPATCH_BASE_KHR is a deprecated alias + // VK_PIPELINE_CREATE_DISPATCH_BASE_KHR is a legacy alias VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, - // VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT is a deprecated alias + // VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT is a legacy alias VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, - // VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR is a deprecated alias + // VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR is a legacy alias VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, @@ -2970,38 +3088,6 @@ typedef enum VkShaderStageFlagBits { VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkShaderStageFlagBits; -typedef enum VkCullModeFlagBits { - VK_CULL_MODE_NONE = 0, - VK_CULL_MODE_FRONT_BIT = 0x00000001, - VK_CULL_MODE_BACK_BIT = 0x00000002, - VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, - VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCullModeFlagBits; -typedef VkFlags VkCullModeFlags; -typedef VkFlags VkPipelineVertexInputStateCreateFlags; -typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; -typedef VkFlags VkPipelineTessellationStateCreateFlags; -typedef VkFlags VkPipelineViewportStateCreateFlags; -typedef VkFlags VkPipelineRasterizationStateCreateFlags; -typedef VkFlags VkPipelineMultisampleStateCreateFlags; - -typedef enum VkPipelineDepthStencilStateCreateFlagBits { - 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_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; -typedef VkFlags VkPipelineDynamicStateCreateFlags; - typedef enum VkPipelineLayoutCreateFlagBits { VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT = 0x00000002, VK_PIPELINE_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF @@ -3047,25 +3133,55 @@ typedef enum VkDescriptorSetLayoutCreateFlagBits { } VkDescriptorSetLayoutCreateFlagBits; typedef VkFlags VkDescriptorSetLayoutCreateFlags; +typedef enum VkColorComponentFlagBits { + VK_COLOR_COMPONENT_R_BIT = 0x00000001, + VK_COLOR_COMPONENT_G_BIT = 0x00000002, + VK_COLOR_COMPONENT_B_BIT = 0x00000004, + VK_COLOR_COMPONENT_A_BIT = 0x00000008, + VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkColorComponentFlagBits; +typedef VkFlags VkColorComponentFlags; + +typedef enum VkCullModeFlagBits { + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 0x00000001, + VK_CULL_MODE_BACK_BIT = 0x00000002, + VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, + VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCullModeFlagBits; +typedef VkFlags VkCullModeFlags; +typedef VkFlags VkPipelineVertexInputStateCreateFlags; +typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; +typedef VkFlags VkPipelineTessellationStateCreateFlags; +typedef VkFlags VkPipelineViewportStateCreateFlags; +typedef VkFlags VkPipelineRasterizationStateCreateFlags; +typedef VkFlags VkPipelineMultisampleStateCreateFlags; + +typedef enum VkPipelineDepthStencilStateCreateFlagBits { + 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_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; +typedef VkFlags VkPipelineDynamicStateCreateFlags; + typedef enum VkAttachmentDescriptionFlagBits { VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, + VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR = 0x00000002, + VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR = 0x00000004, VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkAttachmentDescriptionFlagBits; typedef VkFlags VkAttachmentDescriptionFlags; -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_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR = 0x00000020, - VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR = 0x00000040, - 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 -} VkDependencyFlagBits; -typedef VkFlags VkDependencyFlags; - typedef enum VkFramebufferCreateFlagBits { VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001, VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, @@ -3075,6 +3191,7 @@ typedef VkFlags VkFramebufferCreateFlags; typedef enum VkRenderPassCreateFlagBits { VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0x00000002, + VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x00000004, VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkRenderPassCreateFlagBits; typedef VkFlags VkRenderPassCreateFlags; @@ -3096,45 +3213,11 @@ typedef enum VkSubpassDescriptionFlagBits { } VkSubpassDescriptionFlagBits; typedef VkFlags VkSubpassDescriptionFlags; -typedef enum VkCommandPoolCreateFlagBits { - VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, - VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, - VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, - VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandPoolCreateFlagBits; -typedef VkFlags VkCommandPoolCreateFlags; - -typedef enum VkCommandPoolResetFlagBits { - VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, - VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandPoolResetFlagBits; -typedef VkFlags VkCommandPoolResetFlags; - -typedef enum VkCommandBufferUsageFlagBits { - VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, - VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, - VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, - VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferUsageFlagBits; -typedef VkFlags VkCommandBufferUsageFlags; - -typedef enum VkQueryControlFlagBits { - VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, - VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryControlFlagBits; -typedef VkFlags VkQueryControlFlags; - -typedef enum VkCommandBufferResetFlagBits { - VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, - VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferResetFlagBits; -typedef VkFlags VkCommandBufferResetFlags; - typedef enum VkStencilFaceFlagBits { VK_STENCIL_FACE_FRONT_BIT = 0x00000001, VK_STENCIL_FACE_BACK_BIT = 0x00000002, VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003, - // VK_STENCIL_FRONT_AND_BACK is a deprecated alias + // VK_STENCIL_FRONT_AND_BACK is a legacy alias VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK, VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkStencilFaceFlagBits; @@ -3188,27 +3271,6 @@ typedef struct VkBufferMemoryBarrier { VkDeviceSize size; } VkBufferMemoryBarrier; -typedef struct VkDispatchIndirectCommand { - uint32_t x; - uint32_t y; - uint32_t z; -} VkDispatchIndirectCommand; - -typedef struct VkDrawIndexedIndirectCommand { - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; -} VkDrawIndexedIndirectCommand; - -typedef struct VkDrawIndirectCommand { - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; -} VkDrawIndirectCommand; - typedef struct VkImageSubresourceRange { VkImageAspectFlags aspectMask; uint32_t baseMipLevel; @@ -3237,14 +3299,6 @@ typedef struct VkMemoryBarrier { VkAccessFlags dstAccessMask; } VkMemoryBarrier; -typedef struct VkPipelineCacheHeaderVersionOne { - uint32_t headerSize; - VkPipelineCacheHeaderVersion headerVersion; - uint32_t vendorID; - uint32_t deviceID; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; -} VkPipelineCacheHeaderVersionOne; - typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( void* pUserData, size_t size, @@ -3545,9 +3599,9 @@ typedef struct VkDeviceCreateInfo { VkDeviceCreateFlags flags; uint32_t queueCreateInfoCount; const VkDeviceQueueCreateInfo* pQueueCreateInfos; - // enabledLayerCount is deprecated and should not be used + // enabledLayerCount is legacy and should not be used uint32_t enabledLayerCount; - // ppEnabledLayerNames is deprecated and should not be used + // ppEnabledLayerNames is legacy and should not be used const char* const* ppEnabledLayerNames; uint32_t enabledExtensionCount; const char* const* ppEnabledExtensionNames; @@ -3681,12 +3735,6 @@ typedef struct VkSemaphoreCreateInfo { VkSemaphoreCreateFlags flags; } VkSemaphoreCreateInfo; -typedef struct VkEventCreateInfo { - VkStructureType sType; - const void* pNext; - VkEventCreateFlags flags; -} VkEventCreateInfo; - typedef struct VkQueryPoolCreateInfo { VkStructureType sType; const void* pNext; @@ -3707,16 +3755,6 @@ typedef struct VkBufferCreateInfo { const uint32_t* pQueueFamilyIndices; } VkBufferCreateInfo; -typedef struct VkBufferViewCreateInfo { - VkStructureType sType; - const void* pNext; - VkBufferViewCreateFlags flags; - VkBuffer buffer; - VkFormat format; - VkDeviceSize offset; - VkDeviceSize range; -} VkBufferViewCreateInfo; - typedef struct VkImageCreateInfo { VkStructureType sType; const void* pNext; @@ -3761,16 +3799,109 @@ typedef struct VkImageViewCreateInfo { VkImageSubresourceRange subresourceRange; } VkImageViewCreateInfo; -typedef struct VkShaderModuleCreateInfo { - VkStructureType sType; - const void* pNext; - VkShaderModuleCreateFlags flags; - size_t codeSize; - const uint32_t* pCode; -} VkShaderModuleCreateInfo; - -typedef struct VkPipelineCacheCreateInfo { - VkStructureType sType; +typedef struct VkCommandPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; +} VkCommandPoolCreateInfo; + +typedef struct VkCommandBufferAllocateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint32_t commandBufferCount; +} VkCommandBufferAllocateInfo; + +typedef struct VkCommandBufferInheritanceInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + uint32_t subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkCommandBufferInheritanceInfo; + +typedef struct VkCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + VkCommandBufferUsageFlags flags; + const VkCommandBufferInheritanceInfo* pInheritanceInfo; +} VkCommandBufferBeginInfo; + +typedef struct VkBufferCopy { + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy; + +typedef struct VkImageSubresourceLayers { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceLayers; + +typedef struct VkBufferImageCopy { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +typedef struct VkImageCopy { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct VkDispatchIndirectCommand { + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCommand; + +typedef struct VkPipelineCacheHeaderVersionOne { + uint32_t headerSize; + VkPipelineCacheHeaderVersion headerVersion; + uint32_t vendorID; + uint32_t deviceID; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; +} VkPipelineCacheHeaderVersionOne; + +typedef struct VkEventCreateInfo { + VkStructureType sType; + const void* pNext; + VkEventCreateFlags flags; +} VkEventCreateInfo; + +typedef struct VkBufferViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} VkBufferViewCreateInfo; + +typedef struct VkShaderModuleCreateInfo { + VkStructureType sType; + const void* pNext; + VkShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t* pCode; +} VkShaderModuleCreateInfo; + +typedef struct VkPipelineCacheCreateInfo { + VkStructureType sType; const void* pNext; VkPipelineCacheCreateFlags flags; size_t initialDataSize; @@ -3810,6 +3941,139 @@ typedef struct VkComputePipelineCreateInfo { int32_t basePipelineIndex; } VkComputePipelineCreateInfo; +typedef struct VkPushConstantRange { + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; +} VkPushConstantRange; + +typedef struct VkPipelineLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + +typedef struct VkSamplerCreateInfo { + VkStructureType sType; + const void* pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} VkSamplerCreateInfo; + +typedef struct VkCopyDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; +} VkCopyDescriptorSet; + +typedef struct VkDescriptorBufferInfo { + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} VkDescriptorBufferInfo; + +typedef struct VkDescriptorImageInfo { + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} VkDescriptorImageInfo; + +typedef struct VkDescriptorPoolSize { + VkDescriptorType type; + uint32_t descriptorCount; +} VkDescriptorPoolSize; + +typedef struct VkDescriptorPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const VkDescriptorPoolSize* pPoolSizes; +} VkDescriptorPoolCreateInfo; + +typedef struct VkDescriptorSetAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPool descriptorPool; + uint32_t descriptorSetCount; + const VkDescriptorSetLayout* pSetLayouts; +} VkDescriptorSetAllocateInfo; + +typedef struct VkDescriptorSetLayoutBinding { + uint32_t binding; + VkDescriptorType descriptorType; + uint32_t descriptorCount; + VkShaderStageFlags stageFlags; + const VkSampler* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; + +typedef struct VkDescriptorSetLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const VkDescriptorSetLayoutBinding* pBindings; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct VkWriteDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + const VkDescriptorImageInfo* pImageInfo; + const VkDescriptorBufferInfo* pBufferInfo; + const VkBufferView* pTexelBufferView; +} VkWriteDescriptorSet; + +typedef union VkClearColorValue { + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; +} VkClearColorValue; + +typedef struct VkDrawIndexedIndirectCommand { + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCommand; + +typedef struct VkDrawIndirectCommand { + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +} VkDrawIndirectCommand; + typedef struct VkVertexInputBindingDescription { uint32_t binding; uint32_t stride; @@ -3972,129 +4236,17 @@ typedef struct VkGraphicsPipelineCreateInfo { int32_t basePipelineIndex; } VkGraphicsPipelineCreateInfo; -typedef struct VkPushConstantRange { - VkShaderStageFlags stageFlags; - uint32_t offset; - uint32_t size; -} VkPushConstantRange; - -typedef struct VkPipelineLayoutCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - const VkDescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const VkPushConstantRange* pPushConstantRanges; -} VkPipelineLayoutCreateInfo; - -typedef struct VkSamplerCreateInfo { - VkStructureType sType; - const void* pNext; - VkSamplerCreateFlags flags; - VkFilter magFilter; - VkFilter minFilter; - VkSamplerMipmapMode mipmapMode; - VkSamplerAddressMode addressModeU; - VkSamplerAddressMode addressModeV; - VkSamplerAddressMode addressModeW; - float mipLodBias; - VkBool32 anisotropyEnable; - float maxAnisotropy; - VkBool32 compareEnable; - VkCompareOp compareOp; - float minLod; - float maxLod; - VkBorderColor borderColor; - VkBool32 unnormalizedCoordinates; -} VkSamplerCreateInfo; - -typedef struct VkCopyDescriptorSet { - VkStructureType sType; - const void* pNext; - VkDescriptorSet srcSet; - uint32_t srcBinding; - uint32_t srcArrayElement; - VkDescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; -} VkCopyDescriptorSet; - -typedef struct VkDescriptorBufferInfo { - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize range; -} VkDescriptorBufferInfo; - -typedef struct VkDescriptorImageInfo { - VkSampler sampler; - VkImageView imageView; - VkImageLayout imageLayout; -} VkDescriptorImageInfo; - -typedef struct VkDescriptorPoolSize { - VkDescriptorType type; - uint32_t descriptorCount; -} VkDescriptorPoolSize; - -typedef struct VkDescriptorPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorPoolCreateFlags flags; - uint32_t maxSets; - uint32_t poolSizeCount; - const VkDescriptorPoolSize* pPoolSizes; -} VkDescriptorPoolCreateInfo; - -typedef struct VkDescriptorSetAllocateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorPool descriptorPool; - uint32_t descriptorSetCount; - const VkDescriptorSetLayout* pSetLayouts; -} VkDescriptorSetAllocateInfo; - -typedef struct VkDescriptorSetLayoutBinding { - uint32_t binding; - VkDescriptorType descriptorType; - uint32_t descriptorCount; - VkShaderStageFlags stageFlags; - const VkSampler* pImmutableSamplers; -} VkDescriptorSetLayoutBinding; - -typedef struct VkDescriptorSetLayoutCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorSetLayoutCreateFlags flags; - uint32_t bindingCount; - const VkDescriptorSetLayoutBinding* pBindings; -} VkDescriptorSetLayoutCreateInfo; - -typedef struct VkWriteDescriptorSet { - VkStructureType sType; - const void* pNext; - VkDescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - const VkDescriptorImageInfo* pImageInfo; - const VkDescriptorBufferInfo* pBufferInfo; - const VkBufferView* pTexelBufferView; -} VkWriteDescriptorSet; - -typedef struct VkAttachmentDescription { - VkAttachmentDescriptionFlags flags; - VkFormat format; - VkSampleCountFlagBits samples; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkAttachmentLoadOp stencilLoadOp; - VkAttachmentStoreOp stencilStoreOp; - VkImageLayout initialLayout; - VkImageLayout finalLayout; -} VkAttachmentDescription; +typedef struct VkAttachmentDescription { + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription; typedef struct VkAttachmentReference { uint32_t attachment; @@ -4148,67 +4300,6 @@ typedef struct VkRenderPassCreateInfo { const VkSubpassDependency* pDependencies; } VkRenderPassCreateInfo; -typedef struct VkCommandPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkCommandPoolCreateFlags flags; - uint32_t queueFamilyIndex; -} VkCommandPoolCreateInfo; - -typedef struct VkCommandBufferAllocateInfo { - VkStructureType sType; - const void* pNext; - VkCommandPool commandPool; - VkCommandBufferLevel level; - uint32_t commandBufferCount; -} VkCommandBufferAllocateInfo; - -typedef struct VkCommandBufferInheritanceInfo { - VkStructureType sType; - const void* pNext; - VkRenderPass renderPass; - uint32_t subpass; - VkFramebuffer framebuffer; - VkBool32 occlusionQueryEnable; - VkQueryControlFlags queryFlags; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkCommandBufferInheritanceInfo; - -typedef struct VkCommandBufferBeginInfo { - VkStructureType sType; - const void* pNext; - VkCommandBufferUsageFlags flags; - const VkCommandBufferInheritanceInfo* pInheritanceInfo; -} VkCommandBufferBeginInfo; - -typedef struct VkBufferCopy { - VkDeviceSize srcOffset; - VkDeviceSize dstOffset; - VkDeviceSize size; -} VkBufferCopy; - -typedef struct VkImageSubresourceLayers { - VkImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkImageSubresourceLayers; - -typedef struct VkBufferImageCopy { - VkDeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkBufferImageCopy; - -typedef union VkClearColorValue { - float float32[4]; - int32_t int32[4]; - uint32_t uint32[4]; -} VkClearColorValue; - typedef struct VkClearDepthStencilValue { float depth; uint32_t stencil; @@ -4238,14 +4329,6 @@ typedef struct VkImageBlit { VkOffset3D dstOffsets[2]; } VkImageBlit; -typedef struct VkImageCopy { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageCopy; - typedef struct VkImageResolve { VkImageSubresourceLayers srcSubresource; VkOffset3D srcOffset; @@ -4306,30 +4389,50 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fenc typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); -typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); -typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); +typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); +typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); +typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); +typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); -typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); @@ -4344,20 +4447,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescr typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); +typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); -typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); -typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); -typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); -typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); -typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); -typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); -typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); -typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); @@ -4367,40 +4471,19 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); -typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); -typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); -typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); -typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); -typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); -typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); -typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); -typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); -typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); -typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); -typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); -typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); #ifndef VK_NO_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( @@ -4624,29 +4707,6 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); -VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkEvent* pEvent); - -VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( - VkDevice device, - VkEvent event, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( - VkDevice device, - VkEvent event); - -VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( - VkDevice device, - VkEvent event); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( - VkDevice device, - VkEvent event); - VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, @@ -4679,17 +4739,6 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( VkBuffer buffer, const VkAllocationCallbacks* pAllocator); -VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( - VkDevice device, - const VkBufferViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBufferView* pView); - -VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( - VkDevice device, - VkBufferView bufferView, - const VkAllocationCallbacks* pAllocator); - VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( VkDevice device, const VkImageCreateInfo* pCreateInfo, @@ -4718,6 +4767,174 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( VkImageView imageView, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( + VkDevice device, + VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent); + +VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( + VkDevice device, + VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator); + VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, @@ -4752,14 +4969,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); -VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkGraphicsPipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); - VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( VkDevice device, VkPipelineCache pipelineCache, @@ -4840,75 +5049,105 @@ VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); -VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( - VkDevice device, - const VkFramebufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFramebuffer* pFramebuffer); +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); -VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( - VkDevice device, - VkFramebuffer framebuffer, - const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( - VkDevice device, - const VkRenderPassCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass); +VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); -VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( - VkDevice device, - VkRenderPass renderPass, - const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); -VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( VkDevice device, - VkRenderPass renderPass, - VkExtent2D* pGranularity); + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); -VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( VkDevice device, - const VkCommandPoolCreateInfo* pCreateInfo, + const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, - VkCommandPool* pCommandPool); + VkFramebuffer* pFramebuffer); -VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( +VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( VkDevice device, - VkCommandPool commandPool, + VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); -VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( VkDevice device, - VkCommandPool commandPool, - VkCommandPoolResetFlags flags); + const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( +VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( VkDevice device, - const VkCommandBufferAllocateInfo* pAllocateInfo, - VkCommandBuffer* pCommandBuffers); + VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator); -VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( +VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( VkDevice device, - VkCommandPool commandPool, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers); - -VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( - VkCommandBuffer commandBuffer, - const VkCommandBufferBeginInfo* pBeginInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( - VkCommandBuffer commandBuffer); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( - VkCommandBuffer commandBuffer, - VkCommandBufferResetFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline); + VkRenderPass renderPass, + VkExtent2D* pGranularity); VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( VkCommandBuffer commandBuffer, @@ -4956,16 +5195,6 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( VkStencilFaceFlags faceMask, uint32_t reference); -VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets); - VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, @@ -5008,33 +5237,6 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( uint32_t drawCount, uint32_t stride); -VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions); - VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, @@ -5045,44 +5247,6 @@ VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( const VkImageBlit* pRegions, VkFilter filter); -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize dataSize, - const void* pData); - -VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize size, - uint32_t data); - -VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, @@ -5107,82 +5271,6 @@ VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( uint32_t regionCount, const VkImageResolve* pRegions); -VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers); - -VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - VkDependencyFlags dependencyFlags, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query); - -VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount); - -VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, - uint32_t query); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize stride, - VkQueryResultFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( - VkCommandBuffer commandBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t offset, - uint32_t size, - const void* pValues); - VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, @@ -5194,11 +5282,6 @@ VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( VkCommandBuffer commandBuffer); - -VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( - VkCommandBuffer commandBuffer, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers); #endif @@ -5207,27 +5290,19 @@ VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( // Vulkan 1.1 version number #define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) #define VK_MAX_DEVICE_GROUP_SIZE 32U #define VK_LUID_SIZE 8U #define VK_QUEUE_FAMILY_EXTERNAL (~1U) -typedef enum VkPointClippingBehavior { - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, - VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, - VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, - VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF -} VkPointClippingBehavior; - -typedef enum VkTessellationDomainOrigin { - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, - VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, - VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, - VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF -} VkTessellationDomainOrigin; +typedef enum VkDescriptorUpdateTemplateType { + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS = 1, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorUpdateTemplateType; typedef enum VkSamplerYcbcrModelConversion { VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, @@ -5259,31 +5334,21 @@ typedef enum VkChromaLocation { VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF } VkChromaLocation; -typedef enum VkDescriptorUpdateTemplateType { - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS = 1, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorUpdateTemplateType; +typedef enum VkPointClippingBehavior { + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, + VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} VkPointClippingBehavior; -typedef enum VkSubgroupFeatureFlagBits { - VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, - VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, - VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, - VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, - VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, - VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, - VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, - VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, - VK_SUBGROUP_FEATURE_ROTATE_BIT = 0x00000200, - VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT = 0x00000400, - VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, - VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_BIT, - VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT, - VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSubgroupFeatureFlagBits; -typedef VkFlags VkSubgroupFeatureFlags; +typedef enum VkTessellationDomainOrigin { + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF +} VkTessellationDomainOrigin; typedef enum VkPeerMemoryFeatureFlagBits { VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, @@ -5310,7 +5375,6 @@ typedef enum VkMemoryAllocateFlagBits { } VkMemoryAllocateFlagBits; typedef VkFlags VkMemoryAllocateFlags; typedef VkFlags VkCommandPoolTrimFlags; -typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; typedef enum VkExternalMemoryHandleTypeFlagBits { VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, @@ -5326,6 +5390,7 @@ typedef enum VkExternalMemoryHandleTypeFlagBits { VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800, VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OH_NATIVE_BUFFER_BIT_OHOS = 0x00008000, VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX = 0x00004000, VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT = 0x00010000, VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT = 0x00020000, @@ -5413,15 +5478,25 @@ typedef enum VkExternalSemaphoreFeatureFlagBits { VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkExternalSemaphoreFeatureFlagBits; typedef VkFlags VkExternalSemaphoreFeatureFlags; -typedef struct VkPhysicalDeviceSubgroupProperties { - VkStructureType sType; - void* pNext; - uint32_t subgroupSize; - VkShaderStageFlags supportedStages; - VkSubgroupFeatureFlags supportedOperations; - VkBool32 quadOperationsInAllStages; -} VkPhysicalDeviceSubgroupProperties; +typedef enum VkSubgroupFeatureFlagBits { + VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, + VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, + VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, + VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, + VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, + VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, + VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, + VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, + VK_SUBGROUP_FEATURE_ROTATE_BIT = 0x00000200, + VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT = 0x00000400, + VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, + VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_BIT, + VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT, + VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubgroupFeatureFlagBits; +typedef VkFlags VkSubgroupFeatureFlags; +typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; typedef struct VkBindBufferMemoryInfo { VkStructureType sType; const void* pNext; @@ -5438,15 +5513,6 @@ typedef struct VkBindImageMemoryInfo { VkDeviceSize memoryOffset; } VkBindImageMemoryInfo; -typedef struct VkPhysicalDevice16BitStorageFeatures { - VkStructureType sType; - void* pNext; - VkBool32 storageBuffer16BitAccess; - VkBool32 uniformAndStorageBuffer16BitAccess; - VkBool32 storagePushConstant16; - VkBool32 storageInputOutput16; -} VkPhysicalDevice16BitStorageFeatures; - typedef struct VkMemoryDedicatedRequirements { VkStructureType sType; void* pNext; @@ -5468,14 +5534,6 @@ typedef struct VkMemoryAllocateFlagsInfo { uint32_t deviceMask; } VkMemoryAllocateFlagsInfo; -typedef struct VkDeviceGroupRenderPassBeginInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceMask; - uint32_t deviceRenderAreaCount; - const VkRect2D* pDeviceRenderAreas; -} VkDeviceGroupRenderPassBeginInfo; - typedef struct VkDeviceGroupCommandBufferBeginInfo { VkStructureType sType; const void* pNext; @@ -5623,72 +5681,12 @@ typedef struct VkPhysicalDeviceSparseImageFormatInfo2 { VkImageTiling tiling; } VkPhysicalDeviceSparseImageFormatInfo2; -typedef struct VkPhysicalDevicePointClippingProperties { - VkStructureType sType; - void* pNext; - VkPointClippingBehavior pointClippingBehavior; -} VkPhysicalDevicePointClippingProperties; - -typedef struct VkInputAttachmentAspectReference { - uint32_t subpass; - uint32_t inputAttachmentIndex; - VkImageAspectFlags aspectMask; -} VkInputAttachmentAspectReference; - -typedef struct VkRenderPassInputAttachmentAspectCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t aspectReferenceCount; - const VkInputAttachmentAspectReference* pAspectReferences; -} VkRenderPassInputAttachmentAspectCreateInfo; - typedef struct VkImageViewUsageCreateInfo { VkStructureType sType; const void* pNext; VkImageUsageFlags usage; } VkImageViewUsageCreateInfo; -typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkTessellationDomainOrigin domainOrigin; -} VkPipelineTessellationDomainOriginStateCreateInfo; - -typedef struct VkRenderPassMultiviewCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t subpassCount; - const uint32_t* pViewMasks; - uint32_t dependencyCount; - const int32_t* pViewOffsets; - uint32_t correlationMaskCount; - const uint32_t* pCorrelationMasks; -} VkRenderPassMultiviewCreateInfo; - -typedef struct VkPhysicalDeviceMultiviewFeatures { - VkStructureType sType; - void* pNext; - VkBool32 multiview; - VkBool32 multiviewGeometryShader; - VkBool32 multiviewTessellationShader; -} VkPhysicalDeviceMultiviewFeatures; - -typedef struct VkPhysicalDeviceMultiviewProperties { - VkStructureType sType; - void* pNext; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; -} VkPhysicalDeviceMultiviewProperties; - -typedef struct VkPhysicalDeviceVariablePointersFeatures { - VkStructureType sType; - void* pNext; - VkBool32 variablePointersStorageBuffer; - VkBool32 variablePointers; -} VkPhysicalDeviceVariablePointersFeatures; - -typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; - typedef struct VkPhysicalDeviceProtectedMemoryFeatures { VkStructureType sType; void* pNext; @@ -5715,25 +5713,6 @@ typedef struct VkProtectedSubmitInfo { VkBool32 protectedSubmit; } VkProtectedSubmitInfo; -typedef struct VkSamplerYcbcrConversionCreateInfo { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkSamplerYcbcrModelConversion ycbcrModel; - VkSamplerYcbcrRange ycbcrRange; - VkComponentMapping components; - VkChromaLocation xChromaOffset; - VkChromaLocation yChromaOffset; - VkFilter chromaFilter; - VkBool32 forceExplicitReconstruction; -} VkSamplerYcbcrConversionCreateInfo; - -typedef struct VkSamplerYcbcrConversionInfo { - VkStructureType sType; - const void* pNext; - VkSamplerYcbcrConversion conversion; -} VkSamplerYcbcrConversionInfo; - typedef struct VkBindImagePlaneMemoryInfo { VkStructureType sType; const void* pNext; @@ -5746,40 +5725,6 @@ typedef struct VkImagePlaneMemoryRequirementsInfo { VkImageAspectFlagBits planeAspect; } VkImagePlaneMemoryRequirementsInfo; -typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { - VkStructureType sType; - void* pNext; - VkBool32 samplerYcbcrConversion; -} VkPhysicalDeviceSamplerYcbcrConversionFeatures; - -typedef struct VkSamplerYcbcrConversionImageFormatProperties { - VkStructureType sType; - void* pNext; - uint32_t combinedImageSamplerDescriptorCount; -} VkSamplerYcbcrConversionImageFormatProperties; - -typedef struct VkDescriptorUpdateTemplateEntry { - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - size_t offset; - size_t stride; -} VkDescriptorUpdateTemplateEntry; - -typedef struct VkDescriptorUpdateTemplateCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorUpdateTemplateCreateFlags flags; - uint32_t descriptorUpdateEntryCount; - const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; - VkDescriptorUpdateTemplateType templateType; - VkDescriptorSetLayout descriptorSetLayout; - VkPipelineBindPoint pipelineBindPoint; - VkPipelineLayout pipelineLayout; - uint32_t set; -} VkDescriptorUpdateTemplateCreateInfo; - typedef struct VkExternalMemoryProperties { VkExternalMemoryFeatureFlags externalMemoryFeatures; VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; @@ -5880,55 +5825,194 @@ typedef struct VkExternalSemaphoreProperties { VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; } VkExternalSemaphoreProperties; -typedef struct VkPhysicalDeviceMaintenance3Properties { - VkStructureType sType; - void* pNext; - uint32_t maxPerSetDescriptors; - VkDeviceSize maxMemoryAllocationSize; -} VkPhysicalDeviceMaintenance3Properties; +typedef struct VkPhysicalDeviceSubgroupProperties { + VkStructureType sType; + void* pNext; + uint32_t subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; +} VkPhysicalDeviceSubgroupProperties; -typedef struct VkDescriptorSetLayoutSupport { +typedef struct VkPhysicalDevice16BitStorageFeatures { VkStructureType sType; void* pNext; - VkBool32 supported; -} VkDescriptorSetLayoutSupport; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeatures; -typedef struct VkPhysicalDeviceShaderDrawParametersFeatures { +typedef struct VkPhysicalDeviceVariablePointersFeatures { VkStructureType sType; void* pNext; - VkBool32 shaderDrawParameters; -} VkPhysicalDeviceShaderDrawParametersFeatures; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointersFeatures; -typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); -typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); -typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); -typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); -typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +typedef struct VkDescriptorUpdateTemplateEntry { + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + size_t offset; + size_t stride; +} VkDescriptorUpdateTemplateEntry; + +typedef struct VkDescriptorUpdateTemplateCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorUpdateTemplateCreateFlags flags; + uint32_t descriptorUpdateEntryCount; + const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; + VkDescriptorUpdateTemplateType templateType; + VkDescriptorSetLayout descriptorSetLayout; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout pipelineLayout; + uint32_t set; +} VkDescriptorUpdateTemplateCreateInfo; + +typedef struct VkPhysicalDeviceMaintenance3Properties { + VkStructureType sType; + void* pNext; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} VkPhysicalDeviceMaintenance3Properties; + +typedef struct VkDescriptorSetLayoutSupport { + VkStructureType sType; + void* pNext; + VkBool32 supported; +} VkDescriptorSetLayoutSupport; + +typedef struct VkSamplerYcbcrConversionCreateInfo { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} VkSamplerYcbcrConversionCreateInfo; + +typedef struct VkSamplerYcbcrConversionInfo { + VkStructureType sType; + const void* pNext; + VkSamplerYcbcrConversion conversion; +} VkSamplerYcbcrConversionInfo; + +typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { + VkStructureType sType; + void* pNext; + VkBool32 samplerYcbcrConversion; +} VkPhysicalDeviceSamplerYcbcrConversionFeatures; + +typedef struct VkSamplerYcbcrConversionImageFormatProperties { + VkStructureType sType; + void* pNext; + uint32_t combinedImageSamplerDescriptorCount; +} VkSamplerYcbcrConversionImageFormatProperties; + +typedef struct VkDeviceGroupRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const VkRect2D* pDeviceRenderAreas; +} VkDeviceGroupRenderPassBeginInfo; + +typedef struct VkPhysicalDevicePointClippingProperties { + VkStructureType sType; + void* pNext; + VkPointClippingBehavior pointClippingBehavior; +} VkPhysicalDevicePointClippingProperties; + +typedef struct VkInputAttachmentAspectReference { + uint32_t subpass; + uint32_t inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} VkInputAttachmentAspectReference; + +typedef struct VkRenderPassInputAttachmentAspectCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t aspectReferenceCount; + const VkInputAttachmentAspectReference* pAspectReferences; +} VkRenderPassInputAttachmentAspectCreateInfo; + +typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkTessellationDomainOrigin domainOrigin; +} VkPipelineTessellationDomainOriginStateCreateInfo; + +typedef struct VkRenderPassMultiviewCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t subpassCount; + const uint32_t* pViewMasks; + uint32_t dependencyCount; + const int32_t* pViewOffsets; + uint32_t correlationMaskCount; + const uint32_t* pCorrelationMasks; +} VkRenderPassMultiviewCreateInfo; + +typedef struct VkPhysicalDeviceMultiviewFeatures { + VkStructureType sType; + void* pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} VkPhysicalDeviceMultiviewFeatures; + +typedef struct VkPhysicalDeviceMultiviewProperties { + VkStructureType sType; + void* pNext; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; +} VkPhysicalDeviceMultiviewProperties; + +typedef struct VkPhysicalDeviceShaderDrawParametersFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceShaderDrawParametersFeatures; + +typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); -typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); -typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); #ifndef VK_NO_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion( @@ -5955,15 +6039,6 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask); -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( - VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); - VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, @@ -6028,16 +6103,29 @@ VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2( const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion); +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); -VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate( VkDevice device, @@ -6056,25 +6144,21 @@ VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, - VkExternalSemaphoreProperties* pExternalSemaphoreProperties); - VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); #endif @@ -6114,6 +6198,7 @@ typedef enum VkDriverId { VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25, VK_DRIVER_ID_MESA_HONEYKRISP = 26, VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN = 27, + VK_DRIVER_ID_MESA_KOSMICKRISP = 28, 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, @@ -6139,6 +6224,14 @@ typedef enum VkShaderFloatControlsIndependence { VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF } VkShaderFloatControlsIndependence; +typedef enum VkSemaphoreType { + VK_SEMAPHORE_TYPE_BINARY = 0, + VK_SEMAPHORE_TYPE_TIMELINE = 1, + VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY, + VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE, + VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreType; + typedef enum VkSamplerReductionMode { VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, VK_SAMPLER_REDUCTION_MODE_MIN = 1, @@ -6150,14 +6243,6 @@ typedef enum VkSamplerReductionMode { VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF } VkSamplerReductionMode; -typedef enum VkSemaphoreType { - VK_SEMAPHORE_TYPE_BINARY = 0, - VK_SEMAPHORE_TYPE_TIMELINE = 1, - VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY, - VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE, - VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkSemaphoreType; - typedef enum VkResolveModeFlagBits { VK_RESOLVE_MODE_NONE = 0, VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001, @@ -6170,12 +6255,19 @@ typedef enum VkResolveModeFlagBits { VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT, VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT, VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT, - // VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID is a deprecated alias + // VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID is a legacy alias VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID = VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID, VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkResolveModeFlagBits; typedef VkFlags VkResolveModeFlags; +typedef enum VkSemaphoreWaitFlagBits { + VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001, + VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT, + VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreWaitFlagBits; +typedef VkFlags VkSemaphoreWaitFlags; + typedef enum VkDescriptorBindingFlagBits { VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001, VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002, @@ -6188,13 +6280,6 @@ typedef enum VkDescriptorBindingFlagBits { VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkDescriptorBindingFlagBits; typedef VkFlags VkDescriptorBindingFlags; - -typedef enum VkSemaphoreWaitFlagBits { - VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001, - VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT, - VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSemaphoreWaitFlagBits; -typedef VkFlags VkSemaphoreWaitFlags; typedef struct VkPhysicalDeviceVulkan11Features { VkStructureType sType; void* pNext; @@ -6355,81 +6440,104 @@ typedef struct VkImageFormatListCreateInfo { const VkFormat* pViewFormats; } VkImageFormatListCreateInfo; -typedef struct VkAttachmentDescription2 { - VkStructureType sType; - const void* pNext; - VkAttachmentDescriptionFlags flags; - VkFormat format; - VkSampleCountFlagBits samples; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkAttachmentLoadOp stencilLoadOp; - VkAttachmentStoreOp stencilStoreOp; - VkImageLayout initialLayout; - VkImageLayout finalLayout; -} VkAttachmentDescription2; +typedef struct VkPhysicalDeviceDriverProperties { + VkStructureType sType; + void* pNext; + VkDriverId driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; + VkConformanceVersion conformanceVersion; +} VkPhysicalDeviceDriverProperties; -typedef struct VkAttachmentReference2 { - VkStructureType sType; - const void* pNext; - uint32_t attachment; - VkImageLayout layout; - VkImageAspectFlags aspectMask; -} VkAttachmentReference2; +typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures { + VkStructureType sType; + void* pNext; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; +} VkPhysicalDeviceVulkanMemoryModelFeatures; -typedef struct VkSubpassDescription2 { - VkStructureType sType; - const void* pNext; - VkSubpassDescriptionFlags flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t viewMask; - uint32_t inputAttachmentCount; - const VkAttachmentReference2* pInputAttachments; - uint32_t colorAttachmentCount; - const VkAttachmentReference2* pColorAttachments; - const VkAttachmentReference2* pResolveAttachments; - const VkAttachmentReference2* pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - const uint32_t* pPreserveAttachments; -} VkSubpassDescription2; +typedef struct VkPhysicalDeviceHostQueryResetFeatures { + VkStructureType sType; + void* pNext; + VkBool32 hostQueryReset; +} VkPhysicalDeviceHostQueryResetFeatures; -typedef struct VkSubpassDependency2 { +typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures { + VkStructureType sType; + void* pNext; + VkBool32 timelineSemaphore; +} VkPhysicalDeviceTimelineSemaphoreFeatures; + +typedef struct VkPhysicalDeviceTimelineSemaphoreProperties { + VkStructureType sType; + void* pNext; + uint64_t maxTimelineSemaphoreValueDifference; +} VkPhysicalDeviceTimelineSemaphoreProperties; + +typedef struct VkSemaphoreTypeCreateInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreType semaphoreType; + uint64_t initialValue; +} VkSemaphoreTypeCreateInfo; + +typedef struct VkTimelineSemaphoreSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValueCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValueCount; + const uint64_t* pSignalSemaphoreValues; +} VkTimelineSemaphoreSubmitInfo; + +typedef struct VkSemaphoreWaitInfo { VkStructureType sType; const void* pNext; - uint32_t srcSubpass; - uint32_t dstSubpass; - VkPipelineStageFlags srcStageMask; - VkPipelineStageFlags dstStageMask; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkDependencyFlags dependencyFlags; - int32_t viewOffset; -} VkSubpassDependency2; + VkSemaphoreWaitFlags flags; + uint32_t semaphoreCount; + const VkSemaphore* pSemaphores; + const uint64_t* pValues; +} VkSemaphoreWaitInfo; -typedef struct VkRenderPassCreateInfo2 { - VkStructureType sType; - const void* pNext; - VkRenderPassCreateFlags flags; - uint32_t attachmentCount; - const VkAttachmentDescription2* pAttachments; - uint32_t subpassCount; - const VkSubpassDescription2* pSubpasses; - uint32_t dependencyCount; - const VkSubpassDependency2* pDependencies; - uint32_t correlatedViewMaskCount; - const uint32_t* pCorrelatedViewMasks; -} VkRenderPassCreateInfo2; +typedef struct VkSemaphoreSignalInfo { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + uint64_t value; +} VkSemaphoreSignalInfo; -typedef struct VkSubpassBeginInfo { - VkStructureType sType; - const void* pNext; - VkSubpassContents contents; -} VkSubpassBeginInfo; +typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures { + VkStructureType sType; + void* pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferDeviceAddressFeatures; -typedef struct VkSubpassEndInfo { +typedef struct VkBufferDeviceAddressInfo { VkStructureType sType; const void* pNext; -} VkSubpassEndInfo; + VkBuffer buffer; +} VkBufferDeviceAddressInfo; + +typedef struct VkBufferOpaqueCaptureAddressCreateInfo { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkBufferOpaqueCaptureAddressCreateInfo; + +typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkMemoryOpaqueCaptureAddressAllocateInfo; + +typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkDeviceMemoryOpaqueCaptureAddressInfo; typedef struct VkPhysicalDevice8BitStorageFeatures { VkStructureType sType; @@ -6439,15 +6547,6 @@ typedef struct VkPhysicalDevice8BitStorageFeatures { VkBool32 storagePushConstant8; } VkPhysicalDevice8BitStorageFeatures; -typedef struct VkPhysicalDeviceDriverProperties { - VkStructureType sType; - void* pNext; - VkDriverId driverID; - char driverName[VK_MAX_DRIVER_NAME_SIZE]; - char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; - VkConformanceVersion conformanceVersion; -} VkPhysicalDeviceDriverProperties; - typedef struct VkPhysicalDeviceShaderAtomicInt64Features { VkStructureType sType; void* pNext; @@ -6557,35 +6656,12 @@ typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport { uint32_t maxVariableDescriptorCount; } VkDescriptorSetVariableDescriptorCountLayoutSupport; -typedef struct VkSubpassDescriptionDepthStencilResolve { - VkStructureType sType; - const void* pNext; - VkResolveModeFlagBits depthResolveMode; - VkResolveModeFlagBits stencilResolveMode; - const VkAttachmentReference2* pDepthStencilResolveAttachment; -} VkSubpassDescriptionDepthStencilResolve; - -typedef struct VkPhysicalDeviceDepthStencilResolveProperties { - VkStructureType sType; - void* pNext; - VkResolveModeFlags supportedDepthResolveModes; - VkResolveModeFlags supportedStencilResolveModes; - VkBool32 independentResolveNone; - VkBool32 independentResolve; -} VkPhysicalDeviceDepthStencilResolveProperties; - typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures { VkStructureType sType; void* pNext; VkBool32 scalarBlockLayout; } VkPhysicalDeviceScalarBlockLayoutFeatures; -typedef struct VkImageStencilUsageCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageUsageFlags stencilUsage; -} VkImageStencilUsageCreateInfo; - typedef struct VkSamplerReductionModeCreateInfo { VkStructureType sType; const void* pNext; @@ -6599,46 +6675,6 @@ typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties { VkBool32 filterMinmaxImageComponentMapping; } VkPhysicalDeviceSamplerFilterMinmaxProperties; -typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures { - VkStructureType sType; - void* pNext; - VkBool32 vulkanMemoryModel; - VkBool32 vulkanMemoryModelDeviceScope; - VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; -} VkPhysicalDeviceVulkanMemoryModelFeatures; - -typedef struct VkPhysicalDeviceImagelessFramebufferFeatures { - VkStructureType sType; - void* pNext; - VkBool32 imagelessFramebuffer; -} VkPhysicalDeviceImagelessFramebufferFeatures; - -typedef struct VkFramebufferAttachmentImageInfo { - VkStructureType sType; - const void* pNext; - VkImageCreateFlags flags; - VkImageUsageFlags usage; - uint32_t width; - uint32_t height; - uint32_t layerCount; - uint32_t viewFormatCount; - const VkFormat* pViewFormats; -} VkFramebufferAttachmentImageInfo; - -typedef struct VkFramebufferAttachmentsCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t attachmentImageInfoCount; - const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos; -} VkFramebufferAttachmentsCreateInfo; - -typedef struct VkRenderPassAttachmentBeginInfo { - VkStructureType sType; - const void* pNext; - uint32_t attachmentCount; - const VkImageView* pAttachments; -} VkRenderPassAttachmentBeginInfo; - typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures { VkStructureType sType; void* pNext; @@ -6651,113 +6687,156 @@ typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures { VkBool32 shaderSubgroupExtendedTypes; } VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; -typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { - VkStructureType sType; - void* pNext; - VkBool32 separateDepthStencilLayouts; -} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; +typedef struct VkAttachmentDescription2 { + VkStructureType sType; + const void* pNext; + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription2; -typedef struct VkAttachmentReferenceStencilLayout { - VkStructureType sType; - void* pNext; - VkImageLayout stencilLayout; -} VkAttachmentReferenceStencilLayout; +typedef struct VkAttachmentReference2 { + VkStructureType sType; + const void* pNext; + uint32_t attachment; + VkImageLayout layout; + VkImageAspectFlags aspectMask; +} VkAttachmentReference2; -typedef struct VkAttachmentDescriptionStencilLayout { - VkStructureType sType; - void* pNext; - VkImageLayout stencilInitialLayout; - VkImageLayout stencilFinalLayout; -} VkAttachmentDescriptionStencilLayout; +typedef struct VkSubpassDescription2 { + VkStructureType sType; + const void* pNext; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t viewMask; + uint32_t inputAttachmentCount; + const VkAttachmentReference2* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference2* pColorAttachments; + const VkAttachmentReference2* pResolveAttachments; + const VkAttachmentReference2* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription2; -typedef struct VkPhysicalDeviceHostQueryResetFeatures { - VkStructureType sType; - void* pNext; - VkBool32 hostQueryReset; -} VkPhysicalDeviceHostQueryResetFeatures; +typedef struct VkSubpassDependency2 { + VkStructureType sType; + const void* pNext; + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; + int32_t viewOffset; +} VkSubpassDependency2; -typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures { - VkStructureType sType; - void* pNext; - VkBool32 timelineSemaphore; -} VkPhysicalDeviceTimelineSemaphoreFeatures; +typedef struct VkRenderPassCreateInfo2 { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription2* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription2* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency2* pDependencies; + uint32_t correlatedViewMaskCount; + const uint32_t* pCorrelatedViewMasks; +} VkRenderPassCreateInfo2; -typedef struct VkPhysicalDeviceTimelineSemaphoreProperties { - VkStructureType sType; - void* pNext; - uint64_t maxTimelineSemaphoreValueDifference; -} VkPhysicalDeviceTimelineSemaphoreProperties; +typedef struct VkSubpassBeginInfo { + VkStructureType sType; + const void* pNext; + VkSubpassContents contents; +} VkSubpassBeginInfo; -typedef struct VkSemaphoreTypeCreateInfo { +typedef struct VkSubpassEndInfo { VkStructureType sType; const void* pNext; - VkSemaphoreType semaphoreType; - uint64_t initialValue; -} VkSemaphoreTypeCreateInfo; +} VkSubpassEndInfo; -typedef struct VkTimelineSemaphoreSubmitInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreValueCount; - const uint64_t* pWaitSemaphoreValues; - uint32_t signalSemaphoreValueCount; - const uint64_t* pSignalSemaphoreValues; -} VkTimelineSemaphoreSubmitInfo; +typedef struct VkSubpassDescriptionDepthStencilResolve { + VkStructureType sType; + const void* pNext; + VkResolveModeFlagBits depthResolveMode; + VkResolveModeFlagBits stencilResolveMode; + const VkAttachmentReference2* pDepthStencilResolveAttachment; +} VkSubpassDescriptionDepthStencilResolve; -typedef struct VkSemaphoreWaitInfo { - VkStructureType sType; - const void* pNext; - VkSemaphoreWaitFlags flags; - uint32_t semaphoreCount; - const VkSemaphore* pSemaphores; - const uint64_t* pValues; -} VkSemaphoreWaitInfo; +typedef struct VkPhysicalDeviceDepthStencilResolveProperties { + VkStructureType sType; + void* pNext; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; +} VkPhysicalDeviceDepthStencilResolveProperties; -typedef struct VkSemaphoreSignalInfo { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - uint64_t value; -} VkSemaphoreSignalInfo; +typedef struct VkImageStencilUsageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags stencilUsage; +} VkImageStencilUsageCreateInfo; -typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures { +typedef struct VkPhysicalDeviceImagelessFramebufferFeatures { VkStructureType sType; void* pNext; - VkBool32 bufferDeviceAddress; - VkBool32 bufferDeviceAddressCaptureReplay; - VkBool32 bufferDeviceAddressMultiDevice; -} VkPhysicalDeviceBufferDeviceAddressFeatures; + VkBool32 imagelessFramebuffer; +} VkPhysicalDeviceImagelessFramebufferFeatures; -typedef struct VkBufferDeviceAddressInfo { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; -} VkBufferDeviceAddressInfo; +typedef struct VkFramebufferAttachmentImageInfo { + VkStructureType sType; + const void* pNext; + VkImageCreateFlags flags; + VkImageUsageFlags usage; + uint32_t width; + uint32_t height; + uint32_t layerCount; + uint32_t viewFormatCount; + const VkFormat* pViewFormats; +} VkFramebufferAttachmentImageInfo; -typedef struct VkBufferOpaqueCaptureAddressCreateInfo { +typedef struct VkFramebufferAttachmentsCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t attachmentImageInfoCount; + const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos; +} VkFramebufferAttachmentsCreateInfo; + +typedef struct VkRenderPassAttachmentBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t attachmentCount; + const VkImageView* pAttachments; +} VkRenderPassAttachmentBeginInfo; + +typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { VkStructureType sType; - const void* pNext; - uint64_t opaqueCaptureAddress; -} VkBufferOpaqueCaptureAddressCreateInfo; + void* pNext; + VkBool32 separateDepthStencilLayouts; +} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; -typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo { +typedef struct VkAttachmentReferenceStencilLayout { VkStructureType sType; - const void* pNext; - uint64_t opaqueCaptureAddress; -} VkMemoryOpaqueCaptureAddressAllocateInfo; + void* pNext; + VkImageLayout stencilLayout; +} VkAttachmentReferenceStencilLayout; -typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo { +typedef struct VkAttachmentDescriptionStencilLayout { VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; -} VkDeviceMemoryOpaqueCaptureAddressInfo; + void* pNext; + VkImageLayout stencilInitialLayout; + VkImageLayout stencilFinalLayout; +} VkAttachmentDescriptionStencilLayout; -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); -typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); -typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); -typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); @@ -6765,8 +6844,46 @@ typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, const VkSem typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); #ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkResetQueryPool( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo); + +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); + VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount( VkCommandBuffer commandBuffer, VkBuffer buffer, @@ -6804,38 +6921,6 @@ VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2( VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2( VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); - -VKAPI_ATTR void VKAPI_CALL vkResetQueryPool( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue( - VkDevice device, - VkSemaphore semaphore, - uint64_t* pValue); - -VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores( - VkDevice device, - const VkSemaphoreWaitInfo* pWaitInfo, - uint64_t timeout); - -VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore( - VkDevice device, - const VkSemaphoreSignalInfo* pSignalInfo); - -VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); - -VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); - -VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress( - VkDevice device, - const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); #endif @@ -6847,17 +6932,6 @@ VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress( typedef uint64_t VkFlags64; VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlot) -typedef enum VkPipelineCreationFeedbackFlagBits { - VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 0x00000001, - VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 0x00000002, - VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 0x00000004, - VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT, - VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, - VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT, - VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCreationFeedbackFlagBits; -typedef VkFlags VkPipelineCreationFeedbackFlags; - typedef enum VkToolPurposeFlagBits { VK_TOOL_PURPOSE_VALIDATION_BIT = 0x00000001, VK_TOOL_PURPOSE_PROFILING_BIT = 0x00000002, @@ -6949,7 +7023,7 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0 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_SHADER_BIT_HUAWEI = 0x8000000000ULL; -// VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI is a deprecated alias +// VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI is a legacy alias 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; @@ -6957,6 +7031,9 @@ static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT 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; static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV = 0x100000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM = 0x40000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR = 0x400000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT = 0x200000000000ULL; typedef VkFlags64 VkAccessFlags2; @@ -7033,6 +7110,10 @@ static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 0x10000000000 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; +static const VkAccessFlagBits2 VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM = 0x800000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM = 0x1000000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT = 0x80000000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT = 0x100000000000000ULL; typedef enum VkSubmitFlagBits { @@ -7041,20 +7122,6 @@ typedef enum VkSubmitFlagBits { VK_SUBMIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkSubmitFlagBits; typedef VkFlags VkSubmitFlags; - -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_INLINE_BIT_KHR = 0x00000010, - 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, - VK_RENDERING_CONTENTS_INLINE_BIT_EXT = VK_RENDERING_CONTENTS_INLINE_BIT_KHR, - VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkRenderingFlagBits; -typedef VkFlags VkRenderingFlags; typedef VkFlags64 VkFormatFeatureFlags2; // Flag bits for VkFormatFeatureFlagBits2 @@ -7133,9 +7200,42 @@ static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_ 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; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM = 0x1000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR = 0x800000000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x2000000000000ULL; static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x4000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR = 0x10000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR = 0x20000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR = 0x40000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR = 0x80000000000000ULL; + + +typedef enum VkPipelineCreationFeedbackFlagBits { + VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 0x00000001, + VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 0x00000002, + VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 0x00000004, + VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT, + VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, + VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT, + VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCreationFeedbackFlagBits; +typedef VkFlags VkPipelineCreationFeedbackFlags; +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_INLINE_BIT_KHR = 0x00000010, + VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x00000020, + VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR = 0x00000100, + 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, + VK_RENDERING_CONTENTS_INLINE_BIT_EXT = VK_RENDERING_CONTENTS_INLINE_BIT_KHR, + VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkRenderingFlagBits; +typedef VkFlags VkRenderingFlags; typedef struct VkPhysicalDeviceVulkan13Features { VkStructureType sType; void* pNext; @@ -7206,25 +7306,6 @@ typedef struct VkPhysicalDeviceVulkan13Properties { VkDeviceSize maxBufferSize; } VkPhysicalDeviceVulkan13Properties; -typedef struct VkPipelineCreationFeedback { - VkPipelineCreationFeedbackFlags flags; - uint64_t duration; -} VkPipelineCreationFeedback; - -typedef struct VkPipelineCreationFeedbackCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCreationFeedback* pPipelineCreationFeedback; - uint32_t pipelineStageCreationFeedbackCount; - VkPipelineCreationFeedback* pPipelineStageCreationFeedbacks; -} VkPipelineCreationFeedbackCreateInfo; - -typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderTerminateInvocation; -} VkPhysicalDeviceShaderTerminateInvocationFeatures; - typedef struct VkPhysicalDeviceToolProperties { VkStructureType sType; void* pNext; @@ -7235,12 +7316,6 @@ typedef struct VkPhysicalDeviceToolProperties { char layer[VK_MAX_EXTENSION_NAME_SIZE]; } VkPhysicalDeviceToolProperties; -typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderDemoteToHelperInvocation; -} VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures; - typedef struct VkPhysicalDevicePrivateDataFeatures { VkStructureType sType; void* pNext; @@ -7259,12 +7334,6 @@ typedef struct VkPrivateDataSlotCreateInfo { VkPrivateDataSlotCreateFlags flags; } VkPrivateDataSlotCreateInfo; -typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures { - VkStructureType sType; - void* pNext; - VkBool32 pipelineCreationCacheControl; -} VkPhysicalDevicePipelineCreationCacheControlFeatures; - typedef struct VkMemoryBarrier2 { VkStructureType sType; const void* pNext; @@ -7349,18 +7418,6 @@ typedef struct VkPhysicalDeviceSynchronization2Features { VkBool32 synchronization2; } VkPhysicalDeviceSynchronization2Features; -typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderZeroInitializeWorkgroupMemory; -} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; - -typedef struct VkPhysicalDeviceImageRobustnessFeatures { - VkStructureType sType; - void* pNext; - VkBool32 robustImageAccess; -} VkPhysicalDeviceImageRobustnessFeatures; - typedef struct VkBufferCopy2 { VkStructureType sType; const void* pNext; @@ -7430,47 +7487,87 @@ typedef struct VkCopyImageToBufferInfo2 { const VkBufferImageCopy2* pRegions; } VkCopyImageToBufferInfo2; -typedef struct VkImageBlit2 { - VkStructureType sType; - const void* pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffsets[2]; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffsets[2]; -} VkImageBlit2; +typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures { + VkStructureType sType; + void* pNext; + VkBool32 textureCompressionASTC_HDR; +} VkPhysicalDeviceTextureCompressionASTCHDRFeatures; -typedef struct VkBlitImageInfo2 { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageBlit2* pRegions; - VkFilter filter; -} VkBlitImageInfo2; +typedef struct VkFormatProperties3 { + VkStructureType sType; + void* pNext; + VkFormatFeatureFlags2 linearTilingFeatures; + VkFormatFeatureFlags2 optimalTilingFeatures; + VkFormatFeatureFlags2 bufferFeatures; +} VkFormatProperties3; -typedef struct VkImageResolve2 { +typedef struct VkPhysicalDeviceMaintenance4Features { + VkStructureType sType; + void* pNext; + VkBool32 maintenance4; +} VkPhysicalDeviceMaintenance4Features; + +typedef struct VkPhysicalDeviceMaintenance4Properties { + VkStructureType sType; + void* pNext; + VkDeviceSize maxBufferSize; +} VkPhysicalDeviceMaintenance4Properties; + +typedef struct VkDeviceBufferMemoryRequirements { + VkStructureType sType; + const void* pNext; + const VkBufferCreateInfo* pCreateInfo; +} VkDeviceBufferMemoryRequirements; + +typedef struct VkDeviceImageMemoryRequirements { VkStructureType sType; const void* pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageResolve2; + const VkImageCreateInfo* pCreateInfo; + VkImageAspectFlagBits planeAspect; +} VkDeviceImageMemoryRequirements; -typedef struct VkResolveImageInfo2 { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageResolve2* pRegions; -} VkResolveImageInfo2; +typedef struct VkPipelineCreationFeedback { + VkPipelineCreationFeedbackFlags flags; + uint64_t duration; +} VkPipelineCreationFeedback; + +typedef struct VkPipelineCreationFeedbackCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreationFeedback* pPipelineCreationFeedback; + uint32_t pipelineStageCreationFeedbackCount; + VkPipelineCreationFeedback* pPipelineStageCreationFeedbacks; +} VkPipelineCreationFeedbackCreateInfo; + +typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderTerminateInvocation; +} VkPhysicalDeviceShaderTerminateInvocationFeatures; + +typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderDemoteToHelperInvocation; +} VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures; + +typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures { + VkStructureType sType; + void* pNext; + VkBool32 pipelineCreationCacheControl; +} VkPhysicalDevicePipelineCreationCacheControlFeatures; + +typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderZeroInitializeWorkgroupMemory; +} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + +typedef struct VkPhysicalDeviceImageRobustnessFeatures { + VkStructureType sType; + void* pNext; + VkBool32 robustImageAccess; +} VkPhysicalDeviceImageRobustnessFeatures; typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures { VkStructureType sType; @@ -7490,7 +7587,7 @@ typedef struct VkPhysicalDeviceSubgroupSizeControlProperties { typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo { VkStructureType sType; - void* pNext; + const void* pNext; uint32_t requiredSubgroupSize; } VkPipelineShaderStageRequiredSubgroupSizeCreateInfo; @@ -7524,11 +7621,97 @@ typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo { uint32_t maxInlineUniformBlockBindings; } VkDescriptorPoolInlineUniformBlockCreateInfo; -typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures { +typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures { VkStructureType sType; void* pNext; - VkBool32 textureCompressionASTC_HDR; -} VkPhysicalDeviceTextureCompressionASTCHDRFeatures; + VkBool32 shaderIntegerDotProduct; +} VkPhysicalDeviceShaderIntegerDotProductFeatures; + +typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties { + VkStructureType sType; + void* pNext; + VkBool32 integerDotProduct8BitUnsignedAccelerated; + VkBool32 integerDotProduct8BitSignedAccelerated; + VkBool32 integerDotProduct8BitMixedSignednessAccelerated; + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProduct16BitUnsignedAccelerated; + VkBool32 integerDotProduct16BitSignedAccelerated; + VkBool32 integerDotProduct16BitMixedSignednessAccelerated; + VkBool32 integerDotProduct32BitUnsignedAccelerated; + VkBool32 integerDotProduct32BitSignedAccelerated; + VkBool32 integerDotProduct32BitMixedSignednessAccelerated; + VkBool32 integerDotProduct64BitUnsignedAccelerated; + VkBool32 integerDotProduct64BitSignedAccelerated; + VkBool32 integerDotProduct64BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; +} VkPhysicalDeviceShaderIntegerDotProductProperties; + +typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties { + VkStructureType sType; + void* pNext; + VkDeviceSize storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; +} VkPhysicalDeviceTexelBufferAlignmentProperties; + +typedef struct VkImageBlit2 { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit2; + +typedef struct VkBlitImageInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageBlit2* pRegions; + VkFilter filter; +} VkBlitImageInfo2; + +typedef struct VkImageResolve2 { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve2; + +typedef struct VkResolveImageInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageResolve2* pRegions; +} VkResolveImageInfo2; typedef struct VkRenderingAttachmentInfo { VkStructureType sType; @@ -7584,97 +7767,11 @@ typedef struct VkCommandBufferInheritanceRenderingInfo { VkSampleCountFlagBits rasterizationSamples; } VkCommandBufferInheritanceRenderingInfo; -typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderIntegerDotProduct; -} VkPhysicalDeviceShaderIntegerDotProductFeatures; - -typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties { - VkStructureType sType; - void* pNext; - VkBool32 integerDotProduct8BitUnsignedAccelerated; - VkBool32 integerDotProduct8BitSignedAccelerated; - VkBool32 integerDotProduct8BitMixedSignednessAccelerated; - VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProduct16BitUnsignedAccelerated; - VkBool32 integerDotProduct16BitSignedAccelerated; - VkBool32 integerDotProduct16BitMixedSignednessAccelerated; - VkBool32 integerDotProduct32BitUnsignedAccelerated; - VkBool32 integerDotProduct32BitSignedAccelerated; - VkBool32 integerDotProduct32BitMixedSignednessAccelerated; - VkBool32 integerDotProduct64BitUnsignedAccelerated; - VkBool32 integerDotProduct64BitSignedAccelerated; - VkBool32 integerDotProduct64BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; -} VkPhysicalDeviceShaderIntegerDotProductProperties; - -typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties { - VkStructureType sType; - void* pNext; - VkDeviceSize storageTexelBufferOffsetAlignmentBytes; - VkBool32 storageTexelBufferOffsetSingleTexelAlignment; - VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; - VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; -} VkPhysicalDeviceTexelBufferAlignmentProperties; - -typedef struct VkFormatProperties3 { - VkStructureType sType; - void* pNext; - VkFormatFeatureFlags2 linearTilingFeatures; - VkFormatFeatureFlags2 optimalTilingFeatures; - VkFormatFeatureFlags2 bufferFeatures; -} VkFormatProperties3; - -typedef struct VkPhysicalDeviceMaintenance4Features { - VkStructureType sType; - void* pNext; - VkBool32 maintenance4; -} VkPhysicalDeviceMaintenance4Features; - -typedef struct VkPhysicalDeviceMaintenance4Properties { - VkStructureType sType; - void* pNext; - VkDeviceSize maxBufferSize; -} VkPhysicalDeviceMaintenance4Properties; - -typedef struct VkDeviceBufferMemoryRequirements { - VkStructureType sType; - const void* pNext; - const VkBufferCreateInfo* pCreateInfo; -} VkDeviceBufferMemoryRequirements; - -typedef struct VkDeviceImageMemoryRequirements { - VkStructureType sType; - const void* pNext; - const VkImageCreateInfo* pCreateInfo; - VkImageAspectFlagBits planeAspect; -} VkDeviceImageMemoryRequirements; - typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolProperties)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlot)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlot)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); typedef void (VKAPI_PTR *PFN_vkGetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); -typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); -typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); -typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); @@ -7682,6 +7779,12 @@ typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2)(VkCommandBuffer commandBuffer, co typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +typedef void (VKAPI_PTR *PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetDeviceImageMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); typedef void (VKAPI_PTR *PFN_vkCmdBeginRendering)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); @@ -7701,9 +7804,6 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOp)(VkCommandBuffer commandBuffer, V typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); -typedef void (VKAPI_PTR *PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetDeviceImageMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); #ifndef VK_NO_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolProperties( @@ -7736,22 +7836,6 @@ VKAPI_ATTR void VKAPI_CALL vkGetPrivateData( VkPrivateDataSlot privateDataSlot, uint64_t* pData); -VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2( - VkCommandBuffer commandBuffer, - VkEvent event, - const VkDependencyInfo* pDependencyInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags2 stageMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - const VkDependencyInfo* pDependencyInfos); - VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2( VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); @@ -7784,6 +7868,38 @@ VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirements( + VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfo* pDependencyInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2 stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos); + VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2( VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); @@ -7869,22 +7985,6 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnable( VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnable( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirements( - VkDevice device, - const VkDeviceBufferMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirements( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirements( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); #endif @@ -7916,100 +8016,46 @@ typedef enum VkPipelineRobustnessImageBehavior { VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED, VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS, VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2, - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF -} VkPipelineRobustnessImageBehavior; - -typedef enum VkQueueGlobalPriority { - VK_QUEUE_GLOBAL_PRIORITY_LOW = 128, - VK_QUEUE_GLOBAL_PRIORITY_MEDIUM = 256, - VK_QUEUE_GLOBAL_PRIORITY_HIGH = 512, - VK_QUEUE_GLOBAL_PRIORITY_REALTIME = 1024, - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW, - VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, - VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = VK_QUEUE_GLOBAL_PRIORITY_HIGH, - VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME, - VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR = VK_QUEUE_GLOBAL_PRIORITY_LOW, - VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, - VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR = VK_QUEUE_GLOBAL_PRIORITY_HIGH, - VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR = VK_QUEUE_GLOBAL_PRIORITY_REALTIME, - VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM = 0x7FFFFFFF -} VkQueueGlobalPriority; - -typedef enum VkLineRasterizationMode { - VK_LINE_RASTERIZATION_MODE_DEFAULT = 0, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR = 1, - VK_LINE_RASTERIZATION_MODE_BRESENHAM = 2, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH = 3, - VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR, - VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = VK_LINE_RASTERIZATION_MODE_BRESENHAM, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, - VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR = VK_LINE_RASTERIZATION_MODE_DEFAULT, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR, - VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR = VK_LINE_RASTERIZATION_MODE_BRESENHAM, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, - VK_LINE_RASTERIZATION_MODE_MAX_ENUM = 0x7FFFFFFF -} VkLineRasterizationMode; - -typedef enum VkMemoryUnmapFlagBits { - VK_MEMORY_UNMAP_RESERVE_BIT_EXT = 0x00000001, - VK_MEMORY_UNMAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryUnmapFlagBits; -typedef VkFlags VkMemoryUnmapFlags; -typedef VkFlags64 VkPipelineCreateFlags2; - -// Flag bits for VkPipelineCreateFlagBits2 -typedef VkFlags64 VkPipelineCreateFlagBits2; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT = 0x00000001ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT = 0x00000002ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DERIVATIVE_BIT = 0x00000004ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT = 0x00000010ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0x00000100ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT = 0x00000200ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT = 0x08000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT = 0x40000000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX = 0x100000000ULL; -#endif -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR = 0x00001000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV = 0x200000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = 0x00000001ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR = 0x00000002ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR = 0x00000004ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 0x00000008ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR = 0x00000010ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV = 0x00000020ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR = 0x00000040ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR = 0x00000100ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR = 0x00000200ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR = 0x00000800ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV = 0x00040000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM = 0x2000000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ULL; + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} VkPipelineRobustnessImageBehavior; + +typedef enum VkQueueGlobalPriority { + VK_QUEUE_GLOBAL_PRIORITY_LOW = 128, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM = 256, + VK_QUEUE_GLOBAL_PRIORITY_HIGH = 512, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME = 1024, + VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = VK_QUEUE_GLOBAL_PRIORITY_HIGH, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME, + VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR = VK_QUEUE_GLOBAL_PRIORITY_LOW, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR = VK_QUEUE_GLOBAL_PRIORITY_HIGH, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR = VK_QUEUE_GLOBAL_PRIORITY_REALTIME, + VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM = 0x7FFFFFFF +} VkQueueGlobalPriority; + +typedef enum VkLineRasterizationMode { + VK_LINE_RASTERIZATION_MODE_DEFAULT = 0, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR = 1, + VK_LINE_RASTERIZATION_MODE_BRESENHAM = 2, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH = 3, + VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR, + VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = VK_LINE_RASTERIZATION_MODE_BRESENHAM, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, + VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR = VK_LINE_RASTERIZATION_MODE_DEFAULT, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR, + VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR = VK_LINE_RASTERIZATION_MODE_BRESENHAM, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, + VK_LINE_RASTERIZATION_MODE_MAX_ENUM = 0x7FFFFFFF +} VkLineRasterizationMode; +typedef enum VkMemoryUnmapFlagBits { + VK_MEMORY_UNMAP_RESERVE_BIT_EXT = 0x00000001, + VK_MEMORY_UNMAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryUnmapFlagBits; +typedef VkFlags VkMemoryUnmapFlags; typedef VkFlags64 VkBufferUsageFlags2; // Flag bits for VkBufferUsageFlagBits2 @@ -8053,20 +8099,81 @@ static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL; +#ifdef VK_ENABLE_BETA_EXTENSIONS +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX = 0x200000000ULL; +#endif +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM = 0x20000000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM = 0x08000000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT = 0x100000000ULL; static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT = 0x80000000ULL; typedef enum VkHostImageCopyFlagBits { VK_HOST_IMAGE_COPY_MEMCPY_BIT = 0x00000001, - // VK_HOST_IMAGE_COPY_MEMCPY is a deprecated alias + // VK_HOST_IMAGE_COPY_MEMCPY is a legacy alias VK_HOST_IMAGE_COPY_MEMCPY = VK_HOST_IMAGE_COPY_MEMCPY_BIT, VK_HOST_IMAGE_COPY_MEMCPY_BIT_EXT = VK_HOST_IMAGE_COPY_MEMCPY_BIT, - // VK_HOST_IMAGE_COPY_MEMCPY_EXT is a deprecated alias + // VK_HOST_IMAGE_COPY_MEMCPY_EXT is a legacy alias VK_HOST_IMAGE_COPY_MEMCPY_EXT = VK_HOST_IMAGE_COPY_MEMCPY_BIT, VK_HOST_IMAGE_COPY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkHostImageCopyFlagBits; typedef VkFlags VkHostImageCopyFlags; +typedef VkFlags64 VkPipelineCreateFlags2; + +// Flag bits for VkPipelineCreateFlagBits2 +typedef VkFlags64 VkPipelineCreateFlagBits2; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT = 0x00000001ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT = 0x00000002ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DERIVATIVE_BIT = 0x00000004ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT = 0x00000010ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0x00000100ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT = 0x00000200ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT = 0x08000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT = 0x40000000ULL; +#ifdef VK_ENABLE_BETA_EXTENSIONS +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX = 0x100000000ULL; +#endif +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR = 0x00001000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV = 0x200000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = 0x00000001ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR = 0x00000002ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR = 0x00000004ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 0x00000008ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR = 0x00000010ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV = 0x00000020ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR = 0x00000040ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR = 0x00000100ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR = 0x00000200ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR = 0x00000800ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV = 0x00040000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM = 0x2000000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x10000000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT = 0x80000000000ULL; + typedef struct VkPhysicalDeviceVulkan14Features { VkStructureType sType; void* pNext; @@ -8142,144 +8249,201 @@ typedef struct VkQueueFamilyGlobalPriorityProperties { VkQueueGlobalPriority priorities[VK_MAX_GLOBAL_PRIORITY_SIZE]; } VkQueueFamilyGlobalPriorityProperties; -typedef struct VkPhysicalDeviceShaderSubgroupRotateFeatures { +typedef struct VkPhysicalDeviceIndexTypeUint8Features { VkStructureType sType; void* pNext; - VkBool32 shaderSubgroupRotate; - VkBool32 shaderSubgroupRotateClustered; -} VkPhysicalDeviceShaderSubgroupRotateFeatures; + VkBool32 indexTypeUint8; +} VkPhysicalDeviceIndexTypeUint8Features; -typedef struct VkPhysicalDeviceShaderFloatControls2Features { +typedef struct VkMemoryMapInfo { + VkStructureType sType; + const void* pNext; + VkMemoryMapFlags flags; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMemoryMapInfo; + +typedef struct VkMemoryUnmapInfo { + VkStructureType sType; + const void* pNext; + VkMemoryUnmapFlags flags; + VkDeviceMemory memory; +} VkMemoryUnmapInfo; + +typedef struct VkPhysicalDeviceMaintenance5Features { VkStructureType sType; void* pNext; - VkBool32 shaderFloatControls2; -} VkPhysicalDeviceShaderFloatControls2Features; + VkBool32 maintenance5; +} VkPhysicalDeviceMaintenance5Features; -typedef struct VkPhysicalDeviceShaderExpectAssumeFeatures { +typedef struct VkPhysicalDeviceMaintenance5Properties { VkStructureType sType; void* pNext; - VkBool32 shaderExpectAssume; -} VkPhysicalDeviceShaderExpectAssumeFeatures; + VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; + VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; + VkBool32 depthStencilSwizzleOneSupport; + VkBool32 polygonModePointSize; + VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; + VkBool32 nonStrictWideLinesUseParallelogram; +} VkPhysicalDeviceMaintenance5Properties; -typedef struct VkPhysicalDeviceLineRasterizationFeatures { +typedef struct VkImageSubresource2 { + VkStructureType sType; + void* pNext; + VkImageSubresource imageSubresource; +} VkImageSubresource2; + +typedef struct VkDeviceImageSubresourceInfo { + VkStructureType sType; + const void* pNext; + const VkImageCreateInfo* pCreateInfo; + const VkImageSubresource2* pSubresource; +} VkDeviceImageSubresourceInfo; + +typedef struct VkSubresourceLayout2 { + VkStructureType sType; + void* pNext; + VkSubresourceLayout subresourceLayout; +} VkSubresourceLayout2; + +typedef struct VkBufferUsageFlags2CreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferUsageFlags2 usage; +} VkBufferUsageFlags2CreateInfo; + +typedef struct VkPhysicalDeviceMaintenance6Features { VkStructureType sType; void* pNext; - VkBool32 rectangularLines; - VkBool32 bresenhamLines; - VkBool32 smoothLines; - VkBool32 stippledRectangularLines; - VkBool32 stippledBresenhamLines; - VkBool32 stippledSmoothLines; -} VkPhysicalDeviceLineRasterizationFeatures; + VkBool32 maintenance6; +} VkPhysicalDeviceMaintenance6Features; -typedef struct VkPhysicalDeviceLineRasterizationProperties { +typedef struct VkPhysicalDeviceMaintenance6Properties { VkStructureType sType; void* pNext; - uint32_t lineSubPixelPrecisionBits; -} VkPhysicalDeviceLineRasterizationProperties; + VkBool32 blockTexelViewCompatibleMultipleLayers; + uint32_t maxCombinedImageSamplerDescriptorCount; + VkBool32 fragmentShadingRateClampCombinerInputs; +} VkPhysicalDeviceMaintenance6Properties; + +typedef struct VkBindMemoryStatus { + VkStructureType sType; + const void* pNext; + VkResult* pResult; +} VkBindMemoryStatus; + +typedef struct VkPhysicalDeviceHostImageCopyFeatures { + VkStructureType sType; + void* pNext; + VkBool32 hostImageCopy; +} VkPhysicalDeviceHostImageCopyFeatures; + +typedef struct VkPhysicalDeviceHostImageCopyProperties { + VkStructureType sType; + void* pNext; + uint32_t copySrcLayoutCount; + VkImageLayout* pCopySrcLayouts; + uint32_t copyDstLayoutCount; + VkImageLayout* pCopyDstLayouts; + uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; + VkBool32 identicalMemoryTypeRequirements; +} VkPhysicalDeviceHostImageCopyProperties; + +typedef struct VkMemoryToImageCopy { + VkStructureType sType; + const void* pNext; + const void* pHostPointer; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkMemoryToImageCopy; + +typedef struct VkImageToMemoryCopy { + VkStructureType sType; + const void* pNext; + void* pHostPointer; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkImageToMemoryCopy; + +typedef struct VkCopyMemoryToImageInfo { + VkStructureType sType; + const void* pNext; + VkHostImageCopyFlags flags; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkMemoryToImageCopy* pRegions; +} VkCopyMemoryToImageInfo; + +typedef struct VkCopyImageToMemoryInfo { + VkStructureType sType; + const void* pNext; + VkHostImageCopyFlags flags; + VkImage srcImage; + VkImageLayout srcImageLayout; + uint32_t regionCount; + const VkImageToMemoryCopy* pRegions; +} VkCopyImageToMemoryInfo; + +typedef struct VkCopyImageToImageInfo { + VkStructureType sType; + const void* pNext; + VkHostImageCopyFlags flags; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageCopy2* pRegions; +} VkCopyImageToImageInfo; -typedef struct VkPipelineRasterizationLineStateCreateInfo { +typedef struct VkHostImageLayoutTransitionInfo { VkStructureType sType; const void* pNext; - VkLineRasterizationMode lineRasterizationMode; - VkBool32 stippledLineEnable; - uint32_t lineStippleFactor; - uint16_t lineStipplePattern; -} VkPipelineRasterizationLineStateCreateInfo; + VkImage image; + VkImageLayout oldLayout; + VkImageLayout newLayout; + VkImageSubresourceRange subresourceRange; +} VkHostImageLayoutTransitionInfo; -typedef struct VkPhysicalDeviceVertexAttributeDivisorProperties { +typedef struct VkSubresourceHostMemcpySize { VkStructureType sType; void* pNext; - uint32_t maxVertexAttribDivisor; - VkBool32 supportsNonZeroFirstInstance; -} VkPhysicalDeviceVertexAttributeDivisorProperties; - -typedef struct VkVertexInputBindingDivisorDescription { - uint32_t binding; - uint32_t divisor; -} VkVertexInputBindingDivisorDescription; - -typedef struct VkPipelineVertexInputDivisorStateCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t vertexBindingDivisorCount; - const VkVertexInputBindingDivisorDescription* pVertexBindingDivisors; -} VkPipelineVertexInputDivisorStateCreateInfo; + VkDeviceSize size; +} VkSubresourceHostMemcpySize; -typedef struct VkPhysicalDeviceVertexAttributeDivisorFeatures { +typedef struct VkHostImageCopyDevicePerformanceQuery { VkStructureType sType; void* pNext; - VkBool32 vertexAttributeInstanceRateDivisor; - VkBool32 vertexAttributeInstanceRateZeroDivisor; -} VkPhysicalDeviceVertexAttributeDivisorFeatures; + VkBool32 optimalDeviceAccess; + VkBool32 identicalMemoryLayout; +} VkHostImageCopyDevicePerformanceQuery; -typedef struct VkPhysicalDeviceIndexTypeUint8Features { +typedef struct VkPhysicalDeviceShaderSubgroupRotateFeatures { VkStructureType sType; void* pNext; - VkBool32 indexTypeUint8; -} VkPhysicalDeviceIndexTypeUint8Features; - -typedef struct VkMemoryMapInfo { - VkStructureType sType; - const void* pNext; - VkMemoryMapFlags flags; - VkDeviceMemory memory; - VkDeviceSize offset; - VkDeviceSize size; -} VkMemoryMapInfo; - -typedef struct VkMemoryUnmapInfo { - VkStructureType sType; - const void* pNext; - VkMemoryUnmapFlags flags; - VkDeviceMemory memory; -} VkMemoryUnmapInfo; + VkBool32 shaderSubgroupRotate; + VkBool32 shaderSubgroupRotateClustered; +} VkPhysicalDeviceShaderSubgroupRotateFeatures; -typedef struct VkPhysicalDeviceMaintenance5Features { +typedef struct VkPhysicalDeviceShaderFloatControls2Features { VkStructureType sType; void* pNext; - VkBool32 maintenance5; -} VkPhysicalDeviceMaintenance5Features; + VkBool32 shaderFloatControls2; +} VkPhysicalDeviceShaderFloatControls2Features; -typedef struct VkPhysicalDeviceMaintenance5Properties { +typedef struct VkPhysicalDeviceShaderExpectAssumeFeatures { VkStructureType sType; void* pNext; - VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; - VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; - VkBool32 depthStencilSwizzleOneSupport; - VkBool32 polygonModePointSize; - VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; - VkBool32 nonStrictWideLinesUseParallelogram; -} VkPhysicalDeviceMaintenance5Properties; - -typedef struct VkRenderingAreaInfo { - VkStructureType sType; - const void* pNext; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkFormat* pColorAttachmentFormats; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; -} VkRenderingAreaInfo; - -typedef struct VkImageSubresource2 { - VkStructureType sType; - void* pNext; - VkImageSubresource imageSubresource; -} VkImageSubresource2; - -typedef struct VkDeviceImageSubresourceInfo { - VkStructureType sType; - const void* pNext; - const VkImageCreateInfo* pCreateInfo; - const VkImageSubresource2* pSubresource; -} VkDeviceImageSubresourceInfo; - -typedef struct VkSubresourceLayout2 { - VkStructureType sType; - void* pNext; - VkSubresourceLayout subresourceLayout; -} VkSubresourceLayout2; + VkBool32 shaderExpectAssume; +} VkPhysicalDeviceShaderExpectAssumeFeatures; typedef struct VkPipelineCreateFlags2CreateInfo { VkStructureType sType; @@ -8287,60 +8451,12 @@ typedef struct VkPipelineCreateFlags2CreateInfo { VkPipelineCreateFlags2 flags; } VkPipelineCreateFlags2CreateInfo; -typedef struct VkBufferUsageFlags2CreateInfo { - VkStructureType sType; - const void* pNext; - VkBufferUsageFlags2 usage; -} VkBufferUsageFlags2CreateInfo; - typedef struct VkPhysicalDevicePushDescriptorProperties { VkStructureType sType; void* pNext; uint32_t maxPushDescriptors; } VkPhysicalDevicePushDescriptorProperties; -typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures { - VkStructureType sType; - void* pNext; - VkBool32 dynamicRenderingLocalRead; -} VkPhysicalDeviceDynamicRenderingLocalReadFeatures; - -typedef struct VkRenderingAttachmentLocationInfo { - VkStructureType sType; - const void* pNext; - uint32_t colorAttachmentCount; - const uint32_t* pColorAttachmentLocations; -} VkRenderingAttachmentLocationInfo; - -typedef struct VkRenderingInputAttachmentIndexInfo { - VkStructureType sType; - const void* pNext; - uint32_t colorAttachmentCount; - const uint32_t* pColorAttachmentInputIndices; - const uint32_t* pDepthInputAttachmentIndex; - const uint32_t* pStencilInputAttachmentIndex; -} VkRenderingInputAttachmentIndexInfo; - -typedef struct VkPhysicalDeviceMaintenance6Features { - VkStructureType sType; - void* pNext; - VkBool32 maintenance6; -} VkPhysicalDeviceMaintenance6Features; - -typedef struct VkPhysicalDeviceMaintenance6Properties { - VkStructureType sType; - void* pNext; - VkBool32 blockTexelViewCompatibleMultipleLayers; - uint32_t maxCombinedImageSamplerDescriptorCount; - VkBool32 fragmentShadingRateClampCombinerInputs; -} VkPhysicalDeviceMaintenance6Properties; - -typedef struct VkBindMemoryStatus { - VkStructureType sType; - const void* pNext; - VkResult* pResult; -} VkBindMemoryStatus; - typedef struct VkBindDescriptorSetsInfo { VkStructureType sType; const void* pNext; @@ -8412,125 +8528,111 @@ typedef struct VkPipelineRobustnessCreateInfo { VkPipelineRobustnessImageBehavior images; } VkPipelineRobustnessCreateInfo; -typedef struct VkPhysicalDeviceHostImageCopyFeatures { +typedef struct VkPhysicalDeviceLineRasterizationFeatures { VkStructureType sType; void* pNext; - VkBool32 hostImageCopy; -} VkPhysicalDeviceHostImageCopyFeatures; + VkBool32 rectangularLines; + VkBool32 bresenhamLines; + VkBool32 smoothLines; + VkBool32 stippledRectangularLines; + VkBool32 stippledBresenhamLines; + VkBool32 stippledSmoothLines; +} VkPhysicalDeviceLineRasterizationFeatures; -typedef struct VkPhysicalDeviceHostImageCopyProperties { +typedef struct VkPhysicalDeviceLineRasterizationProperties { VkStructureType sType; void* pNext; - uint32_t copySrcLayoutCount; - VkImageLayout* pCopySrcLayouts; - uint32_t copyDstLayoutCount; - VkImageLayout* pCopyDstLayouts; - uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; - VkBool32 identicalMemoryTypeRequirements; -} VkPhysicalDeviceHostImageCopyProperties; - -typedef struct VkMemoryToImageCopy { - VkStructureType sType; - const void* pNext; - const void* pHostPointer; - uint32_t memoryRowLength; - uint32_t memoryImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkMemoryToImageCopy; - -typedef struct VkImageToMemoryCopy { - VkStructureType sType; - const void* pNext; - void* pHostPointer; - uint32_t memoryRowLength; - uint32_t memoryImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkImageToMemoryCopy; - -typedef struct VkCopyMemoryToImageInfo { - VkStructureType sType; - const void* pNext; - VkHostImageCopyFlags flags; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkMemoryToImageCopy* pRegions; -} VkCopyMemoryToImageInfo; - -typedef struct VkCopyImageToMemoryInfo { - VkStructureType sType; - const void* pNext; - VkHostImageCopyFlags flags; - VkImage srcImage; - VkImageLayout srcImageLayout; - uint32_t regionCount; - const VkImageToMemoryCopy* pRegions; -} VkCopyImageToMemoryInfo; - -typedef struct VkCopyImageToImageInfo { - VkStructureType sType; - const void* pNext; - VkHostImageCopyFlags flags; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageCopy2* pRegions; -} VkCopyImageToImageInfo; + uint32_t lineSubPixelPrecisionBits; +} VkPhysicalDeviceLineRasterizationProperties; -typedef struct VkHostImageLayoutTransitionInfo { +typedef struct VkPipelineRasterizationLineStateCreateInfo { VkStructureType sType; const void* pNext; - VkImage image; - VkImageLayout oldLayout; - VkImageLayout newLayout; - VkImageSubresourceRange subresourceRange; -} VkHostImageLayoutTransitionInfo; + VkLineRasterizationMode lineRasterizationMode; + VkBool32 stippledLineEnable; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; +} VkPipelineRasterizationLineStateCreateInfo; + +typedef struct VkPhysicalDeviceVertexAttributeDivisorProperties { + VkStructureType sType; + void* pNext; + uint32_t maxVertexAttribDivisor; + VkBool32 supportsNonZeroFirstInstance; +} VkPhysicalDeviceVertexAttributeDivisorProperties; + +typedef struct VkVertexInputBindingDivisorDescription { + uint32_t binding; + uint32_t divisor; +} VkVertexInputBindingDivisorDescription; -typedef struct VkSubresourceHostMemcpySize { +typedef struct VkPipelineVertexInputDivisorStateCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t vertexBindingDivisorCount; + const VkVertexInputBindingDivisorDescription* pVertexBindingDivisors; +} VkPipelineVertexInputDivisorStateCreateInfo; + +typedef struct VkPhysicalDeviceVertexAttributeDivisorFeatures { VkStructureType sType; void* pNext; - VkDeviceSize size; -} VkSubresourceHostMemcpySize; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; +} VkPhysicalDeviceVertexAttributeDivisorFeatures; -typedef struct VkHostImageCopyDevicePerformanceQuery { +typedef struct VkRenderingAreaInfo { + VkStructureType sType; + const void* pNext; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; +} VkRenderingAreaInfo; + +typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures { VkStructureType sType; void* pNext; - VkBool32 optimalDeviceAccess; - VkBool32 identicalMemoryLayout; -} VkHostImageCopyDevicePerformanceQuery; + VkBool32 dynamicRenderingLocalRead; +} VkPhysicalDeviceDynamicRenderingLocalReadFeatures; + +typedef struct VkRenderingAttachmentLocationInfo { + VkStructureType sType; + const void* pNext; + uint32_t colorAttachmentCount; + const uint32_t* pColorAttachmentLocations; +} VkRenderingAttachmentLocationInfo; + +typedef struct VkRenderingInputAttachmentIndexInfo { + VkStructureType sType; + const void* pNext; + uint32_t colorAttachmentCount; + const uint32_t* pColorAttachmentInputIndices; + const uint32_t* pDepthInputAttachmentIndex; + const uint32_t* pStencilInputAttachmentIndex; +} VkRenderingInputAttachmentIndexInfo; -typedef void (VKAPI_PTR *PFN_vkCmdSetLineStipple)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); typedef VkResult (VKAPI_PTR *PFN_vkMapMemory2)(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData); typedef VkResult (VKAPI_PTR *PFN_vkUnmapMemory2)(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer2)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType); -typedef void (VKAPI_PTR *PFN_vkGetRenderingAreaGranularity)(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity); typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSubresourceLayout)(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout); typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2)(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToImage)(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToMemory)(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToImage)(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo); +typedef VkResult (VKAPI_PTR *PFN_vkTransitionImageLayout)(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions); typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSet)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplate)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingAttachmentLocations)(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo); -typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingInputAttachmentIndices)(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets2)(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); typedef void (VKAPI_PTR *PFN_vkCmdPushConstants2)(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo); typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSet2)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplate2)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToImage)(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToMemory)(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToImage)(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo); -typedef VkResult (VKAPI_PTR *PFN_vkTransitionImageLayout)(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineStipple)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer2)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType); +typedef void (VKAPI_PTR *PFN_vkGetRenderingAreaGranularity)(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity); +typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingAttachmentLocations)(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo); +typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingInputAttachmentIndices)(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); #ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStipple( - VkCommandBuffer commandBuffer, - uint32_t lineStippleFactor, - uint16_t lineStipplePattern); - VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2( VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, @@ -8540,18 +8642,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2( VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo); -VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkDeviceSize size, - VkIndexType indexType); - -VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularity( - VkDevice device, - const VkRenderingAreaInfo* pRenderingAreaInfo, - VkExtent2D* pGranularity); - VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayout( VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, @@ -8563,6 +8653,23 @@ VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2( const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout); +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImage( + VkDevice device, + const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemory( + VkDevice device, + const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImage( + VkDevice device, + const VkCopyImageToImageInfo* pCopyImageToImageInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayout( + VkDevice device, + uint32_t transitionCount, + const VkHostImageLayoutTransitionInfo* pTransitions); + VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, @@ -8578,14 +8685,6 @@ VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate( uint32_t set, const void* pData); -VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocations( - VkCommandBuffer commandBuffer, - const VkRenderingAttachmentLocationInfo* pLocationInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndices( - VkCommandBuffer commandBuffer, - const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); - VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2( VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); @@ -8602,22 +8701,30 @@ VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2( VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); -VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImage( - VkDevice device, - const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStipple( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern); -VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemory( - VkDevice device, - const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType); -VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImage( +VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularity( VkDevice device, - const VkCopyImageToImageInfo* pCopyImageToImageInfo); + const VkRenderingAreaInfo* pRenderingAreaInfo, + VkExtent2D* pGranularity); -VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayout( - VkDevice device, - uint32_t transitionCount, - const VkHostImageLayoutTransitionInfo* pTransitions); +VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocations( + VkCommandBuffer commandBuffer, + const VkRenderingAttachmentLocationInfo* pLocationInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndices( + VkCommandBuffer commandBuffer, + const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); #endif @@ -8634,7 +8741,8 @@ typedef enum VkPresentModeKHR { VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, - VK_PRESENT_MODE_FIFO_LATEST_READY_EXT = 1000361000, + VK_PRESENT_MODE_FIFO_LATEST_READY_KHR = 1000361000, + VK_PRESENT_MODE_FIFO_LATEST_READY_EXT = VK_PRESENT_MODE_FIFO_LATEST_READY_KHR, VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF } VkPresentModeKHR; @@ -8648,7 +8756,7 @@ typedef enum VkColorSpaceKHR { VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, - // VK_COLOR_SPACE_DOLBYVISION_EXT is deprecated, but no reason was given in the API XML + // VK_COLOR_SPACE_DOLBYVISION_EXT is legacy, but no reason was given in the API XML VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, @@ -8656,9 +8764,9 @@ typedef enum VkColorSpaceKHR { VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000, - // VK_COLORSPACE_SRGB_NONLINEAR_KHR is a deprecated alias + // VK_COLORSPACE_SRGB_NONLINEAR_KHR is a legacy alias VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, - // VK_COLOR_SPACE_DCI_P3_LINEAR_EXT is a deprecated alias + // VK_COLOR_SPACE_DCI_P3_LINEAR_EXT is a legacy alias VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF } VkColorSpaceKHR; @@ -8710,34 +8818,44 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysica typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); #endif +#endif // VK_KHR_swapchain is a preprocessor guard. Do not pass it to API calls. @@ -8750,9 +8868,10 @@ 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_PRESENT_ID_2_BIT_KHR = 0x00000040, VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR = 0x00000080, + VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR = 0x00000008, + VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR, VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkSwapchainCreateFlagBitsKHR; typedef VkFlags VkSwapchainCreateFlagsKHR; @@ -8852,23 +8971,30 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhys typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, @@ -8876,31 +9002,42 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR* pPresentInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); #endif +#endif // VK_KHR_display is a preprocessor guard. Do not pass it to API calls. @@ -8986,47 +9123,61 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDev typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif +#endif // VK_KHR_display_swapchain is a preprocessor guard. Do not pass it to API calls. @@ -9044,6 +9195,7 @@ typedef struct VkDisplayPresentInfoKHR { typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( VkDevice device, uint32_t swapchainCount, @@ -9051,6 +9203,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); #endif +#endif // VK_KHR_sampler_mirror_clamp_to_edge is a preprocessor guard. Do not pass it to API calls. @@ -9294,68 +9447,92 @@ typedef void (VKAPI_PTR *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuff typedef void (VKAPI_PTR *PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR( VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR( VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR( VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR( VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR( VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR( VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR( VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR( VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo); #endif +#endif // VK_KHR_video_decode_queue is a preprocessor guard. Do not pass it to API calls. @@ -9407,10 +9584,12 @@ typedef struct VkVideoDecodeInfoKHR { typedef void (VKAPI_PTR *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo); #endif +#endif // VK_KHR_video_encode_h264 is a preprocessor guard. Do not pass it to API calls. @@ -9430,6 +9609,7 @@ typedef enum VkVideoEncodeH264CapabilityFlagBitsKHR { VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR = 0x00000040, VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR = 0x00000080, VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR = 0x00000100, + VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR = 0x00000400, VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR = 0x00000200, VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoEncodeH264CapabilityFlagBitsKHR; @@ -9631,6 +9811,7 @@ typedef enum VkVideoEncodeH265CapabilityFlagBitsKHR { VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR = 0x00000080, VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR = 0x00000100, VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR = 0x00000200, + VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR = 0x00000800, VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR = 0x00000400, VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoEncodeH265CapabilityFlagBitsKHR; @@ -9921,13 +10102,17 @@ typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer typedef void (VKAPI_PTR *PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderingKHR( VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderingKHR( VkCommandBuffer commandBuffer); #endif +#endif // VK_KHR_multiview is a preprocessor guard. Do not pass it to API calls. @@ -9973,39 +10158,53 @@ typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysical typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); #endif +#endif // VK_KHR_device_group is a preprocessor guard. Do not pass it to API calls. @@ -10039,17 +10238,22 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffe typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer, uint32_t baseGroupX, @@ -10059,6 +10263,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR( uint32_t groupCountY, uint32_t groupCountZ); #endif +#endif // VK_KHR_shader_draw_parameters is a preprocessor guard. Do not pass it to API calls. @@ -10071,20 +10276,22 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR( #define VK_KHR_maintenance1 1 #define VK_KHR_MAINTENANCE_1_SPEC_VERSION 2 #define VK_KHR_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_maintenance1" -// VK_KHR_MAINTENANCE1_SPEC_VERSION is a deprecated alias +// VK_KHR_MAINTENANCE1_SPEC_VERSION is a legacy alias #define VK_KHR_MAINTENANCE1_SPEC_VERSION VK_KHR_MAINTENANCE_1_SPEC_VERSION -// VK_KHR_MAINTENANCE1_EXTENSION_NAME is a deprecated alias +// VK_KHR_MAINTENANCE1_EXTENSION_NAME is a legacy alias #define VK_KHR_MAINTENANCE1_EXTENSION_NAME VK_KHR_MAINTENANCE_1_EXTENSION_NAME typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR; typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); #endif +#endif // VK_KHR_device_group_creation is a preprocessor guard. Do not pass it to API calls. @@ -10099,11 +10306,13 @@ typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR; typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); #endif +#endif // VK_KHR_external_memory_capabilities is a preprocessor guard. Do not pass it to API calls. @@ -10134,11 +10343,13 @@ typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR; typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); #endif +#endif // VK_KHR_external_memory is a preprocessor guard. Do not pass it to API calls. @@ -10182,17 +10393,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemo typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); #endif +#endif // VK_KHR_external_semaphore_capabilities is a preprocessor guard. Do not pass it to API calls. @@ -10214,11 +10429,13 @@ typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR; typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); #endif +#endif // VK_KHR_external_semaphore is a preprocessor guard. Do not pass it to API calls. @@ -10257,15 +10474,19 @@ typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); #endif +#endif // VK_KHR_push_descriptor is a preprocessor guard. Do not pass it to API calls. @@ -10278,6 +10499,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandB typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, @@ -10285,7 +10507,9 @@ VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, @@ -10293,6 +10517,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( uint32_t set, const void* pData); #endif +#endif // VK_KHR_shader_float16_int8 is a preprocessor guard. Do not pass it to API calls. @@ -10356,23 +10581,29 @@ typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice devi typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); #endif +#endif // VK_KHR_imageless_framebuffer is a preprocessor guard. Do not pass it to API calls. @@ -10413,26 +10644,34 @@ typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR( VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); #endif +#endif // VK_KHR_shared_presentable_image is a preprocessor guard. Do not pass it to API calls. @@ -10448,10 +10687,12 @@ typedef struct VkSharedPresentSurfaceCapabilitiesKHR { typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain); #endif +#endif // VK_KHR_external_fence_capabilities is a preprocessor guard. Do not pass it to API calls. @@ -10473,11 +10714,13 @@ typedef VkExternalFenceProperties VkExternalFencePropertiesKHR; typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); #endif +#endif // VK_KHR_external_fence is a preprocessor guard. Do not pass it to API calls. @@ -10516,15 +10759,19 @@ typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkIm typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); #endif +#endif // VK_KHR_performance_query is a preprocessor guard. Do not pass it to API calls. @@ -10551,11 +10798,11 @@ typedef enum VkPerformanceCounterScopeKHR { VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0, VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1, VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2, - // VK_QUERY_SCOPE_COMMAND_BUFFER_KHR is a deprecated alias + // VK_QUERY_SCOPE_COMMAND_BUFFER_KHR is a legacy alias VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, - // VK_QUERY_SCOPE_RENDER_PASS_KHR is a deprecated alias + // VK_QUERY_SCOPE_RENDER_PASS_KHR is a legacy alias VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, - // VK_QUERY_SCOPE_COMMAND_KHR is a deprecated alias + // VK_QUERY_SCOPE_COMMAND_KHR is a legacy alias VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF } VkPerformanceCounterScopeKHR; @@ -10573,9 +10820,9 @@ typedef enum VkPerformanceCounterStorageKHR { typedef enum VkPerformanceCounterDescriptionFlagBitsKHR { VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0x00000001, VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0x00000002, - // VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR is a deprecated alias + // VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR is a legacy alias VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR, - // VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR is a deprecated alias + // VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR is a legacy alias VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR, VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkPerformanceCounterDescriptionFlagBitsKHR; @@ -10652,34 +10899,42 @@ typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, con typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR( VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR( VkDevice device); #endif +#endif // VK_KHR_maintenance2 is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_maintenance2 1 #define VK_KHR_MAINTENANCE_2_SPEC_VERSION 1 #define VK_KHR_MAINTENANCE_2_EXTENSION_NAME "VK_KHR_maintenance2" -// VK_KHR_MAINTENANCE2_SPEC_VERSION is a deprecated alias +// VK_KHR_MAINTENANCE2_SPEC_VERSION is a legacy alias #define VK_KHR_MAINTENANCE2_SPEC_VERSION VK_KHR_MAINTENANCE_2_SPEC_VERSION -// VK_KHR_MAINTENANCE2_EXTENSION_NAME is a deprecated alias +// VK_KHR_MAINTENANCE2_EXTENSION_NAME is a legacy alias #define VK_KHR_MAINTENANCE2_EXTENSION_NAME VK_KHR_MAINTENANCE_2_EXTENSION_NAME typedef VkPointClippingBehavior VkPointClippingBehaviorKHR; @@ -10723,17 +10978,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkP typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); #endif +#endif // VK_KHR_variable_pointers is a preprocessor guard. Do not pass it to API calls. @@ -10787,27 +11046,35 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevic typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); #endif +#endif // VK_KHR_dedicated_allocation is a preprocessor guard. Do not pass it to API calls. @@ -10865,22 +11132,28 @@ typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); #endif +#endif // VK_KHR_image_format_list is a preprocessor guard. Do not pass it to API calls. @@ -10919,17 +11192,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice dev typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); #endif +#endif // VK_KHR_bind_memory2 is a preprocessor guard. Do not pass it to API calls. @@ -10944,25 +11221,29 @@ typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32 typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); #endif +#endif // VK_KHR_maintenance3 is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_maintenance3 1 #define VK_KHR_MAINTENANCE_3_SPEC_VERSION 1 #define VK_KHR_MAINTENANCE_3_EXTENSION_NAME "VK_KHR_maintenance3" -// VK_KHR_MAINTENANCE3_SPEC_VERSION is a deprecated alias +// VK_KHR_MAINTENANCE3_SPEC_VERSION is a legacy alias #define VK_KHR_MAINTENANCE3_SPEC_VERSION VK_KHR_MAINTENANCE_3_SPEC_VERSION -// VK_KHR_MAINTENANCE3_EXTENSION_NAME is a deprecated alias +// VK_KHR_MAINTENANCE3_EXTENSION_NAME is a legacy alias #define VK_KHR_MAINTENANCE3_EXTENSION_NAME VK_KHR_MAINTENANCE_3_EXTENSION_NAME typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR; @@ -10971,11 +11252,13 @@ typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR; typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); #endif +#endif // VK_KHR_draw_indirect_count is a preprocessor guard. Do not pass it to API calls. @@ -10986,6 +11269,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandB typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, @@ -10994,7 +11278,9 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR( VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, @@ -11004,6 +11290,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR( uint32_t maxDrawCount, uint32_t stride); #endif +#endif // VK_KHR_shader_subgroup_extended_types is a preprocessor guard. Do not pass it to API calls. @@ -11182,20 +11469,26 @@ typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkS typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR( VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR( VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR( VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); #endif +#endif // VK_KHR_vulkan_memory_model is a preprocessor guard. Do not pass it to API calls. @@ -11290,16 +11583,20 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkP typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR( VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR( VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); #endif +#endif // VK_KHR_dynamic_rendering_local_read is a preprocessor guard. Do not pass it to API calls. @@ -11316,14 +11613,18 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingAttachmentLocationsKHR)(VkCommandB typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocationsKHR( VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR( VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); #endif +#endif // VK_KHR_shader_quad_control is a preprocessor guard. Do not pass it to API calls. @@ -11381,12 +11682,14 @@ typedef struct VkPhysicalDevicePresentWaitFeaturesKHR { typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout); #endif +#endif // VK_KHR_uniform_buffer_standard_layout is a preprocessor guard. Do not pass it to API calls. @@ -11416,18 +11719,24 @@ typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice de typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); #endif +#endif // VK_KHR_deferred_host_operations is a preprocessor guard. Do not pass it to API calls. @@ -11442,28 +11751,38 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice devic typedef VkResult (VKAPI_PTR *PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR( VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR( VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR( VkDevice device, VkDeferredOperationKHR operation); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR( VkDevice device, VkDeferredOperationKHR operation); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR( VkDevice device, VkDeferredOperationKHR operation); #endif +#endif // VK_KHR_pipeline_executable_properties is a preprocessor guard. Do not pass it to API calls. @@ -11537,24 +11856,30 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR( VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR( VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR( VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); #endif +#endif // VK_KHR_map_memory2 is a preprocessor guard. Do not pass it to API calls. @@ -11573,15 +11898,19 @@ typedef VkResult (VKAPI_PTR *PFN_vkMapMemory2KHR)(VkDevice device, const VkMemor typedef VkResult (VKAPI_PTR *PFN_vkUnmapMemory2KHR)(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2KHR( VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2KHR( VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo); #endif +#endif // VK_KHR_shader_integer_dot_product is a preprocessor guard. Do not pass it to API calls. @@ -11647,6 +11976,7 @@ typedef enum VkVideoEncodeTuningModeKHR { } VkVideoEncodeTuningModeKHR; typedef enum VkVideoEncodeFlagBitsKHR { + VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR = 0x00000004, VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x00000001, VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR = 0x00000002, VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF @@ -11795,22 +12125,28 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR( VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); #endif +#endif // VK_KHR_synchronization2 is a preprocessor guard. Do not pass it to API calls. @@ -11853,38 +12189,50 @@ typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR( VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); #endif +#endif // VK_KHR_fragment_shader_barycentric is a preprocessor guard. Do not pass it to API calls. @@ -11974,30 +12322,42 @@ typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR( VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR( VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR( VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); #endif +#endif // VK_KHR_format_feature_flags2 is a preprocessor guard. Do not pass it to API calls. @@ -12043,10 +12403,24 @@ typedef struct VkTraceRaysIndirectCommand2KHR { typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirect2KHR)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirect2KHR( VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress); #endif +#endif + + +// VK_KHR_shader_untyped_pointers is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_untyped_pointers 1 +#define VK_KHR_SHADER_UNTYPED_POINTERS_SPEC_VERSION 1 +#define VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME "VK_KHR_shader_untyped_pointers" +typedef struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderUntypedPointers; +} VkPhysicalDeviceShaderUntypedPointersFeaturesKHR; + // VK_KHR_portability_enumeration is a preprocessor guard. Do not pass it to API calls. @@ -12072,22 +12446,28 @@ typedef void (VKAPI_PTR *PFN_vkGetDeviceImageMemoryRequirementsKHR)(VkDevice dev typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR( VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR( VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR( VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); #endif +#endif // VK_KHR_shader_subgroup_rotate is a preprocessor guard. Do not pass it to API calls. @@ -12144,29 +12524,37 @@ typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSubresourceLayoutKHR)(VkDevice devi typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2KHR)(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2KHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularityKHR( VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayoutKHR( VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2KHR( VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout); #endif +#endif // VK_KHR_present_id2 is a preprocessor guard. Do not pass it to API calls. @@ -12220,11 +12608,13 @@ typedef struct VkPresentWait2InfoKHR { typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresent2KHR)(VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR* pPresentWait2Info); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresent2KHR( VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR* pPresentWait2Info); #endif +#endif // VK_KHR_ray_tracing_position_fetch is a preprocessor guard. Do not pass it to API calls. @@ -12331,34 +12721,153 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineBinaryDataKHR)(VkDevice device, co typedef VkResult (VKAPI_PTR *PFN_vkReleaseCapturedPipelineDataKHR)(VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineBinariesKHR( VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineBinaryHandlesInfoKHR* pBinaries); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineBinaryKHR( VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineKeyKHR( VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, VkPipelineBinaryKeyKHR* pPipelineKey); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineBinaryDataKHR( VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, VkPipelineBinaryKeyKHR* pPipelineBinaryKey, size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkReleaseCapturedPipelineDataKHR( VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator); #endif +#endif + + +// VK_KHR_surface_maintenance1 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_surface_maintenance1 1 +#define VK_KHR_SURFACE_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_surface_maintenance1" + +typedef enum VkPresentScalingFlagBitsKHR { + VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR = 0x00000001, + VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR = 0x00000002, + VK_PRESENT_SCALING_STRETCH_BIT_KHR = 0x00000004, + VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT = VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR, + VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT = VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR, + VK_PRESENT_SCALING_STRETCH_BIT_EXT = VK_PRESENT_SCALING_STRETCH_BIT_KHR, + VK_PRESENT_SCALING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPresentScalingFlagBitsKHR; +typedef VkFlags VkPresentScalingFlagsKHR; + +typedef enum VkPresentGravityFlagBitsKHR { + VK_PRESENT_GRAVITY_MIN_BIT_KHR = 0x00000001, + VK_PRESENT_GRAVITY_MAX_BIT_KHR = 0x00000002, + VK_PRESENT_GRAVITY_CENTERED_BIT_KHR = 0x00000004, + VK_PRESENT_GRAVITY_MIN_BIT_EXT = VK_PRESENT_GRAVITY_MIN_BIT_KHR, + VK_PRESENT_GRAVITY_MAX_BIT_EXT = VK_PRESENT_GRAVITY_MAX_BIT_KHR, + VK_PRESENT_GRAVITY_CENTERED_BIT_EXT = VK_PRESENT_GRAVITY_CENTERED_BIT_KHR, + VK_PRESENT_GRAVITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPresentGravityFlagBitsKHR; +typedef VkFlags VkPresentGravityFlagsKHR; +typedef struct VkSurfacePresentModeKHR { + VkStructureType sType; + void* pNext; + VkPresentModeKHR presentMode; +} VkSurfacePresentModeKHR; + +typedef struct VkSurfacePresentScalingCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkPresentScalingFlagsKHR supportedPresentScaling; + VkPresentGravityFlagsKHR supportedPresentGravityX; + VkPresentGravityFlagsKHR supportedPresentGravityY; + VkExtent2D minScaledImageExtent; + VkExtent2D maxScaledImageExtent; +} VkSurfacePresentScalingCapabilitiesKHR; + +typedef struct VkSurfacePresentModeCompatibilityKHR { + VkStructureType sType; + void* pNext; + uint32_t presentModeCount; + VkPresentModeKHR* pPresentModes; +} VkSurfacePresentModeCompatibilityKHR; + + + +// VK_KHR_swapchain_maintenance1 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_swapchain_maintenance1 1 +#define VK_KHR_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_swapchain_maintenance1" +typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 swapchainMaintenance1; +} VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR; + +typedef struct VkSwapchainPresentFenceInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkFence* pFences; +} VkSwapchainPresentFenceInfoKHR; + +typedef struct VkSwapchainPresentModesCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t presentModeCount; + const VkPresentModeKHR* pPresentModes; +} VkSwapchainPresentModesCreateInfoKHR; + +typedef struct VkSwapchainPresentModeInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentModeKHR* pPresentModes; +} VkSwapchainPresentModeInfoKHR; + +typedef struct VkSwapchainPresentScalingCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkPresentScalingFlagsKHR scalingBehavior; + VkPresentGravityFlagsKHR presentGravityX; + VkPresentGravityFlagsKHR presentGravityY; +} VkSwapchainPresentScalingCreateInfoKHR; + +typedef struct VkReleaseSwapchainImagesInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndexCount; + const uint32_t* pImageIndices; +} VkReleaseSwapchainImagesInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkReleaseSwapchainImagesKHR)(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesKHR( + VkDevice device, + const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); +#endif +#endif // VK_KHR_cooperative_matrix is a preprocessor guard. Do not pass it to API calls. @@ -12381,10 +12890,8 @@ typedef enum VkComponentTypeKHR { VK_COMPONENT_TYPE_BFLOAT16_KHR = 1000141000, VK_COMPONENT_TYPE_SINT8_PACKED_NV = 1000491000, VK_COMPONENT_TYPE_UINT8_PACKED_NV = 1000491001, - VK_COMPONENT_TYPE_FLOAT_E4M3_NV = 1000491002, - VK_COMPONENT_TYPE_FLOAT_E5M2_NV = 1000491003, - VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT = 1000567000, - VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT = 1000567001, + VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT = 1000491002, + VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT = 1000491003, VK_COMPONENT_TYPE_FLOAT16_NV = VK_COMPONENT_TYPE_FLOAT16_KHR, VK_COMPONENT_TYPE_FLOAT32_NV = VK_COMPONENT_TYPE_FLOAT32_KHR, VK_COMPONENT_TYPE_FLOAT64_NV = VK_COMPONENT_TYPE_FLOAT64_KHR, @@ -12396,6 +12903,8 @@ typedef enum VkComponentTypeKHR { VK_COMPONENT_TYPE_UINT16_NV = VK_COMPONENT_TYPE_UINT16_KHR, VK_COMPONENT_TYPE_UINT32_NV = VK_COMPONENT_TYPE_UINT32_KHR, VK_COMPONENT_TYPE_UINT64_NV = VK_COMPONENT_TYPE_UINT64_KHR, + VK_COMPONENT_TYPE_FLOAT_E4M3_NV = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT, + VK_COMPONENT_TYPE_FLOAT_E5M2_NV = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT, VK_COMPONENT_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF } VkComponentTypeKHR; @@ -12440,11 +12949,13 @@ typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR { typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties); #endif +#endif // VK_KHR_compute_shader_derivatives is a preprocessor guard. Do not pass it to API calls. @@ -12538,6 +13049,7 @@ typedef enum VkVideoEncodeAV1CapabilityFlagBitsKHR { VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR = 0x00000004, VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR = 0x00000008, VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR = 0x00000020, VK_VIDEO_ENCODE_AV1_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkVideoEncodeAV1CapabilityFlagBitsKHR; typedef VkFlags VkVideoEncodeAV1CapabilityFlagsKHR; @@ -12832,11 +13344,13 @@ typedef VkPipelineRasterizationLineStateCreateInfo VkPipelineRasterizationLineSt typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleKHR)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleKHR( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); #endif +#endif // VK_KHR_calibrated_timestamps is a preprocessor guard. Do not pass it to API calls. @@ -12865,11 +13379,14 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR) typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsKHR)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR( VkDevice device, uint32_t timestampCount, @@ -12877,6 +13394,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR( uint64_t* pTimestamps, uint64_t* pMaxDeviation); #endif +#endif // VK_KHR_shader_expect_assume is a preprocessor guard. Do not pass it to API calls. @@ -12932,30 +13450,177 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetDescriptorBufferOffsets2EXT)(VkCommandBuffe typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2KHR( VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2KHR( VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2KHR( VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2KHR( VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsets2EXT( VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); #endif +#endif + + +// VK_KHR_copy_memory_indirect is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_copy_memory_indirect 1 +#define VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION 1 +#define VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME "VK_KHR_copy_memory_indirect" + +typedef enum VkAddressCopyFlagBitsKHR { + VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR = 0x00000001, + VK_ADDRESS_COPY_SPARSE_BIT_KHR = 0x00000002, + VK_ADDRESS_COPY_PROTECTED_BIT_KHR = 0x00000004, + VK_ADDRESS_COPY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAddressCopyFlagBitsKHR; +typedef VkFlags VkAddressCopyFlagsKHR; +typedef struct VkStridedDeviceAddressRangeKHR { + VkDeviceAddress address; + VkDeviceSize size; + VkDeviceSize stride; +} VkStridedDeviceAddressRangeKHR; + +typedef struct VkCopyMemoryIndirectCommandKHR { + VkDeviceAddress srcAddress; + VkDeviceAddress dstAddress; + VkDeviceSize size; +} VkCopyMemoryIndirectCommandKHR; + +typedef struct VkCopyMemoryIndirectInfoKHR { + VkStructureType sType; + const void* pNext; + VkAddressCopyFlagsKHR srcCopyFlags; + VkAddressCopyFlagsKHR dstCopyFlags; + uint32_t copyCount; + VkStridedDeviceAddressRangeKHR copyAddressRange; +} VkCopyMemoryIndirectInfoKHR; + +typedef struct VkCopyMemoryToImageIndirectCommandKHR { + VkDeviceAddress srcAddress; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkCopyMemoryToImageIndirectCommandKHR; + +typedef struct VkCopyMemoryToImageIndirectInfoKHR { + VkStructureType sType; + const void* pNext; + VkAddressCopyFlagsKHR srcCopyFlags; + uint32_t copyCount; + VkStridedDeviceAddressRangeKHR copyAddressRange; + VkImage dstImage; + VkImageLayout dstImageLayout; + const VkImageSubresourceLayers* pImageSubresources; +} VkCopyMemoryToImageIndirectInfoKHR; + +typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 indirectMemoryCopy; + VkBool32 indirectMemoryToImageCopy; +} VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR; + +typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR { + VkStructureType sType; + void* pNext; + VkQueueFlags supportedQueues; +} VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryIndirectKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageIndirectKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectKHR( + VkCommandBuffer commandBuffer, + const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectKHR( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo); +#endif +#endif + + +// VK_KHR_video_encode_intra_refresh is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_encode_intra_refresh 1 +#define VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION 1 +#define VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME "VK_KHR_video_encode_intra_refresh" + +typedef enum VkVideoEncodeIntraRefreshModeFlagBitsKHR { + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR = 0, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeIntraRefreshModeFlagBitsKHR; +typedef VkFlags VkVideoEncodeIntraRefreshModeFlagsKHR; +typedef struct VkVideoEncodeIntraRefreshCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes; + uint32_t maxIntraRefreshCycleDuration; + uint32_t maxIntraRefreshActiveReferencePictures; + VkBool32 partitionIndependentIntraRefreshRegions; + VkBool32 nonRectangularIntraRefreshRegions; +} VkVideoEncodeIntraRefreshCapabilitiesKHR; + +typedef struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode; +} VkVideoEncodeSessionIntraRefreshCreateInfoKHR; + +typedef struct VkVideoEncodeIntraRefreshInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t intraRefreshCycleDuration; + uint32_t intraRefreshIndex; +} VkVideoEncodeIntraRefreshInfoKHR; + +typedef struct VkVideoReferenceIntraRefreshInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t dirtyIntraRefreshRegions; +} VkVideoReferenceIntraRefreshInfoKHR; + +typedef struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 videoEncodeIntraRefresh; +} VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; + // VK_KHR_video_encode_quantization_map is a preprocessor guard. Do not pass it to API calls. @@ -13106,12 +13771,6 @@ typedef VkFlags64 VkAccessFlags3KHR; typedef VkFlags64 VkAccessFlagBits3KHR; static const VkAccessFlagBits3KHR VK_ACCESS_3_NONE_KHR = 0ULL; -typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 maintenance8; -} VkPhysicalDeviceMaintenance8FeaturesKHR; - typedef struct VkMemoryBarrierAccessFlags3KHR { VkStructureType sType; const void* pNext; @@ -13119,6 +13778,26 @@ typedef struct VkMemoryBarrierAccessFlags3KHR { VkAccessFlags3KHR dstAccessMask3; } VkMemoryBarrierAccessFlags3KHR; +typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 maintenance8; +} VkPhysicalDeviceMaintenance8FeaturesKHR; + + + +// VK_KHR_shader_fma is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_fma 1 +#define VK_KHR_SHADER_FMA_SPEC_VERSION 1 +#define VK_KHR_SHADER_FMA_EXTENSION_NAME "VK_KHR_shader_fma" +typedef struct VkPhysicalDeviceShaderFmaFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderFmaFloat16; + VkBool32 shaderFmaFloat32; + VkBool32 shaderFmaFloat64; +} VkPhysicalDeviceShaderFmaFeaturesKHR; + // VK_KHR_maintenance9 is a preprocessor guard. Do not pass it to API calls. @@ -13218,6 +13897,81 @@ typedef struct VkPhysicalDeviceRobustness2PropertiesKHR { +// VK_KHR_present_mode_fifo_latest_ready is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_present_mode_fifo_latest_ready 1 +#define VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION 1 +#define VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME "VK_KHR_present_mode_fifo_latest_ready" +typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 presentModeFifoLatestReady; +} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + + + +// VK_KHR_maintenance10 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance10 1 +#define VK_KHR_MAINTENANCE_10_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_10_EXTENSION_NAME "VK_KHR_maintenance10" + +typedef enum VkRenderingAttachmentFlagBitsKHR { + VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR = 0x00000001, + VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR = 0x00000002, + VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR = 0x00000004, + VK_RENDERING_ATTACHMENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkRenderingAttachmentFlagBitsKHR; +typedef VkFlags VkRenderingAttachmentFlagsKHR; + +typedef enum VkResolveImageFlagBitsKHR { + VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR = 0x00000001, + VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR = 0x00000002, + VK_RESOLVE_IMAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkResolveImageFlagBitsKHR; +typedef VkFlags VkResolveImageFlagsKHR; +typedef struct VkPhysicalDeviceMaintenance10FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 maintenance10; +} VkPhysicalDeviceMaintenance10FeaturesKHR; + +typedef struct VkPhysicalDeviceMaintenance10PropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rgba4OpaqueBlackSwizzled; + VkBool32 resolveSrgbFormatAppliesTransferFunction; + VkBool32 resolveSrgbFormatSupportsTransferFunctionControl; +} VkPhysicalDeviceMaintenance10PropertiesKHR; + +typedef struct VkRenderingEndInfoKHR { + VkStructureType sType; + const void* pNext; +} VkRenderingEndInfoKHR; + +typedef struct VkRenderingAttachmentFlagsInfoKHR { + VkStructureType sType; + const void* pNext; + VkRenderingAttachmentFlagsKHR flags; +} VkRenderingAttachmentFlagsInfoKHR; + +typedef struct VkResolveImageModeInfoKHR { + VkStructureType sType; + const void* pNext; + VkResolveImageFlagsKHR flags; + VkResolveModeFlagBits resolveMode; + VkResolveModeFlagBits stencilResolveMode; +} VkResolveImageModeInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdEndRendering2KHR)(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2KHR( + VkCommandBuffer commandBuffer, + const VkRenderingEndInfoKHR* pRenderingEndInfo); +#endif +#endif + + // VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_debug_report 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) @@ -13266,9 +14020,9 @@ typedef enum VkDebugReportObjectTypeEXT { VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT = 1000307000, VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT = 1000307001, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT = 1000366000, - // VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT is a deprecated alias + // VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT is a legacy alias VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, - // VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT is a deprecated alias + // VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT is a legacy alias VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, @@ -13307,17 +14061,22 @@ typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instanc typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( VkInstance instance, VkDebugReportFlagsEXT flags, @@ -13328,6 +14087,7 @@ VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( const char* pLayerPrefix, const char* pMessage); #endif +#endif // VK_NV_glsl_shader is a preprocessor guard. Do not pass it to API calls. @@ -13414,25 +14174,35 @@ typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuff typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); #endif +#endif // VK_AMD_gcn_shader is a preprocessor guard. Do not pass it to API calls. @@ -13508,6 +14278,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuf typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer, uint32_t firstBinding, @@ -13515,34 +14286,44 @@ VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT( const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer, uint32_t instanceCount, @@ -13552,6 +14333,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT( uint32_t counterOffset, uint32_t vertexStride); #endif +#endif // VK_NVX_binary_import is a preprocessor guard. Do not pass it to API calls. @@ -13604,32 +14386,42 @@ typedef void (VKAPI_PTR *PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFuncti typedef void (VKAPI_PTR *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX( VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX( VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX( VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX( VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX( VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo); #endif +#endif // VK_NVX_image_view_handle is a preprocessor guard. Do not pass it to API calls. @@ -13656,19 +14448,25 @@ typedef uint64_t (VKAPI_PTR *PFN_vkGetImageViewHandle64NVX)(VkDevice device, con typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR uint64_t VKAPI_CALL vkGetImageViewHandle64NVX( VkDevice device, const VkImageViewHandleInfoNVX* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX( VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties); #endif +#endif // VK_AMD_draw_indirect_count is a preprocessor guard. Do not pass it to API calls. @@ -13679,6 +14477,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandB typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, @@ -13687,7 +14486,9 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, @@ -13697,6 +14498,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( uint32_t maxDrawCount, uint32_t stride); #endif +#endif // VK_AMD_negative_viewport_height is a preprocessor guard. Do not pass it to API calls. @@ -13761,6 +14563,7 @@ typedef struct VkShaderStatisticsInfoAMD { typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( VkDevice device, VkPipeline pipeline, @@ -13769,6 +14572,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( size_t* pInfoSize, void* pInfo); #endif +#endif // VK_AMD_shader_image_load_store_lod is a preprocessor guard. Do not pass it to API calls. @@ -13826,6 +14630,7 @@ typedef struct VkExternalImageFormatPropertiesNV { typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice, VkFormat format, @@ -13836,6 +14641,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesN VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); #endif +#endif // VK_NV_external_memory is a preprocessor guard. Do not pass it to API calls. @@ -13964,13 +14770,17 @@ typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer); #endif +#endif // VK_NV_clip_space_w_scaling is a preprocessor guard. Do not pass it to API calls. @@ -13993,12 +14803,14 @@ typedef struct VkPipelineViewportWScalingStateCreateInfoNV { typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); #endif +#endif // VK_EXT_direct_mode_display is a preprocessor guard. Do not pass it to API calls. @@ -14008,10 +14820,12 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display); #endif +#endif // VK_EXT_display_surface_counter is a preprocessor guard. Do not pass it to API calls. @@ -14021,7 +14835,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( typedef enum VkSurfaceCounterFlagBitsEXT { VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0x00000001, - // VK_SURFACE_COUNTER_VBLANK_EXT is a deprecated alias + // VK_SURFACE_COUNTER_VBLANK_EXT is a legacy alias VK_SURFACE_COUNTER_VBLANK_EXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT, VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF } VkSurfaceCounterFlagBitsEXT; @@ -14045,11 +14859,13 @@ typedef struct VkSurfaceCapabilities2EXT { typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); #endif +#endif // VK_EXT_display_control is a preprocessor guard. Do not pass it to API calls. @@ -14103,30 +14919,38 @@ typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkD typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); #endif +#endif // VK_GOOGLE_display_timing is a preprocessor guard. Do not pass it to API calls. @@ -14161,17 +14985,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice devic typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); #endif +#endif // VK_NV_sample_mask_override_coverage is a preprocessor guard. Do not pass it to API calls. @@ -14190,9 +15018,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( #define VK_NV_viewport_array2 1 #define VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION 1 #define VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME "VK_NV_viewport_array2" -// VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION is a deprecated alias +// VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION is a legacy alias #define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION -// VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME is a deprecated alias +// VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME is a legacy alias #define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME @@ -14280,20 +15108,26 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEnableEXT)(VkCommandBuffer typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleModeEXT)(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleModeEXT( VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode); #endif +#endif // VK_EXT_conservative_rasterization is a preprocessor guard. Do not pass it to API calls. @@ -14383,12 +15217,14 @@ typedef struct VkHdrMetadataEXT { typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); #endif +#endif // VK_IMG_relaxed_line_rasterization is a preprocessor guard. Do not pass it to API calls. @@ -14510,53 +15346,75 @@ typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instanc typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT( VkQueue queue); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT( VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT( VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); #endif +#endif // VK_EXT_sampler_filter_minmax is a preprocessor guard. Do not pass it to API calls. @@ -14681,15 +15539,19 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer command typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); #endif +#endif // VK_EXT_blend_operation_advanced is a preprocessor guard. Do not pass it to API calls. @@ -14866,11 +15728,13 @@ typedef struct VkDrmFormatModifierPropertiesList2EXT { typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); #endif +#endif // VK_EXT_validation_cache is a preprocessor guard. Do not pass it to API calls. @@ -14904,29 +15768,37 @@ typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, Vk typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT( VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT( VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); #endif +#endif // VK_EXT_descriptor_indexing is a preprocessor guard. Do not pass it to API calls. @@ -15037,23 +15909,29 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuff typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); #endif +#endif // VK_NV_ray_tracing is a preprocessor guard. Do not pass it to API calls. @@ -15082,6 +15960,9 @@ typedef enum VkGeometryTypeKHR { VK_GEOMETRY_TYPE_INSTANCES_KHR = 2, VK_GEOMETRY_TYPE_SPHERES_NV = 1000429004, VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV = 1000429005, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX = 1000478000, +#endif VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR, VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR, VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF @@ -15144,9 +16025,9 @@ typedef enum VkGeometryInstanceFlagBitsKHR { VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, - // VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT is a deprecated alias + // VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT is a legacy alias VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT, - // VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT is a deprecated alias + // VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT is a legacy alias VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT, VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkGeometryInstanceFlagBitsKHR; @@ -15170,22 +16051,23 @@ typedef enum VkBuildAccelerationStructureFlagBitsKHR { VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV = 0x00000200, #endif VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR = 0x00000800, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV = 0x00001000, 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, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, - // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT is a deprecated alias + // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT is a legacy alias VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT, - // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT is a deprecated alias + // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT is a legacy alias VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT, - // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT is a deprecated alias + // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT is a legacy alias VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT, #ifdef VK_ENABLE_BETA_EXTENSIONS - // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV is a deprecated alias + // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV is a legacy alias VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV, #endif - // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR is a deprecated alias + // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR is a legacy alias VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF } VkBuildAccelerationStructureFlagBitsKHR; @@ -15353,27 +16235,36 @@ typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCom typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV( VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV( VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, @@ -15384,13 +16275,17 @@ VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV( VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV( VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, @@ -15407,7 +16302,9 @@ VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV( uint32_t width, uint32_t height, uint32_t depth); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV( VkDevice device, VkPipelineCache pipelineCache, @@ -15415,7 +16312,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV( const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR( VkDevice device, VkPipeline pipeline, @@ -15423,7 +16322,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR( uint32_t groupCount, size_t dataSize, void* pData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV( VkDevice device, VkPipeline pipeline, @@ -15431,13 +16332,17 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV( uint32_t groupCount, size_t dataSize, void* pData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, @@ -15445,12 +16350,15 @@ VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV( VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader); #endif +#endif // VK_NV_representative_fragment_test is a preprocessor guard. Do not pass it to API calls. @@ -15532,12 +16440,14 @@ typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); #endif +#endif // VK_AMD_buffer_marker is a preprocessor guard. Do not pass it to API calls. @@ -15548,13 +16458,16 @@ typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandB typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, @@ -15562,6 +16475,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD( VkDeviceSize dstOffset, uint32_t marker); #endif +#endif // VK_AMD_pipeline_compiler_control is a preprocessor guard. Do not pass it to API calls. @@ -15593,11 +16507,14 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT) typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT( VkDevice device, uint32_t timestampCount, @@ -15605,6 +16522,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT( uint64_t* pTimestamps, uint64_t* pMaxDeviation); #endif +#endif // VK_AMD_shader_core_properties is a preprocessor guard. Do not pass it to API calls. @@ -15736,18 +16654,23 @@ typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer comma typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, VkBuffer buffer, @@ -15757,6 +16680,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV( uint32_t maxDrawCount, uint32_t stride); #endif +#endif // VK_NV_fragment_shader_barycentric is a preprocessor guard. Do not pass it to API calls. @@ -15800,18 +16724,22 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorEnableNV)(VkCommandBuffer c typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorEnableNV( VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); #endif +#endif // VK_NV_device_diagnostic_checkpoints is a preprocessor guard. Do not pass it to API calls. @@ -15849,20 +16777,26 @@ typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void* pCheckpointMarker); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV( VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData); #endif +#endif // VK_INTEL_shader_integer_functions2 is a preprocessor guard. Do not pass it to API calls. @@ -15977,43 +16911,61 @@ typedef VkResult (VKAPI_PTR *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueu typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL( VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL( VkDevice device); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL( VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL( VkDevice device, VkPerformanceConfigurationINTEL configuration); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL( VkQueue queue, VkPerformanceConfigurationINTEL configuration); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL( VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue); #endif +#endif // VK_EXT_pci_bus_info is a preprocessor guard. Do not pass it to API calls. @@ -16050,11 +17002,13 @@ typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD { typedef void (VKAPI_PTR *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD( VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable); #endif +#endif // VK_EXT_fragment_density_map is a preprocessor guard. Do not pass it to API calls. @@ -16104,9 +17058,9 @@ typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLay #define VK_GOOGLE_hlsl_functionality1 1 #define VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION 1 #define VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1" -// VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION is a deprecated alias +// VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION is a legacy alias #define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION -// VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME is a deprecated alias +// VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME is a legacy alias #define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME @@ -16239,10 +17193,12 @@ typedef struct VkBufferDeviceAddressCreateInfoEXT { typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfo* pInfo); #endif +#endif // VK_EXT_tooling_info is a preprocessor guard. Do not pass it to API calls. @@ -16258,11 +17214,13 @@ typedef VkPhysicalDeviceToolProperties VkPhysicalDeviceToolPropertiesEXT; typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT( VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); #endif +#endif // VK_EXT_separate_stencil_usage is a preprocessor guard. Do not pass it to API calls. @@ -16346,11 +17304,13 @@ typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV { typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties); #endif +#endif // VK_NV_coverage_reduction_mode is a preprocessor guard. Do not pass it to API calls. @@ -16389,11 +17349,13 @@ typedef struct VkFramebufferMixedSamplesCombinationNV { typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations); #endif +#endif // VK_EXT_fragment_shader_interlock is a preprocessor guard. Do not pass it to API calls. @@ -16468,12 +17430,14 @@ typedef struct VkHeadlessSurfaceCreateInfoEXT { typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT( VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif +#endif // VK_EXT_line_rasterization is a preprocessor guard. Do not pass it to API calls. @@ -16491,11 +17455,13 @@ typedef VkPipelineRasterizationLineStateCreateInfo VkPipelineRasterizationLineSt typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); #endif +#endif // VK_EXT_shader_atomic_float is a preprocessor guard. Do not pass it to API calls. @@ -16530,12 +17496,14 @@ typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFea typedef void (VKAPI_PTR *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); #endif +#endif // VK_EXT_index_type_uint8 is a preprocessor guard. Do not pass it to API calls. @@ -16570,28 +17538,39 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer comma typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT( VkCommandBuffer commandBuffer, uint32_t firstBinding, @@ -16600,27 +17579,39 @@ VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT( const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, @@ -16629,6 +17620,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT( VkStencilOp depthFailOp, VkCompareOp compareOp); #endif +#endif // VK_EXT_host_image_copy is a preprocessor guard. Do not pass it to API calls. @@ -16670,29 +17662,39 @@ typedef VkResult (VKAPI_PTR *PFN_vkTransitionImageLayoutEXT)(VkDevice device, ui typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2EXT)(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImageEXT( VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemoryEXT( VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImageEXT( VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayoutEXT( VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT( VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout); #endif +#endif // VK_EXT_map_memory_placed is a preprocessor guard. Do not pass it to API calls. @@ -16748,44 +17750,19 @@ 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 VkPresentScalingFlagBitsKHR VkPresentScalingFlagBitsEXT; -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 VkPresentScalingFlagsKHR VkPresentScalingFlagsEXT; -typedef struct VkSurfacePresentScalingCapabilitiesEXT { - VkStructureType sType; - void* pNext; - VkPresentScalingFlagsEXT supportedPresentScaling; - VkPresentGravityFlagsEXT supportedPresentGravityX; - VkPresentGravityFlagsEXT supportedPresentGravityY; - VkExtent2D minScaledImageExtent; - VkExtent2D maxScaledImageExtent; -} VkSurfacePresentScalingCapabilitiesEXT; +typedef VkPresentGravityFlagBitsKHR VkPresentGravityFlagBitsEXT; -typedef struct VkSurfacePresentModeCompatibilityEXT { - VkStructureType sType; - void* pNext; - uint32_t presentModeCount; - VkPresentModeKHR* pPresentModes; -} VkSurfacePresentModeCompatibilityEXT; +typedef VkPresentGravityFlagsKHR VkPresentGravityFlagsEXT; + +typedef VkSurfacePresentModeKHR VkSurfacePresentModeEXT; + +typedef VkSurfacePresentScalingCapabilitiesKHR VkSurfacePresentScalingCapabilitiesEXT; + +typedef VkSurfacePresentModeCompatibilityKHR VkSurfacePresentModeCompatibilityEXT; @@ -16793,55 +17770,26 @@ typedef struct 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 VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT; -typedef struct VkSwapchainPresentFenceInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkFence* pFences; -} VkSwapchainPresentFenceInfoEXT; +typedef VkSwapchainPresentFenceInfoKHR VkSwapchainPresentFenceInfoEXT; -typedef struct VkSwapchainPresentModesCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t presentModeCount; - const VkPresentModeKHR* pPresentModes; -} VkSwapchainPresentModesCreateInfoEXT; +typedef VkSwapchainPresentModesCreateInfoKHR VkSwapchainPresentModesCreateInfoEXT; -typedef struct VkSwapchainPresentModeInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkPresentModeKHR* pPresentModes; -} VkSwapchainPresentModeInfoEXT; +typedef VkSwapchainPresentModeInfoKHR VkSwapchainPresentModeInfoEXT; -typedef struct VkSwapchainPresentScalingCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPresentScalingFlagsEXT scalingBehavior; - VkPresentGravityFlagsEXT presentGravityX; - VkPresentGravityFlagsEXT presentGravityY; -} VkSwapchainPresentScalingCreateInfoEXT; +typedef VkSwapchainPresentScalingCreateInfoKHR VkSwapchainPresentScalingCreateInfoEXT; -typedef struct VkReleaseSwapchainImagesInfoEXT { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; - uint32_t imageIndexCount; - const uint32_t* pImageIndices; -} VkReleaseSwapchainImagesInfoEXT; +typedef VkReleaseSwapchainImagesInfoKHR VkReleaseSwapchainImagesInfoEXT; -typedef VkResult (VKAPI_PTR *PFN_vkReleaseSwapchainImagesEXT)(VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo); +typedef VkResult (VKAPI_PTR *PFN_vkReleaseSwapchainImagesEXT)(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesEXT( VkDevice device, - const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo); + const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); +#endif #endif @@ -17014,37 +17962,49 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice devi typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV( VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV( VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV( VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV( VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV( VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); #endif +#endif // VK_NV_inherited_viewport_scissor is a preprocessor guard. Do not pass it to API calls. @@ -17083,17 +18043,17 @@ typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBuff // VK_QCOM_render_pass_transform is a preprocessor guard. Do not pass it to API calls. #define VK_QCOM_render_pass_transform 1 -#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 4 +#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 5 #define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform" typedef struct VkRenderPassTransformBeginInfoQCOM { VkStructureType sType; - void* pNext; + const void* pNext; VkSurfaceTransformFlagBitsKHR transform; } VkRenderPassTransformBeginInfoQCOM; typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM { VkStructureType sType; - void* pNext; + const void* pNext; VkSurfaceTransformFlagBitsKHR transform; VkRect2D renderArea; } VkCommandBufferInheritanceRenderPassTransformInfoQCOM; @@ -17138,10 +18098,12 @@ typedef struct VkDepthBiasRepresentationInfoEXT { typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias2EXT)(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias2EXT( VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo); #endif +#endif // VK_EXT_device_memory_report is a preprocessor guard. Do not pass it to API calls. @@ -17198,17 +18160,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physic typedef VkResult (VKAPI_PTR *PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display); #endif +#endif // VK_EXT_robustness2 is a preprocessor guard. Do not pass it to API calls. @@ -17297,24 +18263,31 @@ typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectT typedef void (VKAPI_PTR *PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT( VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT( VkDevice device, VkObjectType objectType, @@ -17322,6 +18295,7 @@ VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT( VkPrivateDataSlot privateDataSlot, uint64_t* pData); #endif +#endif // VK_EXT_pipeline_creation_cache_control is a preprocessor guard. Do not pass it to API calls. @@ -17367,7 +18341,7 @@ typedef struct VkDeviceDiagnosticsConfigCreateInfoNV { // VK_QCOM_tile_shading is a preprocessor guard. Do not pass it to API calls. #define VK_QCOM_tile_shading 1 -#define VK_QCOM_TILE_SHADING_SPEC_VERSION 1 +#define VK_QCOM_TILE_SHADING_SPEC_VERSION 2 #define VK_QCOM_TILE_SHADING_EXTENSION_NAME "VK_QCOM_tile_shading" typedef enum VkTileShadingRenderPassFlagBitsQCOM { @@ -17431,18 +18405,24 @@ typedef void (VKAPI_PTR *PFN_vkCmdBeginPerTileExecutionQCOM)(VkCommandBuffer com typedef void (VKAPI_PTR *PFN_vkCmdEndPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDispatchTileQCOM( VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM* pDispatchTileInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBeginPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdEndPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo); #endif +#endif // VK_NV_low_latency is a preprocessor guard. Do not pass it to API calls. @@ -17606,28 +18586,37 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkD typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSizeEXT( VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT( VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDescriptorEXT( VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBuffersEXT( VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, @@ -17636,38 +18625,51 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT( uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData); #endif +#endif // VK_EXT_graphics_pipeline_library is a preprocessor guard. Do not pass it to API calls. @@ -17767,11 +18769,13 @@ typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV { typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV( VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); #endif +#endif // VK_NV_ray_tracing_motion_blur is a preprocessor guard. Do not pass it to API calls. @@ -18082,11 +19086,13 @@ typedef struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT { typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultInfoEXT( VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo); #endif +#endif // VK_ARM_rasterization_order_attachment_access is a preprocessor guard. Do not pass it to API calls. @@ -18178,6 +19184,7 @@ typedef struct VkVertexInputAttributeDescription2EXT { typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT( VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, @@ -18185,6 +19192,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT( uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); #endif +#endif // VK_EXT_physical_device_drm is a preprocessor guard. Do not pass it to API calls. @@ -18272,11 +19280,7 @@ typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { #define VK_EXT_present_mode_fifo_latest_ready 1 #define VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION 1 #define VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME "VK_EXT_present_mode_fifo_latest_ready" -typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 presentModeFifoLatestReady; -} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT; +typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT; @@ -18307,14 +19311,18 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI typedef void (VKAPI_PTR *PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI( VkCommandBuffer commandBuffer); #endif +#endif // VK_HUAWEI_invocation_mask is a preprocessor guard. Do not pass it to API calls. @@ -18330,11 +19338,13 @@ typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI { typedef void (VKAPI_PTR *PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); #endif +#endif // VK_NV_external_memory_rdma is a preprocessor guard. Do not pass it to API calls. @@ -18358,11 +19368,13 @@ typedef struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV { typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV( VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress); #endif +#endif // VK_EXT_pipeline_properties is a preprocessor guard. Do not pass it to API calls. @@ -18386,11 +19398,13 @@ typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT { typedef VkResult (VKAPI_PTR *PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT( VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties); #endif +#endif // VK_EXT_frame_boundary is a preprocessor guard. Do not pass it to API calls. @@ -18469,26 +19483,36 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, uint32_t patchControlPoints); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); #endif +#endif // VK_EXT_color_write_enable is a preprocessor guard. Do not pass it to API calls. @@ -18511,11 +19535,13 @@ typedef struct VkPipelineColorWriteCreateInfoEXT { typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables); #endif +#endif // VK_EXT_primitives_generated_query is a preprocessor guard. Do not pass it to API calls. @@ -18543,6 +19569,66 @@ typedef VkQueueFamilyGlobalPriorityProperties VkQueueFamilyGlobalPriorityPropert +// VK_VALVE_video_encode_rgb_conversion is a preprocessor guard. Do not pass it to API calls. +#define VK_VALVE_video_encode_rgb_conversion 1 +#define VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION 1 +#define VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME "VK_VALVE_video_encode_rgb_conversion" + +typedef enum VkVideoEncodeRgbModelConversionFlagBitsVALVE { + VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE = 0x00000001, + VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE = 0x00000002, + VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE = 0x00000004, + VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE = 0x00000008, + VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE = 0x00000010, + VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_FLAG_BITS_MAX_ENUM_VALVE = 0x7FFFFFFF +} VkVideoEncodeRgbModelConversionFlagBitsVALVE; +typedef VkFlags VkVideoEncodeRgbModelConversionFlagsVALVE; + +typedef enum VkVideoEncodeRgbRangeCompressionFlagBitsVALVE { + VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE = 0x00000001, + VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE = 0x00000002, + VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FLAG_BITS_MAX_ENUM_VALVE = 0x7FFFFFFF +} VkVideoEncodeRgbRangeCompressionFlagBitsVALVE; +typedef VkFlags VkVideoEncodeRgbRangeCompressionFlagsVALVE; + +typedef enum VkVideoEncodeRgbChromaOffsetFlagBitsVALVE { + VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE = 0x00000001, + VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE = 0x00000002, + VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_FLAG_BITS_MAX_ENUM_VALVE = 0x7FFFFFFF +} VkVideoEncodeRgbChromaOffsetFlagBitsVALVE; +typedef VkFlags VkVideoEncodeRgbChromaOffsetFlagsVALVE; +typedef struct VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE { + VkStructureType sType; + void* pNext; + VkBool32 videoEncodeRgbConversion; +} VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; + +typedef struct VkVideoEncodeRgbConversionCapabilitiesVALVE { + VkStructureType sType; + void* pNext; + VkVideoEncodeRgbModelConversionFlagsVALVE rgbModels; + VkVideoEncodeRgbRangeCompressionFlagsVALVE rgbRanges; + VkVideoEncodeRgbChromaOffsetFlagsVALVE xChromaOffsets; + VkVideoEncodeRgbChromaOffsetFlagsVALVE yChromaOffsets; +} VkVideoEncodeRgbConversionCapabilitiesVALVE; + +typedef struct VkVideoEncodeProfileRgbConversionInfoVALVE { + VkStructureType sType; + const void* pNext; + VkBool32 performEncodeRgbConversion; +} VkVideoEncodeProfileRgbConversionInfoVALVE; + +typedef struct VkVideoEncodeSessionRgbConversionCreateInfoVALVE { + VkStructureType sType; + const void* pNext; + VkVideoEncodeRgbModelConversionFlagBitsVALVE rgbModel; + VkVideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange; + VkVideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset; + VkVideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset; +} VkVideoEncodeSessionRgbConversionCreateInfoVALVE; + + + // VK_EXT_image_view_min_lod is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_image_view_min_lod 1 #define VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION 1 @@ -18592,6 +19678,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, u typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT( VkCommandBuffer commandBuffer, uint32_t drawCount, @@ -18599,7 +19686,9 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT( uint32_t instanceCount, uint32_t firstInstance, uint32_t stride); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT( VkCommandBuffer commandBuffer, uint32_t drawCount, @@ -18609,6 +19698,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT( uint32_t stride, const int32_t* pVertexOffset); #endif +#endif // VK_EXT_image_2d_view_of_3d is a preprocessor guard. Do not pass it to API calls. @@ -18840,43 +19930,58 @@ typedef void (VKAPI_PTR *PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice devic typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateMicromapEXT( VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyMicromapEXT( VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBuildMicromapsEXT( VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkBuildMicromapsEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT( VkDevice device, uint32_t micromapCount, @@ -18885,19 +19990,27 @@ VKAPI_ATTR VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT( size_t dataSize, void* pData, size_t stride); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT( VkCommandBuffer commandBuffer, uint32_t micromapCount, @@ -18905,18 +20018,23 @@ VKAPI_ATTR void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT( VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDeviceMicromapCompatibilityEXT( VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetMicromapBuildSizesEXT( VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); #endif +#endif // VK_EXT_load_store_op_none is a preprocessor guard. Do not pass it to API calls. @@ -18955,17 +20073,21 @@ typedef void (VKAPI_PTR *PFN_vkCmdDrawClusterHUAWEI)(VkCommandBuffer commandBuff typedef void (VKAPI_PTR *PFN_vkCmdDrawClusterIndirectHUAWEI)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterHUAWEI( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterIndirectHUAWEI( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); #endif +#endif // VK_EXT_border_color_swizzle is a preprocessor guard. Do not pass it to API calls. @@ -19001,11 +20123,13 @@ typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { typedef void (VKAPI_PTR *PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT( VkDevice device, VkDeviceMemory memory, float priority); #endif +#endif // VK_ARM_shader_core_properties is a preprocessor guard. Do not pass it to API calls. @@ -19100,16 +20224,20 @@ typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)(VkDev typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetHostMappingVALVE)(VkDevice device, VkDescriptorSet descriptorSet, void** ppData); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutHostMappingInfoVALVE( VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE( VkDevice device, VkDescriptorSet descriptorSet, void** ppData); #endif +#endif // VK_EXT_depth_clamp_zero_one is a preprocessor guard. Do not pass it to API calls. @@ -19206,20 +20334,9 @@ typedef VkRenderPassFragmentDensityMapOffsetEndInfoEXT VkSubpassFragmentDensityM #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 VkCopyMemoryIndirectCommandKHR VkCopyMemoryIndirectCommandNV; -typedef struct VkCopyMemoryToImageIndirectCommandNV { - VkDeviceAddress srcAddress; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkCopyMemoryToImageIndirectCommandNV; +typedef VkCopyMemoryToImageIndirectCommandKHR VkCopyMemoryToImageIndirectCommandNV; typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV { VkStructureType sType; @@ -19227,22 +20344,21 @@ typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV { VkBool32 indirectCopy; } VkPhysicalDeviceCopyMemoryIndirectFeaturesNV; -typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV { - VkStructureType sType; - void* pNext; - VkQueueFlags supportedQueues; -} VkPhysicalDeviceCopyMemoryIndirectPropertiesNV; +typedef VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR 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 +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectNV( VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV( VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, @@ -19252,6 +20368,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV( VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources); #endif +#endif // VK_NV_memory_decompression is a preprocessor guard. Do not pass it to API calls. @@ -19259,11 +20376,16 @@ VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV( #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; +// Flag bits for VkMemoryDecompressionMethodFlagBitsEXT +typedef VkFlags64 VkMemoryDecompressionMethodFlagBitsEXT; +static const VkMemoryDecompressionMethodFlagBitsEXT VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT = 0x00000001ULL; +static const VkMemoryDecompressionMethodFlagBitsEXT VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV = 0x00000001ULL; + +typedef VkMemoryDecompressionMethodFlagBitsEXT VkMemoryDecompressionMethodFlagBitsNV; + +typedef VkFlags64 VkMemoryDecompressionMethodFlagsEXT; +typedef VkMemoryDecompressionMethodFlagsEXT VkMemoryDecompressionMethodFlagsNV; -typedef VkFlags64 VkMemoryDecompressionMethodFlagsNV; typedef struct VkDecompressMemoryRegionNV { VkDeviceAddress srcAddress; VkDeviceAddress dstAddress; @@ -19272,34 +20394,42 @@ typedef struct VkDecompressMemoryRegionNV { VkMemoryDecompressionMethodFlagsNV decompressionMethod; } VkDecompressMemoryRegionNV; -typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV { +typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesEXT { VkStructureType sType; void* pNext; VkBool32 memoryDecompression; -} VkPhysicalDeviceMemoryDecompressionFeaturesNV; +} VkPhysicalDeviceMemoryDecompressionFeaturesEXT; -typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV { - VkStructureType sType; - void* pNext; - VkMemoryDecompressionMethodFlagsNV decompressionMethods; - uint64_t maxDecompressionIndirectCount; -} VkPhysicalDeviceMemoryDecompressionPropertiesNV; +typedef VkPhysicalDeviceMemoryDecompressionFeaturesEXT VkPhysicalDeviceMemoryDecompressionFeaturesNV; + +typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesEXT { + VkStructureType sType; + void* pNext; + VkMemoryDecompressionMethodFlagsEXT decompressionMethods; + uint64_t maxDecompressionIndirectCount; +} VkPhysicalDeviceMemoryDecompressionPropertiesEXT; + +typedef VkPhysicalDeviceMemoryDecompressionPropertiesEXT 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 +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryNV( VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountNV( VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride); #endif +#endif // VK_NV_device_generated_commands_compute is a preprocessor guard. Do not pass it to API calls. @@ -19338,20 +20468,26 @@ typedef void (VKAPI_PTR *PFN_vkCmdUpdatePipelineIndirectBufferNV)(VkCommandBuffe typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetPipelineIndirectDeviceAddressNV)(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPipelineIndirectMemoryRequirementsNV( VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdUpdatePipelineIndirectBufferNV( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetPipelineIndirectDeviceAddressNV( VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo); #endif +#endif // VK_NV_ray_tracing_linear_swept_spheres is a preprocessor guard. Do not pass it to API calls. @@ -19598,142 +20734,204 @@ typedef void (VKAPI_PTR *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkComma typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT( VkCommandBuffer commandBuffer, VkPolygonMode polygonMode); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationSamplesEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleMaskEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEnableEXT( VkCommandBuffer commandBuffer, VkBool32 logicOpEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT( VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT( VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT( VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT( VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT( VkCommandBuffer commandBuffer, uint32_t rasterizationStream); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT( VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetExtraPrimitiveOverestimationSizeEXT( VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClipEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT( VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendAdvancedEXT( VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetProvokingVertexModeEXT( VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetLineRasterizationModeEXT( VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT( VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingEnableNV( VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportSwizzleNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorLocationNV( VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationModeNV( VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableNV( VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetShadingRateImageEnableNV( VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV( VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageReductionModeNV( VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode); #endif +#endif // VK_EXT_subpass_merge_feedback is a preprocessor guard. Do not pass it to API calls. @@ -19859,6 +21057,7 @@ static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_SHADER_BIT_ARM = 0x0000000 static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM = 0x00000004ULL; static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM = 0x00000008ULL; static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM = 0x00000010ULL; +static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM = 0x00000020ULL; typedef struct VkTensorDescriptionARM { VkStructureType sType; @@ -20023,7 +21222,7 @@ typedef struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM { typedef struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM { VkStructureType sType; - const void* pNext; + void* pNext; size_t tensorCaptureReplayDescriptorDataSize; size_t tensorViewCaptureReplayDescriptorDataSize; size_t tensorDescriptorSize; @@ -20067,62 +21266,84 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetTensorOpaqueCaptureDescriptorDataARM)(VkDe typedef VkResult (VKAPI_PTR *PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM)(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorARM( VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyTensorARM( VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorViewARM( VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyTensorViewARM( VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetTensorMemoryRequirementsARM( VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkBindTensorMemoryARM( VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDeviceTensorMemoryRequirementsARM( VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyTensorARM( VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalTensorPropertiesARM( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDescriptorDataARM( VkDevice device, const VkTensorCaptureDescriptorDataInfoARM* pInfo, void* pData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorViewOpaqueCaptureDescriptorDataARM( VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData); #endif +#endif // VK_EXT_shader_module_identifier is a preprocessor guard. Do not pass it to API calls. @@ -20160,16 +21381,20 @@ typedef void (VKAPI_PTR *PFN_vkGetShaderModuleIdentifierEXT)(VkDevice device, Vk typedef void (VKAPI_PTR *PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleIdentifierEXT( VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT( VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier); #endif +#endif // VK_EXT_rasterization_order_attachment_access is a preprocessor guard. Do not pass it to API calls. @@ -20312,35 +21537,45 @@ typedef VkResult (VKAPI_PTR *PFN_vkBindOpticalFlowSessionImageNV)(VkDevice devic typedef void (VKAPI_PTR *PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceOpticalFlowImageFormatsNV( VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV( VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyOpticalFlowSessionNV( VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV( VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV( VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo); #endif +#endif // VK_EXT_legacy_dithering is a preprocessor guard. Do not pass it to API calls. @@ -20404,10 +21639,12 @@ typedef struct VkAntiLagDataAMD { typedef void (VKAPI_PTR *PFN_vkAntiLagUpdateAMD)(VkDevice device, const VkAntiLagDataAMD* pData); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkAntiLagUpdateAMD( VkDevice device, const VkAntiLagDataAMD* pData); #endif +#endif // VK_EXT_shader_object is a preprocessor guard. Do not pass it to API calls. @@ -20437,6 +21674,7 @@ typedef enum VkShaderCreateFlagBitsEXT { VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 0x00000020, VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00000040, VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT = 0x00000080, + VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT = 0x00008000, VK_SHADER_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF } VkShaderCreateFlagBitsEXT; typedef VkFlags VkShaderCreateFlagsEXT; @@ -20484,35 +21722,45 @@ typedef void (VKAPI_PTR *PFN_vkCmdBindShadersEXT)(VkCommandBuffer commandBuffer, typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampRangeEXT)(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateShadersEXT( VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyShaderEXT( VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderBinaryDataEXT( VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBindShadersEXT( VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampRangeEXT( VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange); #endif +#endif // VK_QCOM_tile_properties is a preprocessor guard. Do not pass it to API calls. @@ -20537,17 +21785,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice de typedef VkResult (VKAPI_PTR *PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM( VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM( VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties); #endif +#endif // VK_SEC_amigo_profiling is a preprocessor guard. Do not pass it to API calls. @@ -20666,20 +21918,26 @@ typedef VkResult (VKAPI_PTR *PFN_vkConvertCooperativeVectorMatrixNV)(VkDevice de typedef void (VKAPI_PTR *PFN_vkCmdConvertCooperativeVectorMatrixNV)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeVectorPropertiesNV( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkConvertCooperativeVectorMatrixNV( VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdConvertCooperativeVectorMatrixNV( VkCommandBuffer commandBuffer, uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos); #endif +#endif // VK_NV_extended_sparse_address_space is a preprocessor guard. Do not pass it to API calls. @@ -20909,30 +22167,348 @@ typedef void (VKAPI_PTR *PFN_vkGetLatencyTimingsNV)(VkDevice device, VkSwapchain typedef void (VKAPI_PTR *PFN_vkQueueNotifyOutOfBandNV)(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkSetLatencySleepModeNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkLatencySleepNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkSetLatencyMarkerNV( VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetLatencyTimingsNV( VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkQueueNotifyOutOfBandNV( VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo); #endif +#endif + + +// VK_ARM_data_graph is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_data_graph 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDataGraphPipelineSessionARM) +#define VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM 128U +#define VK_ARM_DATA_GRAPH_SPEC_VERSION 1 +#define VK_ARM_DATA_GRAPH_EXTENSION_NAME "VK_ARM_data_graph" + +typedef enum VkDataGraphPipelineSessionBindPointARM { + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM = 0, + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphPipelineSessionBindPointARM; + +typedef enum VkDataGraphPipelineSessionBindPointTypeARM { + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM = 0, + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphPipelineSessionBindPointTypeARM; + +typedef enum VkDataGraphPipelinePropertyARM { + VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM = 0, + VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM = 1, + VK_DATA_GRAPH_PIPELINE_PROPERTY_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphPipelinePropertyARM; + +typedef enum VkPhysicalDeviceDataGraphProcessingEngineTypeARM { + VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM = 0, + VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF +} VkPhysicalDeviceDataGraphProcessingEngineTypeARM; + +typedef enum VkPhysicalDeviceDataGraphOperationTypeARM { + VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM = 0, + VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF +} VkPhysicalDeviceDataGraphOperationTypeARM; +typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagsARM; + +// Flag bits for VkDataGraphPipelineSessionCreateFlagBitsARM +typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagBitsARM; +static const VkDataGraphPipelineSessionCreateFlagBitsARM VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM = 0x00000001ULL; + +typedef VkFlags64 VkDataGraphPipelineDispatchFlagsARM; + +// Flag bits for VkDataGraphPipelineDispatchFlagBitsARM +typedef VkFlags64 VkDataGraphPipelineDispatchFlagBitsARM; + +typedef struct VkPhysicalDeviceDataGraphFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 dataGraph; + VkBool32 dataGraphUpdateAfterBind; + VkBool32 dataGraphSpecializationConstants; + VkBool32 dataGraphDescriptorBuffer; + VkBool32 dataGraphShaderModule; +} VkPhysicalDeviceDataGraphFeaturesARM; + +typedef struct VkDataGraphPipelineConstantARM { + VkStructureType sType; + const void* pNext; + uint32_t id; + const void* pConstantData; +} VkDataGraphPipelineConstantARM; + +typedef struct VkDataGraphPipelineResourceInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t descriptorSet; + uint32_t binding; + uint32_t arrayElement; +} VkDataGraphPipelineResourceInfoARM; + +typedef struct VkDataGraphPipelineCompilerControlCreateInfoARM { + VkStructureType sType; + const void* pNext; + const char* pVendorOptions; +} VkDataGraphPipelineCompilerControlCreateInfoARM; + +typedef struct VkDataGraphPipelineCreateInfoARM { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags2KHR flags; + VkPipelineLayout layout; + uint32_t resourceInfoCount; + const VkDataGraphPipelineResourceInfoARM* pResourceInfos; +} VkDataGraphPipelineCreateInfoARM; + +typedef struct VkDataGraphPipelineShaderModuleCreateInfoARM { + VkStructureType sType; + const void* pNext; + VkShaderModule module; + const char* pName; + const VkSpecializationInfo* pSpecializationInfo; + uint32_t constantCount; + const VkDataGraphPipelineConstantARM* pConstants; +} VkDataGraphPipelineShaderModuleCreateInfoARM; + +typedef struct VkDataGraphPipelineSessionCreateInfoARM { + VkStructureType sType; + const void* pNext; + VkDataGraphPipelineSessionCreateFlagsARM flags; + VkPipeline dataGraphPipeline; +} VkDataGraphPipelineSessionCreateInfoARM; + +typedef struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM { + VkStructureType sType; + const void* pNext; + VkDataGraphPipelineSessionARM session; +} VkDataGraphPipelineSessionBindPointRequirementsInfoARM; + +typedef struct VkDataGraphPipelineSessionBindPointRequirementARM { + VkStructureType sType; + const void* pNext; + VkDataGraphPipelineSessionBindPointARM bindPoint; + VkDataGraphPipelineSessionBindPointTypeARM bindPointType; + uint32_t numObjects; +} VkDataGraphPipelineSessionBindPointRequirementARM; + +typedef struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM { + VkStructureType sType; + const void* pNext; + VkDataGraphPipelineSessionARM session; + VkDataGraphPipelineSessionBindPointARM bindPoint; + uint32_t objectIndex; +} VkDataGraphPipelineSessionMemoryRequirementsInfoARM; + +typedef struct VkBindDataGraphPipelineSessionMemoryInfoARM { + VkStructureType sType; + const void* pNext; + VkDataGraphPipelineSessionARM session; + VkDataGraphPipelineSessionBindPointARM bindPoint; + uint32_t objectIndex; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindDataGraphPipelineSessionMemoryInfoARM; + +typedef struct VkDataGraphPipelineInfoARM { + VkStructureType sType; + const void* pNext; + VkPipeline dataGraphPipeline; +} VkDataGraphPipelineInfoARM; + +typedef struct VkDataGraphPipelinePropertyQueryResultARM { + VkStructureType sType; + const void* pNext; + VkDataGraphPipelinePropertyARM property; + VkBool32 isText; + size_t dataSize; + void* pData; +} VkDataGraphPipelinePropertyQueryResultARM; + +typedef struct VkDataGraphPipelineIdentifierCreateInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t identifierSize; + const uint8_t* pIdentifier; +} VkDataGraphPipelineIdentifierCreateInfoARM; + +typedef struct VkDataGraphPipelineDispatchInfoARM { + VkStructureType sType; + void* pNext; + VkDataGraphPipelineDispatchFlagsARM flags; +} VkDataGraphPipelineDispatchInfoARM; + +typedef struct VkPhysicalDeviceDataGraphProcessingEngineARM { + VkPhysicalDeviceDataGraphProcessingEngineTypeARM type; + VkBool32 isForeign; +} VkPhysicalDeviceDataGraphProcessingEngineARM; + +typedef struct VkPhysicalDeviceDataGraphOperationSupportARM { + VkPhysicalDeviceDataGraphOperationTypeARM operationType; + char name[VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM]; + uint32_t version; +} VkPhysicalDeviceDataGraphOperationSupportARM; + +typedef struct VkQueueFamilyDataGraphPropertiesARM { + VkStructureType sType; + const void* pNext; + VkPhysicalDeviceDataGraphProcessingEngineARM engine; + VkPhysicalDeviceDataGraphOperationSupportARM operation; +} VkQueueFamilyDataGraphPropertiesARM; + +typedef struct VkDataGraphProcessingEngineCreateInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t processingEngineCount; + VkPhysicalDeviceDataGraphProcessingEngineARM* pProcessingEngines; +} VkDataGraphProcessingEngineCreateInfoARM; + +typedef struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + VkPhysicalDeviceDataGraphProcessingEngineTypeARM engineType; +} VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; + +typedef struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes; + VkExternalMemoryHandleTypeFlags foreignMemoryHandleTypes; +} VkQueueFamilyDataGraphProcessingEnginePropertiesARM; + +typedef struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t dimension; + uint32_t zeroCount; + uint32_t groupSize; +} VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDataGraphPipelinesARM)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDataGraphPipelineSessionARM)(VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDataGraphPipelineSessionARM* pSession); +typedef VkResult (VKAPI_PTR *PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM)(VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements); +typedef void (VKAPI_PTR *PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM)(VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkBindDataGraphPipelineSessionMemoryARM)(VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkDestroyDataGraphPipelineSessionARM)(VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchDataGraphARM)(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, const VkDataGraphPipelineDispatchInfoARM* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetDataGraphPipelineAvailablePropertiesARM)(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t* pPropertiesCount, VkDataGraphPipelinePropertyARM* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDataGraphPipelinePropertiesARM)(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelinesARM( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkDataGraphPipelineCreateInfoARM* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelineSessionARM( + VkDevice device, + const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDataGraphPipelineSessionARM* pSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineSessionBindPointRequirementsARM( + VkDevice device, + const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, + uint32_t* pBindPointRequirementCount, + VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDataGraphPipelineSessionMemoryRequirementsARM( + VkDevice device, + const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, + VkMemoryRequirements2* pMemoryRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBindDataGraphPipelineSessionMemoryARM( + VkDevice device, + uint32_t bindInfoCount, + const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyDataGraphPipelineSessionARM( + VkDevice device, + VkDataGraphPipelineSessionARM session, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchDataGraphARM( + VkCommandBuffer commandBuffer, + VkDataGraphPipelineSessionARM session, + const VkDataGraphPipelineDispatchInfoARM* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineAvailablePropertiesARM( + VkDevice device, + const VkDataGraphPipelineInfoARM* pPipelineInfo, + uint32_t* pPropertiesCount, + VkDataGraphPipelinePropertyARM* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelinePropertiesARM( + VkDevice device, + const VkDataGraphPipelineInfoARM* pPipelineInfo, + uint32_t propertiesCount, + VkDataGraphPipelinePropertyQueryResultARM* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pQueueFamilyDataGraphPropertyCount, + VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, + VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties); +#endif +#endif // VK_QCOM_multiview_per_view_render_areas is a preprocessor guard. Do not pass it to API calls. @@ -21074,10 +22650,12 @@ typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT { typedef void (VKAPI_PTR *PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT)(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetAttachmentFeedbackLoopEnableEXT( VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask); #endif +#endif // VK_MSFT_layered_driver is a preprocessor guard. Do not pass it to API calls. @@ -21149,10 +22727,53 @@ typedef struct VkTileMemorySizeInfoQCOM { typedef void (VKAPI_PTR *PFN_vkCmdBindTileMemoryQCOM)(VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBindTileMemoryQCOM( VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo); #endif +#endif + + +// VK_EXT_memory_decompression is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_memory_decompression 1 +#define VK_EXT_MEMORY_DECOMPRESSION_SPEC_VERSION 1 +#define VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME "VK_EXT_memory_decompression" +typedef struct VkDecompressMemoryRegionEXT { + VkDeviceAddress srcAddress; + VkDeviceAddress dstAddress; + VkDeviceSize compressedSize; + VkDeviceSize decompressedSize; +} VkDecompressMemoryRegionEXT; + +typedef struct VkDecompressMemoryInfoEXT { + VkStructureType sType; + const void* pNext; + VkMemoryDecompressionMethodFlagsEXT decompressionMethod; + uint32_t regionCount; + const VkDecompressMemoryRegionEXT* pRegions; +} VkDecompressMemoryInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryEXT)(VkCommandBuffer commandBuffer, const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT); +typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryIndirectCountEXT)(VkCommandBuffer commandBuffer, VkMemoryDecompressionMethodFlagsEXT decompressionMethod, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t maxDecompressionCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryEXT( + VkCommandBuffer commandBuffer, + const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountEXT( + VkCommandBuffer commandBuffer, + VkMemoryDecompressionMethodFlagsEXT decompressionMethod, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t maxDecompressionCount, + uint32_t stride); +#endif +#endif // VK_NV_display_stereo is a preprocessor guard. Do not pass it to API calls. @@ -21228,22 +22849,28 @@ typedef void (VKAPI_PTR *PFN_vkDestroyExternalComputeQueueNV)(VkDevice device, V typedef void (VKAPI_PTR *PFN_vkGetExternalComputeQueueDataNV)(VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateExternalComputeQueueNV( VkDevice device, const VkExternalComputeQueueCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkExternalComputeQueueNV* pExternalQueue); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyExternalComputeQueueNV( VkDevice device, VkExternalComputeQueueNV externalQueue, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetExternalComputeQueueDataNV( VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData); #endif +#endif // VK_NV_command_buffer_inheritance is a preprocessor guard. Do not pass it to API calls. @@ -21309,7 +22936,7 @@ typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV { // VK_NV_cluster_acceleration_structure is a preprocessor guard. Do not pass it to API calls. #define VK_NV_cluster_acceleration_structure 1 -#define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION 2 +#define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION 4 #define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_NV_cluster_acceleration_structure" typedef enum VkClusterAccelerationStructureTypeNV { @@ -21325,6 +22952,7 @@ typedef enum VkClusterAccelerationStructureOpTypeNV { VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV = 2, VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV = 3, VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV = 4, + VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV = 5, VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MAX_ENUM_NV = 0x7FFFFFFF } VkClusterAccelerationStructureOpTypeNV; @@ -21336,6 +22964,7 @@ typedef enum VkClusterAccelerationStructureOpModeNV { } VkClusterAccelerationStructureOpModeNV; typedef enum VkClusterAccelerationStructureAddressResolutionFlagBitsNV { + VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV = 0, VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV = 0x00000001, VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV = 0x00000002, VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV = 0x00000004, @@ -21519,6 +23148,10 @@ typedef struct VkClusterAccelerationStructureInstantiateClusterInfoNV { VkStridedDeviceAddressNV vertexBuffer; } VkClusterAccelerationStructureInstantiateClusterInfoNV; +typedef struct VkClusterAccelerationStructureGetTemplateIndicesInfoNV { + VkDeviceAddress clusterTemplateAddress; +} VkClusterAccelerationStructureGetTemplateIndicesInfoNV; + typedef struct VkAccelerationStructureBuildSizesInfoKHR { VkStructureType sType; const void* pNext; @@ -21537,15 +23170,19 @@ typedef void (VKAPI_PTR *PFN_vkGetClusterAccelerationStructureBuildSizesNV)(VkDe typedef void (VKAPI_PTR *PFN_vkCmdBuildClusterAccelerationStructureIndirectNV)(VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetClusterAccelerationStructureBuildSizesNV( VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBuildClusterAccelerationStructureIndirectNV( VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos); #endif +#endif // VK_NV_partitioned_acceleration_structure is a preprocessor guard. Do not pass it to API calls. @@ -21649,15 +23286,19 @@ typedef void (VKAPI_PTR *PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV) typedef void (VKAPI_PTR *PFN_vkCmdBuildPartitionedAccelerationStructuresNV)(VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetPartitionedAccelerationStructuresBuildSizesNV( VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBuildPartitionedAccelerationStructuresNV( VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo); #endif +#endif // VK_EXT_device_generated_commands is a preprocessor guard. Do not pass it to API calls. @@ -21889,55 +23530,73 @@ typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetPipelineEXT)(VkDevice d typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetShaderEXT)(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsEXT( VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsEXT( VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsEXT( VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutEXT( VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutEXT( VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectExecutionSetEXT( VkDevice device, const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectExecutionSetEXT* pIndirectExecutionSet); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectExecutionSetEXT( VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetPipelineEXT( VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetShaderEXT( VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites); #endif +#endif // VK_MESA_image_alignment_control is a preprocessor guard. Do not pass it to API calls. @@ -22044,11 +23703,13 @@ typedef struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV { typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties); #endif +#endif // VK_ARM_pipeline_opacity_micromap is a preprocessor guard. Do not pass it to API calls. @@ -22063,6 +23724,64 @@ typedef struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM { +// VK_ARM_performance_counters_by_region is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_performance_counters_by_region 1 +#define VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_SPEC_VERSION 1 +#define VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_EXTENSION_NAME "VK_ARM_performance_counters_by_region" +typedef VkFlags VkPerformanceCounterDescriptionFlagsARM; +typedef struct VkPhysicalDevicePerformanceCountersByRegionFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 performanceCountersByRegion; +} VkPhysicalDevicePerformanceCountersByRegionFeaturesARM; + +typedef struct VkPhysicalDevicePerformanceCountersByRegionPropertiesARM { + VkStructureType sType; + void* pNext; + uint32_t maxPerRegionPerformanceCounters; + VkExtent2D performanceCounterRegionSize; + uint32_t rowStrideAlignment; + uint32_t regionAlignment; + VkBool32 identityTransformOrder; +} VkPhysicalDevicePerformanceCountersByRegionPropertiesARM; + +typedef struct VkPerformanceCounterARM { + VkStructureType sType; + void* pNext; + uint32_t counterID; +} VkPerformanceCounterARM; + +typedef struct VkPerformanceCounterDescriptionARM { + VkStructureType sType; + void* pNext; + VkPerformanceCounterDescriptionFlagsARM flags; + char name[VK_MAX_DESCRIPTION_SIZE]; +} VkPerformanceCounterDescriptionARM; + +typedef struct VkRenderPassPerformanceCountersByRegionBeginInfoARM { + VkStructureType sType; + void* pNext; + uint32_t counterAddressCount; + const VkDeviceAddress* pCounterAddresses; + VkBool32 serializeRegions; + uint32_t counterIndexCount; + uint32_t* pCounterIndices; +} VkRenderPassPerformanceCountersByRegionBeginInfoARM; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, VkPerformanceCounterDescriptionARM* pCounterDescriptions); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pCounterCount, + VkPerformanceCounterARM* pCounters, + VkPerformanceCounterDescriptionARM* pCounterDescriptions); +#endif +#endif + + // VK_EXT_vertex_attribute_robustness is a preprocessor guard. Do not pass it to API calls. #define VK_EXT_vertex_attribute_robustness 1 #define VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION 1 @@ -22087,6 +23806,30 @@ typedef struct VkPhysicalDeviceFormatPackFeaturesARM { +// VK_VALVE_fragment_density_map_layered is a preprocessor guard. Do not pass it to API calls. +#define VK_VALVE_fragment_density_map_layered 1 +#define VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION 1 +#define VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME "VK_VALVE_fragment_density_map_layered" +typedef struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMapLayered; +} VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; + +typedef struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE { + VkStructureType sType; + void* pNext; + uint32_t maxFragmentDensityMapLayers; +} VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; + +typedef struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE { + VkStructureType sType; + const void* pNext; + uint32_t maxFragmentDensityMapLayers; +} VkPipelineFragmentDensityMapLayeredCreateInfoVALVE; + + + // VK_NV_present_metering is a preprocessor guard. Do not pass it to API calls. #define VK_NV_present_metering 1 #define VK_NV_PRESENT_METERING_SPEC_VERSION 1 @@ -22110,17 +23853,16 @@ typedef struct VkPhysicalDevicePresentMeteringFeaturesNV { #define VK_EXT_fragment_density_map_offset 1 #define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1 #define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_EXT_fragment_density_map_offset" -typedef struct VkRenderingEndInfoEXT { - VkStructureType sType; - const void* pNext; -} VkRenderingEndInfoEXT; +typedef VkRenderingEndInfoKHR VkRenderingEndInfoEXT; -typedef void (VKAPI_PTR *PFN_vkCmdEndRendering2EXT)(VkCommandBuffer commandBuffer, const VkRenderingEndInfoEXT* pRenderingEndInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRendering2EXT)(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2EXT( VkCommandBuffer commandBuffer, - const VkRenderingEndInfoEXT* pRenderingEndInfo); + const VkRenderingEndInfoKHR* pRenderingEndInfo); +#endif #endif @@ -22136,6 +23878,42 @@ typedef struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT { +// VK_EXT_shader_64bit_indexing is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_64bit_indexing 1 +#define VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION 1 +#define VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME "VK_EXT_shader_64bit_indexing" +typedef struct VkPhysicalDeviceShader64BitIndexingFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shader64BitIndexing; +} VkPhysicalDeviceShader64BitIndexingFeaturesEXT; + + + +// VK_SEC_pipeline_cache_incremental_mode is a preprocessor guard. Do not pass it to API calls. +#define VK_SEC_pipeline_cache_incremental_mode 1 +#define VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION 1 +#define VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME "VK_SEC_pipeline_cache_incremental_mode" +typedef struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC { + VkStructureType sType; + void* pNext; + VkBool32 pipelineCacheIncrementalMode; +} VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; + + + +// VK_EXT_shader_uniform_buffer_unsized_array is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_uniform_buffer_unsized_array 1 +#define VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION 1 +#define VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME "VK_EXT_shader_uniform_buffer_unsized_array" +typedef struct VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderUniformBufferUnsizedArray; +} VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; + + + // VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls. #define VK_KHR_acceleration_structure 1 #define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13 @@ -22310,23 +24088,30 @@ typedef void (VKAPI_PTR *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(V typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR( VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR( VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR( VkCommandBuffer commandBuffer, uint32_t infoCount, @@ -22334,29 +24119,39 @@ VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR( const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR( VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR( VkDevice device, uint32_t accelerationStructureCount, @@ -22365,23 +24160,33 @@ VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR( size_t dataSize, void* pData, size_t stride); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR( VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR( VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR( VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR( VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR( VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, @@ -22389,12 +24194,16 @@ VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR( VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR( VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR( VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, @@ -22402,6 +24211,7 @@ VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR( const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); #endif +#endif // VK_KHR_ray_tracing_pipeline is a preprocessor guard. Do not pass it to API calls. @@ -22488,6 +24298,7 @@ typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkD typedef void (VKAPI_PTR *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR( VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, @@ -22497,7 +24308,9 @@ VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR( uint32_t width, uint32_t height, uint32_t depth); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR( VkDevice device, VkDeferredOperationKHR deferredOperation, @@ -22506,7 +24319,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR( const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( VkDevice device, VkPipeline pipeline, @@ -22514,7 +24329,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR uint32_t groupCount, size_t dataSize, void* pData); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR( VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, @@ -22522,17 +24339,22 @@ VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR( const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR( VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, uint32_t pipelineStackSize); #endif +#endif // VK_KHR_ray_query is a preprocessor guard. Do not pass it to API calls. @@ -22605,19 +24427,24 @@ typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectEXT)(VkCommandBuffer comm 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 +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksEXT( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectEXT( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountEXT( VkCommandBuffer commandBuffer, VkBuffer buffer, @@ -22627,6 +24454,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountEXT( uint32_t maxDrawCount, uint32_t stride); #endif +#endif #ifdef __cplusplus } diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_directfb.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_directfb.h index 26a4363..bb15676 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_directfb.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_directfb.h @@ -36,17 +36,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateDirectFBSurfaceEXT)(VkInstance instance typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT( VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb); #endif +#endif #ifdef __cplusplus } diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_fuchsia.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_fuchsia.h index 0af61bd..f65efc6 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_fuchsia.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_fuchsia.h @@ -34,12 +34,14 @@ typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA { typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif +#endif // VK_FUCHSIA_external_memory is a preprocessor guard. Do not pass it to API calls. @@ -70,17 +72,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandleFUCHSIA)(VkDevice device typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA( VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties); #endif +#endif // VK_FUCHSIA_external_semaphore is a preprocessor guard. Do not pass it to API calls. @@ -107,15 +113,19 @@ typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreZirconHandleFUCHSIA)(VkDevice typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA( VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA( VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle); #endif +#endif // VK_FUCHSIA_buffer_collection is a preprocessor guard. Do not pass it to API calls. @@ -228,32 +238,42 @@ typedef void (VKAPI_PTR *PFN_vkDestroyBufferCollectionFUCHSIA)(VkDevice device, typedef VkResult (VKAPI_PTR *PFN_vkGetBufferCollectionPropertiesFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIA( VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIA( VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIA( VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA( VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA( VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties); #endif +#endif #ifdef __cplusplus } diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_ggp.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_ggp.h index 4b6affc..156c84a 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_ggp.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_ggp.h @@ -34,12 +34,14 @@ typedef struct VkStreamDescriptorSurfaceCreateInfoGGP { typedef VkResult (VKAPI_PTR *PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP( VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif +#endif // VK_GGP_frame_token is a preprocessor guard. Do not pass it to API calls. diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_ios.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_ios.h index a705dc6..94feb5f 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_ios.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_ios.h @@ -34,12 +34,14 @@ typedef struct VkIOSSurfaceCreateInfoMVK { typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif +#endif #ifdef __cplusplus } diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_macos.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_macos.h index 8d5dd05..07b32d6 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_macos.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_macos.h @@ -34,12 +34,14 @@ typedef struct VkMacOSSurfaceCreateInfoMVK { typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif +#endif #ifdef __cplusplus } diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_metal.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_metal.h index 7e44f54..325c371 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_metal.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_metal.h @@ -40,12 +40,14 @@ typedef struct VkMetalSurfaceCreateInfoEXT { typedef VkResult (VKAPI_PTR *PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT( VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif +#endif // VK_EXT_metal_objects is a preprocessor guard. Do not pass it to API calls. @@ -183,10 +185,12 @@ typedef struct VkImportMetalSharedEventInfoEXT { typedef void (VKAPI_PTR *PFN_vkExportMetalObjectsEXT)(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT( VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); #endif +#endif // VK_EXT_external_memory_metal is a preprocessor guard. Do not pass it to API calls. @@ -217,17 +221,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandleEXT)(VkDevice device, con typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandlePropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT( VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties); #endif +#endif #ifdef __cplusplus } diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_ohos.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_ohos.h new file mode 100644 index 0000000..7a6b49a --- /dev/null +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_ohos.h @@ -0,0 +1,182 @@ +#ifndef VULKAN_OHOS_H_ +#define VULKAN_OHOS_H_ 1 + +/* +** Copyright 2015-2025 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 + + + +// VK_OHOS_external_memory is a preprocessor guard. Do not pass it to API calls. +#define VK_OHOS_external_memory 1 +struct OH_NativeBuffer; +#define VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION 2 +#define VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME "VK_OHOS_external_memory" +typedef struct VkNativeBufferUsageOHOS { + VkStructureType sType; + void* pNext; + uint64_t OHOSNativeBufferUsage; +} VkNativeBufferUsageOHOS; + +typedef struct VkNativeBufferPropertiesOHOS { + VkStructureType sType; + void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeBits; +} VkNativeBufferPropertiesOHOS; + +typedef struct VkNativeBufferFormatPropertiesOHOS { + VkStructureType sType; + void* pNext; + VkFormat format; + uint64_t externalFormat; + VkFormatFeatureFlags formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; +} VkNativeBufferFormatPropertiesOHOS; + +typedef struct VkImportNativeBufferInfoOHOS { + VkStructureType sType; + const void* pNext; + struct OH_NativeBuffer* buffer; +} VkImportNativeBufferInfoOHOS; + +typedef struct VkMemoryGetNativeBufferInfoOHOS { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkMemoryGetNativeBufferInfoOHOS; + +typedef struct VkExternalFormatOHOS { + VkStructureType sType; + void* pNext; + uint64_t externalFormat; +} VkExternalFormatOHOS; + +typedef VkResult (VKAPI_PTR *PFN_vkGetNativeBufferPropertiesOHOS)(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryNativeBufferOHOS)(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer); +#endif +#endif + + +// VK_OHOS_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_OHOS_surface 1 +typedef struct NativeWindow OHNativeWindow; +#define VK_OHOS_SURFACE_SPEC_VERSION 1 +#define VK_OHOS_SURFACE_EXTENSION_NAME "VK_OHOS_surface" +typedef VkFlags VkSurfaceCreateFlagsOHOS; +typedef struct VkSurfaceCreateInfoOHOS { + VkStructureType sType; + const void* pNext; + VkSurfaceCreateFlagsOHOS flags; + OHNativeWindow* window; +} VkSurfaceCreateInfoOHOS; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSurfaceOHOS)(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif + + +// VK_OHOS_native_buffer is a preprocessor guard. Do not pass it to API calls. +#define VK_OHOS_native_buffer 1 +struct OHBufferHandle; +#define VK_OHOS_NATIVE_BUFFER_SPEC_VERSION 1 +#define VK_OHOS_NATIVE_BUFFER_EXTENSION_NAME "VK_OHOS_native_buffer" + +typedef enum VkSwapchainImageUsageFlagBitsOHOS { + VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_OHOS = 0x00000001, + VK_SWAPCHAIN_IMAGE_USAGE_FLAG_BITS_MAX_ENUM_OHOS = 0x7FFFFFFF +} VkSwapchainImageUsageFlagBitsOHOS; +typedef VkFlags VkSwapchainImageUsageFlagsOHOS; +typedef struct VkNativeBufferOHOS { + VkStructureType sType; + const void* pNext; + struct OHBufferHandle* handle; +} VkNativeBufferOHOS; + +typedef struct VkSwapchainImageCreateInfoOHOS { + VkStructureType sType; + const void* pNext; + VkSwapchainImageUsageFlagsOHOS usage; +} VkSwapchainImageCreateInfoOHOS; + +typedef struct VkPhysicalDevicePresentationPropertiesOHOS { + VkStructureType sType; + void* pNext; + VkBool32 sharedImage; +} VkPhysicalDevicePresentationPropertiesOHOS; + +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsageOHOS)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, uint64_t* grallocUsage); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireImageOHOS)(VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSignalReleaseImageOHOS)(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int32_t* pNativeFenceFd); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainGrallocUsageOHOS( + VkDevice device, + VkFormat format, + VkImageUsageFlags imageUsage, + uint64_t* grallocUsage); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireImageOHOS( + VkDevice device, + VkImage image, + int32_t nativeFenceFd, + VkSemaphore semaphore, + VkFence fence); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSignalReleaseImageOHOS( + VkQueue queue, + uint32_t waitSemaphoreCount, + const VkSemaphore* pWaitSemaphores, + VkImage image, + int32_t* pNativeFenceFd); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_screen.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_screen.h index 6c8bfd2..79b04f0 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_screen.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_screen.h @@ -36,17 +36,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateScreenSurfaceQNX)(VkInstance instance, typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX( VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window); #endif +#endif // VK_QNX_external_memory_screen_buffer is a preprocessor guard. Do not pass it to API calls. @@ -95,11 +99,13 @@ typedef struct VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX { typedef VkResult (VKAPI_PTR *PFN_vkGetScreenBufferPropertiesQNX)(VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetScreenBufferPropertiesQNX( VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties); #endif +#endif #ifdef __cplusplus } diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_vi.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_vi.h index a30bfb1..5a52a17 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_vi.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_vi.h @@ -34,12 +34,14 @@ typedef struct VkViSurfaceCreateInfoNN { typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); #endif +#endif #ifdef __cplusplus } diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_wayland.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_wayland.h index 75bf070..3172bad 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_wayland.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_wayland.h @@ -36,17 +36,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); #endif +#endif #ifdef __cplusplus } diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_win32.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_win32.h index e66ed1f..beee808 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_win32.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_win32.h @@ -36,16 +36,20 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, c typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); #endif +#endif // VK_KHR_external_memory_win32 is a preprocessor guard. Do not pass it to API calls. @@ -85,17 +89,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, con typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); #endif +#endif // VK_KHR_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls. @@ -158,15 +166,19 @@ typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice devic typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); #endif +#endif // VK_KHR_external_fence_win32 is a preprocessor guard. Do not pass it to API calls. @@ -202,15 +214,19 @@ typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, c typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); #endif +#endif // VK_NV_external_memory_win32 is a preprocessor guard. Do not pass it to API calls. @@ -234,12 +250,14 @@ typedef struct VkExportMemoryWin32HandleInfoNV { typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle); #endif +#endif // VK_NV_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls. @@ -296,25 +314,33 @@ typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice d typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT( VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes); #endif +#endif // VK_NV_acquire_winrt_display is a preprocessor guard. Do not pass it to API calls. @@ -325,15 +351,19 @@ typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physi typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay); #endif +#endif #ifdef __cplusplus } diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_xcb.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_xcb.h index 4e06275..e6acb9c 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_xcb.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_xcb.h @@ -36,18 +36,22 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, con typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); #endif +#endif #ifdef __cplusplus } diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_xlib.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_xlib.h index b581779..e2593fc 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_xlib.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_xlib.h @@ -36,18 +36,22 @@ typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, co typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); #endif +#endif #ifdef __cplusplus } diff --git a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_xlib_xrandr.h b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_xlib_xrandr.h index ba88a66..88b643f 100644 --- a/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_xlib_xrandr.h +++ b/libs/bgfx/3rdparty/khronos/vulkan-local/vulkan_xlib_xrandr.h @@ -27,17 +27,21 @@ typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physi typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay); #ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display); +#endif +#ifndef VK_ONLY_EXPORTED_PROTOTYPES VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay); #endif +#endif #ifdef __cplusplus } diff --git a/libs/bgfx/3rdparty/spirv-cross/main.cpp b/libs/bgfx/3rdparty/spirv-cross/main.cpp index ea3ecf4..6059016 100644 --- a/libs/bgfx/3rdparty/spirv-cross/main.cpp +++ b/libs/bgfx/3rdparty/spirv-cross/main.cpp @@ -536,6 +536,7 @@ static void print_resources(const Compiler &compiler, const ShaderResources &res print_resources(compiler, "push", res.push_constant_buffers); print_resources(compiler, "counters", res.atomic_counters); print_resources(compiler, "acceleration structures", res.acceleration_structures); + print_resources(compiler, "tensors", res.tensors); print_resources(compiler, "record buffers", res.shader_record_buffers); print_resources(compiler, spv::StorageClassInput, res.builtin_inputs); print_resources(compiler, spv::StorageClassOutput, res.builtin_outputs); diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv.h b/libs/bgfx/3rdparty/spirv-cross/spirv.h index 43dd311..005d451 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv.h +++ b/libs/bgfx/3rdparty/spirv-cross/spirv.h @@ -1,27 +1,11 @@ /* -** Copyright (c) 2014-2024 The Khronos Group Inc. +** Copyright: 2014-2024 The Khronos Group Inc. +** License: MIT ** -** Permission is hereby granted, free of charge, to any person obtaining a copy -** of this software and/or associated documentation files (the "Materials"), -** to deal in the Materials without restriction, including without limitation -** the rights to use, copy, modify, merge, publish, distribute, sublicense, -** and/or sell copies of the Materials, and to permit persons to whom the -** Materials are furnished to do so, subject to the following conditions: -** -** The above copyright notice and this permission notice shall be included in -** all copies or substantial portions of the Materials. -** -** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS -** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND -** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ -** -** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS -** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS -** IN THE MATERIALS. +** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS +** KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS +** SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT +** https://www.khronos.org/registry/ */ /* @@ -176,6 +160,8 @@ typedef enum SpvExecutionMode_ { SpvExecutionModeSignedZeroInfNanPreserve = 4461, SpvExecutionModeRoundingModeRTE = 4462, SpvExecutionModeRoundingModeRTZ = 4463, + SpvExecutionModeNonCoherentTileAttachmentReadQCOM = 4489, + SpvExecutionModeTileShadingRateQCOM = 4490, SpvExecutionModeEarlyAndLateFragmentTestsAMD = 5017, SpvExecutionModeStencilRefReplacingEXT = 5027, SpvExecutionModeCoalescingAMDX = 5069, @@ -245,6 +231,7 @@ typedef enum SpvStorageClass_ { SpvStorageClassImage = 11, SpvStorageClassStorageBuffer = 12, SpvStorageClassTileImageEXT = 4172, + SpvStorageClassTileAttachmentQCOM = 4491, SpvStorageClassNodePayloadAMDX = 5068, SpvStorageClassCallableDataKHR = 5328, SpvStorageClassCallableDataNV = 5328, @@ -554,6 +541,7 @@ typedef enum SpvDecoration_ { SpvDecorationMaxByteOffset = 45, SpvDecorationAlignmentId = 46, SpvDecorationMaxByteOffsetId = 47, + SpvDecorationSaturatedToLargestFloat8NormalConversionEXT = 4216, SpvDecorationNoSignedWrap = 4469, SpvDecorationNoUnsignedWrap = 4470, SpvDecorationWeightTextureQCOM = 4487, @@ -723,6 +711,9 @@ typedef enum SpvBuiltIn_ { SpvBuiltInDeviceIndex = 4438, SpvBuiltInViewIndex = 4440, SpvBuiltInShadingRateKHR = 4444, + SpvBuiltInTileOffsetQCOM = 4492, + SpvBuiltInTileDimensionQCOM = 4493, + SpvBuiltInTileApronSizeQCOM = 4494, SpvBuiltInBaryCoordNoPerspAMD = 4992, SpvBuiltInBaryCoordNoPerspCentroidAMD = 4993, SpvBuiltInBaryCoordNoPerspSampleAMD = 4994, @@ -1073,7 +1064,13 @@ typedef enum SpvCapability_ { SpvCapabilityTileImageColorReadAccessEXT = 4166, SpvCapabilityTileImageDepthReadAccessEXT = 4167, SpvCapabilityTileImageStencilReadAccessEXT = 4168, + SpvCapabilityTensorsARM = 4174, + SpvCapabilityStorageTensorArrayDynamicIndexingARM = 4175, + SpvCapabilityStorageTensorArrayNonUniformIndexingARM = 4176, + SpvCapabilityGraphARM = 4191, SpvCapabilityCooperativeMatrixLayoutsARM = 4201, + SpvCapabilityFloat8EXT = 4212, + SpvCapabilityFloat8CooperativeMatrixEXT = 4213, SpvCapabilityFragmentShadingRateKHR = 4422, SpvCapabilitySubgroupBallotKHR = 4423, SpvCapabilityDrawParameters = 4427, @@ -1109,6 +1106,7 @@ typedef enum SpvCapability_ { SpvCapabilityTextureSampleWeightedQCOM = 4484, SpvCapabilityTextureBoxFilterQCOM = 4485, SpvCapabilityTextureBlockMatchQCOM = 4486, + SpvCapabilityTileShadingQCOM = 4495, SpvCapabilityTextureBlockMatch2QCOM = 4498, SpvCapabilityFloat16ImageAMD = 5008, SpvCapabilityImageGatherBiasLodAMD = 5009, @@ -1119,6 +1117,8 @@ typedef enum SpvCapability_ { SpvCapabilityShaderClockKHR = 5055, SpvCapabilityShaderEnqueueAMDX = 5067, SpvCapabilityQuadControlKHR = 5087, + SpvCapabilityInt4TypeINTEL = 5112, + SpvCapabilityInt4CooperativeMatrixINTEL = 5114, SpvCapabilityBFloat16TypeKHR = 5116, SpvCapabilityBFloat16DotProductKHR = 5117, SpvCapabilityBFloat16CooperativeMatrixKHR = 5118, @@ -1287,6 +1287,7 @@ typedef enum SpvCapability_ { SpvCapabilityMaskedGatherScatterINTEL = 6427, SpvCapabilityCacheControlsINTEL = 6441, SpvCapabilityRegisterLimitsINTEL = 6460, + SpvCapabilityBindlessImagesINTEL = 6528, SpvCapabilityMax = 0x7fffffff, } SpvCapability; @@ -1463,6 +1464,24 @@ typedef enum SpvTensorAddressingOperandsMask_ { SpvTensorAddressingOperandsDecodeFuncMask = 0x00000002, } SpvTensorAddressingOperandsMask; +typedef enum SpvTensorOperandsShift_ { + SpvTensorOperandsNontemporalARMShift = 0, + SpvTensorOperandsOutOfBoundsValueARMShift = 1, + SpvTensorOperandsMakeElementAvailableARMShift = 2, + SpvTensorOperandsMakeElementVisibleARMShift = 3, + SpvTensorOperandsNonPrivateElementARMShift = 4, + SpvTensorOperandsMax = 0x7fffffff, +} SpvTensorOperandsShift; + +typedef enum SpvTensorOperandsMask_ { + SpvTensorOperandsMaskNone = 0, + SpvTensorOperandsNontemporalARMMask = 0x00000001, + SpvTensorOperandsOutOfBoundsValueARMMask = 0x00000002, + SpvTensorOperandsMakeElementAvailableARMMask = 0x00000004, + SpvTensorOperandsMakeElementVisibleARMMask = 0x00000008, + SpvTensorOperandsNonPrivateElementARMMask = 0x00000010, +} SpvTensorOperandsMask; + typedef enum SpvInitializationModeQualifier_ { SpvInitializationModeQualifierInitOnDeviceReprogramINTEL = 0, SpvInitializationModeQualifierInitOnDeviceResetINTEL = 1, @@ -1549,6 +1568,8 @@ typedef enum SpvRawAccessChainOperandsMask_ { typedef enum SpvFPEncoding_ { SpvFPEncodingBFloat16KHR = 0, + SpvFPEncodingFloat8E4M3EXT = 4214, + SpvFPEncodingFloat8E5M2EXT = 4215, SpvFPEncodingMax = 0x7fffffff, } SpvFPEncoding; @@ -1927,6 +1948,17 @@ typedef enum SpvOp_ { SpvOpColorAttachmentReadEXT = 4160, SpvOpDepthAttachmentReadEXT = 4161, SpvOpStencilAttachmentReadEXT = 4162, + SpvOpTypeTensorARM = 4163, + SpvOpTensorReadARM = 4164, + SpvOpTensorWriteARM = 4165, + SpvOpTensorQuerySizeARM = 4166, + SpvOpGraphConstantARM = 4181, + SpvOpGraphEntryPointARM = 4182, + SpvOpGraphARM = 4183, + SpvOpGraphInputARM = 4184, + SpvOpGraphSetOutputARM = 4185, + SpvOpGraphEndARM = 4186, + SpvOpTypeGraphARM = 4190, SpvOpTerminateInvocation = 4416, SpvOpTypeUntypedPointerKHR = 4417, SpvOpUntypedVariableKHR = 4418, @@ -2385,6 +2417,9 @@ typedef enum SpvOp_ { SpvOpRoundFToTF32INTEL = 6426, SpvOpMaskedGatherINTEL = 6428, SpvOpMaskedScatterINTEL = 6429, + SpvOpConvertHandleToImageINTEL = 6529, + SpvOpConvertHandleToSamplerINTEL = 6530, + SpvOpConvertHandleToSampledImageINTEL = 6531, SpvOpMax = 0x7fffffff, } SpvOp; @@ -2743,6 +2778,17 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy case SpvOpColorAttachmentReadEXT: *hasResult = true; *hasResultType = true; break; case SpvOpDepthAttachmentReadEXT: *hasResult = true; *hasResultType = true; break; case SpvOpStencilAttachmentReadEXT: *hasResult = true; *hasResultType = true; break; + case SpvOpTypeTensorARM: *hasResult = true; *hasResultType = false; break; + case SpvOpTensorReadARM: *hasResult = true; *hasResultType = true; break; + case SpvOpTensorWriteARM: *hasResult = false; *hasResultType = false; break; + case SpvOpTensorQuerySizeARM: *hasResult = true; *hasResultType = true; break; + case SpvOpGraphConstantARM: *hasResult = true; *hasResultType = true; break; + case SpvOpGraphEntryPointARM: *hasResult = false; *hasResultType = false; break; + case SpvOpGraphARM: *hasResult = true; *hasResultType = true; break; + case SpvOpGraphInputARM: *hasResult = true; *hasResultType = true; break; + case SpvOpGraphSetOutputARM: *hasResult = false; *hasResultType = false; break; + case SpvOpGraphEndARM: *hasResult = false; *hasResultType = false; break; + case SpvOpTypeGraphARM: *hasResult = true; *hasResultType = false; break; case SpvOpTerminateInvocation: *hasResult = false; *hasResultType = false; break; case SpvOpTypeUntypedPointerKHR: *hasResult = true; *hasResultType = false; break; case SpvOpUntypedVariableKHR: *hasResult = true; *hasResultType = true; break; @@ -3190,6 +3236,9 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy case SpvOpRoundFToTF32INTEL: *hasResult = true; *hasResultType = true; break; case SpvOpMaskedGatherINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpMaskedScatterINTEL: *hasResult = false; *hasResultType = false; break; + case SpvOpConvertHandleToImageINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpConvertHandleToSamplerINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpConvertHandleToSampledImageINTEL: *hasResult = true; *hasResultType = true; break; } } inline const char* SpvSourceLanguageToString(SpvSourceLanguage value) { @@ -3305,6 +3354,8 @@ inline const char* SpvExecutionModeToString(SpvExecutionMode value) { case SpvExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; case SpvExecutionModeRoundingModeRTE: return "RoundingModeRTE"; case SpvExecutionModeRoundingModeRTZ: return "RoundingModeRTZ"; + case SpvExecutionModeNonCoherentTileAttachmentReadQCOM: return "NonCoherentTileAttachmentReadQCOM"; + case SpvExecutionModeTileShadingRateQCOM: return "TileShadingRateQCOM"; case SpvExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD"; case SpvExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT"; case SpvExecutionModeCoalescingAMDX: return "CoalescingAMDX"; @@ -3371,6 +3422,7 @@ inline const char* SpvStorageClassToString(SpvStorageClass value) { case SpvStorageClassImage: return "Image"; case SpvStorageClassStorageBuffer: return "StorageBuffer"; case SpvStorageClassTileImageEXT: return "TileImageEXT"; + case SpvStorageClassTileAttachmentQCOM: return "TileAttachmentQCOM"; case SpvStorageClassNodePayloadAMDX: return "NodePayloadAMDX"; case SpvStorageClassCallableDataKHR: return "CallableDataKHR"; case SpvStorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR"; @@ -3619,6 +3671,7 @@ inline const char* SpvDecorationToString(SpvDecoration value) { case SpvDecorationMaxByteOffset: return "MaxByteOffset"; case SpvDecorationAlignmentId: return "AlignmentId"; case SpvDecorationMaxByteOffsetId: return "MaxByteOffsetId"; + case SpvDecorationSaturatedToLargestFloat8NormalConversionEXT: return "SaturatedToLargestFloat8NormalConversionEXT"; case SpvDecorationNoSignedWrap: return "NoSignedWrap"; case SpvDecorationNoUnsignedWrap: return "NoUnsignedWrap"; case SpvDecorationWeightTextureQCOM: return "WeightTextureQCOM"; @@ -3778,6 +3831,9 @@ inline const char* SpvBuiltInToString(SpvBuiltIn value) { case SpvBuiltInDeviceIndex: return "DeviceIndex"; case SpvBuiltInViewIndex: return "ViewIndex"; case SpvBuiltInShadingRateKHR: return "ShadingRateKHR"; + case SpvBuiltInTileOffsetQCOM: return "TileOffsetQCOM"; + case SpvBuiltInTileDimensionQCOM: return "TileDimensionQCOM"; + case SpvBuiltInTileApronSizeQCOM: return "TileApronSizeQCOM"; case SpvBuiltInBaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD"; case SpvBuiltInBaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD"; case SpvBuiltInBaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD"; @@ -3958,7 +4014,13 @@ inline const char* SpvCapabilityToString(SpvCapability value) { case SpvCapabilityTileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT"; case SpvCapabilityTileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT"; case SpvCapabilityTileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT"; + case SpvCapabilityTensorsARM: return "TensorsARM"; + case SpvCapabilityStorageTensorArrayDynamicIndexingARM: return "StorageTensorArrayDynamicIndexingARM"; + case SpvCapabilityStorageTensorArrayNonUniformIndexingARM: return "StorageTensorArrayNonUniformIndexingARM"; + case SpvCapabilityGraphARM: return "GraphARM"; case SpvCapabilityCooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM"; + case SpvCapabilityFloat8EXT: return "Float8EXT"; + case SpvCapabilityFloat8CooperativeMatrixEXT: return "Float8CooperativeMatrixEXT"; case SpvCapabilityFragmentShadingRateKHR: return "FragmentShadingRateKHR"; case SpvCapabilitySubgroupBallotKHR: return "SubgroupBallotKHR"; case SpvCapabilityDrawParameters: return "DrawParameters"; @@ -3992,6 +4054,7 @@ inline const char* SpvCapabilityToString(SpvCapability value) { case SpvCapabilityTextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM"; case SpvCapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM"; case SpvCapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM"; + case SpvCapabilityTileShadingQCOM: return "TileShadingQCOM"; case SpvCapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM"; case SpvCapabilityFloat16ImageAMD: return "Float16ImageAMD"; case SpvCapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; @@ -4002,6 +4065,8 @@ inline const char* SpvCapabilityToString(SpvCapability value) { case SpvCapabilityShaderClockKHR: return "ShaderClockKHR"; case SpvCapabilityShaderEnqueueAMDX: return "ShaderEnqueueAMDX"; case SpvCapabilityQuadControlKHR: return "QuadControlKHR"; + case SpvCapabilityInt4TypeINTEL: return "Int4TypeINTEL"; + case SpvCapabilityInt4CooperativeMatrixINTEL: return "Int4CooperativeMatrixINTEL"; case SpvCapabilityBFloat16TypeKHR: return "BFloat16TypeKHR"; case SpvCapabilityBFloat16DotProductKHR: return "BFloat16DotProductKHR"; case SpvCapabilityBFloat16CooperativeMatrixKHR: return "BFloat16CooperativeMatrixKHR"; @@ -4144,6 +4209,7 @@ inline const char* SpvCapabilityToString(SpvCapability value) { case SpvCapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL"; case SpvCapabilityCacheControlsINTEL: return "CacheControlsINTEL"; case SpvCapabilityRegisterLimitsINTEL: return "RegisterLimitsINTEL"; + case SpvCapabilityBindlessImagesINTEL: return "BindlessImagesINTEL"; default: return "Unknown"; } } @@ -4299,6 +4365,8 @@ inline const char* SpvNamedMaximumNumberOfRegistersToString(SpvNamedMaximumNumbe inline const char* SpvFPEncodingToString(SpvFPEncoding value) { switch (value) { case SpvFPEncodingBFloat16KHR: return "BFloat16KHR"; + case SpvFPEncodingFloat8E4M3EXT: return "Float8E4M3EXT"; + case SpvFPEncodingFloat8E5M2EXT: return "Float8E5M2EXT"; default: return "Unknown"; } } @@ -4683,6 +4751,17 @@ inline const char* SpvOpToString(SpvOp value) { case SpvOpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT"; case SpvOpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT"; case SpvOpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT"; + case SpvOpTypeTensorARM: return "OpTypeTensorARM"; + case SpvOpTensorReadARM: return "OpTensorReadARM"; + case SpvOpTensorWriteARM: return "OpTensorWriteARM"; + case SpvOpTensorQuerySizeARM: return "OpTensorQuerySizeARM"; + case SpvOpGraphConstantARM: return "OpGraphConstantARM"; + case SpvOpGraphEntryPointARM: return "OpGraphEntryPointARM"; + case SpvOpGraphARM: return "OpGraphARM"; + case SpvOpGraphInputARM: return "OpGraphInputARM"; + case SpvOpGraphSetOutputARM: return "OpGraphSetOutputARM"; + case SpvOpGraphEndARM: return "OpGraphEndARM"; + case SpvOpTypeGraphARM: return "OpTypeGraphARM"; case SpvOpTerminateInvocation: return "OpTerminateInvocation"; case SpvOpTypeUntypedPointerKHR: return "OpTypeUntypedPointerKHR"; case SpvOpUntypedVariableKHR: return "OpUntypedVariableKHR"; @@ -5130,6 +5209,9 @@ inline const char* SpvOpToString(SpvOp value) { case SpvOpRoundFToTF32INTEL: return "OpRoundFToTF32INTEL"; case SpvOpMaskedGatherINTEL: return "OpMaskedGatherINTEL"; case SpvOpMaskedScatterINTEL: return "OpMaskedScatterINTEL"; + case SpvOpConvertHandleToImageINTEL: return "OpConvertHandleToImageINTEL"; + case SpvOpConvertHandleToSamplerINTEL: return "OpConvertHandleToSamplerINTEL"; + case SpvOpConvertHandleToSampledImageINTEL: return "OpConvertHandleToSampledImageINTEL"; default: return "Unknown"; } } diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv.hpp b/libs/bgfx/3rdparty/spirv-cross/spirv.hpp index 5fbba32..f7a7bf8 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv.hpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv.hpp @@ -1,26 +1,10 @@ -// Copyright (c) 2014-2024 The Khronos Group Inc. +// Copyright: 2014-2024 The Khronos Group Inc. +// License: MIT // -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and/or associated documentation files (the "Materials"), -// to deal in the Materials without restriction, including without limitation -// the rights to use, copy, modify, merge, publish, distribute, sublicense, -// and/or sell copies of the Materials, and to permit persons to whom the -// Materials are furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Materials. -// -// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS -// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND -// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ -// -// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS -// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS -// IN THE MATERIALS. +// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS +// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS +// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT +// https://www.khronos.org/registry/ // This header is automatically generated by the same tool that creates // the Binary Section of the SPIR-V specification. @@ -172,6 +156,8 @@ enum ExecutionMode { ExecutionModeSignedZeroInfNanPreserve = 4461, ExecutionModeRoundingModeRTE = 4462, ExecutionModeRoundingModeRTZ = 4463, + ExecutionModeNonCoherentTileAttachmentReadQCOM = 4489, + ExecutionModeTileShadingRateQCOM = 4490, ExecutionModeEarlyAndLateFragmentTestsAMD = 5017, ExecutionModeStencilRefReplacingEXT = 5027, ExecutionModeCoalescingAMDX = 5069, @@ -241,6 +227,7 @@ enum StorageClass { StorageClassImage = 11, StorageClassStorageBuffer = 12, StorageClassTileImageEXT = 4172, + StorageClassTileAttachmentQCOM = 4491, StorageClassNodePayloadAMDX = 5068, StorageClassCallableDataKHR = 5328, StorageClassCallableDataNV = 5328, @@ -550,6 +537,7 @@ enum Decoration { DecorationMaxByteOffset = 45, DecorationAlignmentId = 46, DecorationMaxByteOffsetId = 47, + DecorationSaturatedToLargestFloat8NormalConversionEXT = 4216, DecorationNoSignedWrap = 4469, DecorationNoUnsignedWrap = 4470, DecorationWeightTextureQCOM = 4487, @@ -719,6 +707,9 @@ enum BuiltIn { BuiltInDeviceIndex = 4438, BuiltInViewIndex = 4440, BuiltInShadingRateKHR = 4444, + BuiltInTileOffsetQCOM = 4492, + BuiltInTileDimensionQCOM = 4493, + BuiltInTileApronSizeQCOM = 4494, BuiltInBaryCoordNoPerspAMD = 4992, BuiltInBaryCoordNoPerspCentroidAMD = 4993, BuiltInBaryCoordNoPerspSampleAMD = 4994, @@ -1069,7 +1060,13 @@ enum Capability { CapabilityTileImageColorReadAccessEXT = 4166, CapabilityTileImageDepthReadAccessEXT = 4167, CapabilityTileImageStencilReadAccessEXT = 4168, + CapabilityTensorsARM = 4174, + CapabilityStorageTensorArrayDynamicIndexingARM = 4175, + CapabilityStorageTensorArrayNonUniformIndexingARM = 4176, + CapabilityGraphARM = 4191, CapabilityCooperativeMatrixLayoutsARM = 4201, + CapabilityFloat8EXT = 4212, + CapabilityFloat8CooperativeMatrixEXT = 4213, CapabilityFragmentShadingRateKHR = 4422, CapabilitySubgroupBallotKHR = 4423, CapabilityDrawParameters = 4427, @@ -1105,6 +1102,7 @@ enum Capability { CapabilityTextureSampleWeightedQCOM = 4484, CapabilityTextureBoxFilterQCOM = 4485, CapabilityTextureBlockMatchQCOM = 4486, + CapabilityTileShadingQCOM = 4495, CapabilityTextureBlockMatch2QCOM = 4498, CapabilityFloat16ImageAMD = 5008, CapabilityImageGatherBiasLodAMD = 5009, @@ -1115,6 +1113,8 @@ enum Capability { CapabilityShaderClockKHR = 5055, CapabilityShaderEnqueueAMDX = 5067, CapabilityQuadControlKHR = 5087, + CapabilityInt4TypeINTEL = 5112, + CapabilityInt4CooperativeMatrixINTEL = 5114, CapabilityBFloat16TypeKHR = 5116, CapabilityBFloat16DotProductKHR = 5117, CapabilityBFloat16CooperativeMatrixKHR = 5118, @@ -1283,6 +1283,7 @@ enum Capability { CapabilityMaskedGatherScatterINTEL = 6427, CapabilityCacheControlsINTEL = 6441, CapabilityRegisterLimitsINTEL = 6460, + CapabilityBindlessImagesINTEL = 6528, CapabilityMax = 0x7fffffff, }; @@ -1459,6 +1460,24 @@ enum TensorAddressingOperandsMask { TensorAddressingOperandsDecodeFuncMask = 0x00000002, }; +enum TensorOperandsShift { + TensorOperandsNontemporalARMShift = 0, + TensorOperandsOutOfBoundsValueARMShift = 1, + TensorOperandsMakeElementAvailableARMShift = 2, + TensorOperandsMakeElementVisibleARMShift = 3, + TensorOperandsNonPrivateElementARMShift = 4, + TensorOperandsMax = 0x7fffffff, +}; + +enum TensorOperandsMask { + TensorOperandsMaskNone = 0, + TensorOperandsNontemporalARMMask = 0x00000001, + TensorOperandsOutOfBoundsValueARMMask = 0x00000002, + TensorOperandsMakeElementAvailableARMMask = 0x00000004, + TensorOperandsMakeElementVisibleARMMask = 0x00000008, + TensorOperandsNonPrivateElementARMMask = 0x00000010, +}; + enum InitializationModeQualifier { InitializationModeQualifierInitOnDeviceReprogramINTEL = 0, InitializationModeQualifierInitOnDeviceResetINTEL = 1, @@ -1545,6 +1564,8 @@ enum RawAccessChainOperandsMask { enum FPEncoding { FPEncodingBFloat16KHR = 0, + FPEncodingFloat8E4M3EXT = 4214, + FPEncodingFloat8E5M2EXT = 4215, FPEncodingMax = 0x7fffffff, }; @@ -1923,6 +1944,17 @@ enum Op { OpColorAttachmentReadEXT = 4160, OpDepthAttachmentReadEXT = 4161, OpStencilAttachmentReadEXT = 4162, + OpTypeTensorARM = 4163, + OpTensorReadARM = 4164, + OpTensorWriteARM = 4165, + OpTensorQuerySizeARM = 4166, + OpGraphConstantARM = 4181, + OpGraphEntryPointARM = 4182, + OpGraphARM = 4183, + OpGraphInputARM = 4184, + OpGraphSetOutputARM = 4185, + OpGraphEndARM = 4186, + OpTypeGraphARM = 4190, OpTerminateInvocation = 4416, OpTypeUntypedPointerKHR = 4417, OpUntypedVariableKHR = 4418, @@ -2381,6 +2413,9 @@ enum Op { OpRoundFToTF32INTEL = 6426, OpMaskedGatherINTEL = 6428, OpMaskedScatterINTEL = 6429, + OpConvertHandleToImageINTEL = 6529, + OpConvertHandleToSamplerINTEL = 6530, + OpConvertHandleToSampledImageINTEL = 6531, OpMax = 0x7fffffff, }; @@ -2739,6 +2774,17 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case OpColorAttachmentReadEXT: *hasResult = true; *hasResultType = true; break; case OpDepthAttachmentReadEXT: *hasResult = true; *hasResultType = true; break; case OpStencilAttachmentReadEXT: *hasResult = true; *hasResultType = true; break; + case OpTypeTensorARM: *hasResult = true; *hasResultType = false; break; + case OpTensorReadARM: *hasResult = true; *hasResultType = true; break; + case OpTensorWriteARM: *hasResult = false; *hasResultType = false; break; + case OpTensorQuerySizeARM: *hasResult = true; *hasResultType = true; break; + case OpGraphConstantARM: *hasResult = true; *hasResultType = true; break; + case OpGraphEntryPointARM: *hasResult = false; *hasResultType = false; break; + case OpGraphARM: *hasResult = true; *hasResultType = true; break; + case OpGraphInputARM: *hasResult = true; *hasResultType = true; break; + case OpGraphSetOutputARM: *hasResult = false; *hasResultType = false; break; + case OpGraphEndARM: *hasResult = false; *hasResultType = false; break; + case OpTypeGraphARM: *hasResult = true; *hasResultType = false; break; case OpTerminateInvocation: *hasResult = false; *hasResultType = false; break; case OpTypeUntypedPointerKHR: *hasResult = true; *hasResultType = false; break; case OpUntypedVariableKHR: *hasResult = true; *hasResultType = true; break; @@ -3186,6 +3232,9 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case OpRoundFToTF32INTEL: *hasResult = true; *hasResultType = true; break; case OpMaskedGatherINTEL: *hasResult = true; *hasResultType = true; break; case OpMaskedScatterINTEL: *hasResult = false; *hasResultType = false; break; + case OpConvertHandleToImageINTEL: *hasResult = true; *hasResultType = true; break; + case OpConvertHandleToSamplerINTEL: *hasResult = true; *hasResultType = true; break; + case OpConvertHandleToSampledImageINTEL: *hasResult = true; *hasResultType = true; break; } } inline const char* SourceLanguageToString(SourceLanguage value) { @@ -3301,6 +3350,8 @@ inline const char* ExecutionModeToString(ExecutionMode value) { case ExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve"; case ExecutionModeRoundingModeRTE: return "RoundingModeRTE"; case ExecutionModeRoundingModeRTZ: return "RoundingModeRTZ"; + case ExecutionModeNonCoherentTileAttachmentReadQCOM: return "NonCoherentTileAttachmentReadQCOM"; + case ExecutionModeTileShadingRateQCOM: return "TileShadingRateQCOM"; case ExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD"; case ExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT"; case ExecutionModeCoalescingAMDX: return "CoalescingAMDX"; @@ -3367,6 +3418,7 @@ inline const char* StorageClassToString(StorageClass value) { case StorageClassImage: return "Image"; case StorageClassStorageBuffer: return "StorageBuffer"; case StorageClassTileImageEXT: return "TileImageEXT"; + case StorageClassTileAttachmentQCOM: return "TileAttachmentQCOM"; case StorageClassNodePayloadAMDX: return "NodePayloadAMDX"; case StorageClassCallableDataKHR: return "CallableDataKHR"; case StorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR"; @@ -3615,6 +3667,7 @@ inline const char* DecorationToString(Decoration value) { case DecorationMaxByteOffset: return "MaxByteOffset"; case DecorationAlignmentId: return "AlignmentId"; case DecorationMaxByteOffsetId: return "MaxByteOffsetId"; + case DecorationSaturatedToLargestFloat8NormalConversionEXT: return "SaturatedToLargestFloat8NormalConversionEXT"; case DecorationNoSignedWrap: return "NoSignedWrap"; case DecorationNoUnsignedWrap: return "NoUnsignedWrap"; case DecorationWeightTextureQCOM: return "WeightTextureQCOM"; @@ -3774,6 +3827,9 @@ inline const char* BuiltInToString(BuiltIn value) { case BuiltInDeviceIndex: return "DeviceIndex"; case BuiltInViewIndex: return "ViewIndex"; case BuiltInShadingRateKHR: return "ShadingRateKHR"; + case BuiltInTileOffsetQCOM: return "TileOffsetQCOM"; + case BuiltInTileDimensionQCOM: return "TileDimensionQCOM"; + case BuiltInTileApronSizeQCOM: return "TileApronSizeQCOM"; case BuiltInBaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD"; case BuiltInBaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD"; case BuiltInBaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD"; @@ -3954,7 +4010,13 @@ inline const char* CapabilityToString(Capability value) { case CapabilityTileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT"; case CapabilityTileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT"; case CapabilityTileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT"; + case CapabilityTensorsARM: return "TensorsARM"; + case CapabilityStorageTensorArrayDynamicIndexingARM: return "StorageTensorArrayDynamicIndexingARM"; + case CapabilityStorageTensorArrayNonUniformIndexingARM: return "StorageTensorArrayNonUniformIndexingARM"; + case CapabilityGraphARM: return "GraphARM"; case CapabilityCooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM"; + case CapabilityFloat8EXT: return "Float8EXT"; + case CapabilityFloat8CooperativeMatrixEXT: return "Float8CooperativeMatrixEXT"; case CapabilityFragmentShadingRateKHR: return "FragmentShadingRateKHR"; case CapabilitySubgroupBallotKHR: return "SubgroupBallotKHR"; case CapabilityDrawParameters: return "DrawParameters"; @@ -3988,6 +4050,7 @@ inline const char* CapabilityToString(Capability value) { case CapabilityTextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM"; case CapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM"; case CapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM"; + case CapabilityTileShadingQCOM: return "TileShadingQCOM"; case CapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM"; case CapabilityFloat16ImageAMD: return "Float16ImageAMD"; case CapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; @@ -3998,6 +4061,8 @@ inline const char* CapabilityToString(Capability value) { case CapabilityShaderClockKHR: return "ShaderClockKHR"; case CapabilityShaderEnqueueAMDX: return "ShaderEnqueueAMDX"; case CapabilityQuadControlKHR: return "QuadControlKHR"; + case CapabilityInt4TypeINTEL: return "Int4TypeINTEL"; + case CapabilityInt4CooperativeMatrixINTEL: return "Int4CooperativeMatrixINTEL"; case CapabilityBFloat16TypeKHR: return "BFloat16TypeKHR"; case CapabilityBFloat16DotProductKHR: return "BFloat16DotProductKHR"; case CapabilityBFloat16CooperativeMatrixKHR: return "BFloat16CooperativeMatrixKHR"; @@ -4140,6 +4205,7 @@ inline const char* CapabilityToString(Capability value) { case CapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL"; case CapabilityCacheControlsINTEL: return "CacheControlsINTEL"; case CapabilityRegisterLimitsINTEL: return "RegisterLimitsINTEL"; + case CapabilityBindlessImagesINTEL: return "BindlessImagesINTEL"; default: return "Unknown"; } } @@ -4295,6 +4361,8 @@ inline const char* NamedMaximumNumberOfRegistersToString(NamedMaximumNumberOfReg inline const char* FPEncodingToString(FPEncoding value) { switch (value) { case FPEncodingBFloat16KHR: return "BFloat16KHR"; + case FPEncodingFloat8E4M3EXT: return "Float8E4M3EXT"; + case FPEncodingFloat8E5M2EXT: return "Float8E5M2EXT"; default: return "Unknown"; } } @@ -4679,6 +4747,17 @@ inline const char* OpToString(Op value) { case OpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT"; case OpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT"; case OpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT"; + case OpTypeTensorARM: return "OpTypeTensorARM"; + case OpTensorReadARM: return "OpTensorReadARM"; + case OpTensorWriteARM: return "OpTensorWriteARM"; + case OpTensorQuerySizeARM: return "OpTensorQuerySizeARM"; + case OpGraphConstantARM: return "OpGraphConstantARM"; + case OpGraphEntryPointARM: return "OpGraphEntryPointARM"; + case OpGraphARM: return "OpGraphARM"; + case OpGraphInputARM: return "OpGraphInputARM"; + case OpGraphSetOutputARM: return "OpGraphSetOutputARM"; + case OpGraphEndARM: return "OpGraphEndARM"; + case OpTypeGraphARM: return "OpTypeGraphARM"; case OpTerminateInvocation: return "OpTerminateInvocation"; case OpTypeUntypedPointerKHR: return "OpTypeUntypedPointerKHR"; case OpUntypedVariableKHR: return "OpUntypedVariableKHR"; @@ -5126,6 +5205,9 @@ inline const char* OpToString(Op value) { case OpRoundFToTF32INTEL: return "OpRoundFToTF32INTEL"; case OpMaskedGatherINTEL: return "OpMaskedGatherINTEL"; case OpMaskedScatterINTEL: return "OpMaskedScatterINTEL"; + case OpConvertHandleToImageINTEL: return "OpConvertHandleToImageINTEL"; + case OpConvertHandleToSamplerINTEL: return "OpConvertHandleToSamplerINTEL"; + case OpConvertHandleToSampledImageINTEL: return "OpConvertHandleToSampledImageINTEL"; default: return "Unknown"; } } @@ -5186,6 +5268,10 @@ inline TensorAddressingOperandsMask operator|(TensorAddressingOperandsMask a, Te inline TensorAddressingOperandsMask operator&(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) & unsigned(b)); } inline TensorAddressingOperandsMask operator^(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) ^ unsigned(b)); } inline TensorAddressingOperandsMask operator~(TensorAddressingOperandsMask a) { return TensorAddressingOperandsMask(~unsigned(a)); } +inline TensorOperandsMask operator|(TensorOperandsMask a, TensorOperandsMask b) { return TensorOperandsMask(unsigned(a) | unsigned(b)); } +inline TensorOperandsMask operator&(TensorOperandsMask a, TensorOperandsMask b) { return TensorOperandsMask(unsigned(a) & unsigned(b)); } +inline TensorOperandsMask operator^(TensorOperandsMask a, TensorOperandsMask b) { return TensorOperandsMask(unsigned(a) ^ unsigned(b)); } +inline TensorOperandsMask operator~(TensorOperandsMask a) { return TensorOperandsMask(~unsigned(a)); } inline MatrixMultiplyAccumulateOperandsMask operator|(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) | unsigned(b)); } inline MatrixMultiplyAccumulateOperandsMask operator&(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) & unsigned(b)); } inline MatrixMultiplyAccumulateOperandsMask operator^(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) ^ unsigned(b)); } diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_cfg.cpp b/libs/bgfx/3rdparty/spirv-cross/spirv_cfg.cpp index 9329947..c68886d 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_cfg.cpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_cfg.cpp @@ -81,31 +81,105 @@ bool CFG::is_back_edge(uint32_t to) const // We have a back edge if the visit order is set with the temporary magic value 0. // Crossing edges will have already been recorded with a visit order. auto itr = visit_order.find(to); - return itr != end(visit_order) && itr->second.get() == 0; + return itr != end(visit_order) && itr->second.visited_branches && !itr->second.visited_resolve; } -bool CFG::has_visited_forward_edge(uint32_t to) const +bool CFG::has_visited_branch(uint32_t to) const { - // If > 0, we have visited the edge already, and this is not a back edge branch. auto itr = visit_order.find(to); - return itr != end(visit_order) && itr->second.get() > 0; + return itr != end(visit_order) && itr->second.visited_branches; } -bool CFG::post_order_visit(uint32_t block_id) +void CFG::post_order_visit_entry(uint32_t block) { - // If we have already branched to this block (back edge), stop recursion. - // If our branches are back-edges, we do not record them. - // We have to record crossing edges however. - if (has_visited_forward_edge(block_id)) - return true; - else if (is_back_edge(block_id)) - return false; + visit_stack.push_back(block); - // Block back-edges from recursively revisiting ourselves. - visit_order[block_id].get() = 0; + while (!visit_stack.empty()) + { + bool keep_iterating; + do + { + // Reverse the order to allow for stack-like behavior and preserves the visit order from recursive algorithm. + // Traverse depth first. + uint32_t to_visit = visit_stack.back(); + last_visited_size = visit_stack.size(); + post_order_visit_branches(to_visit); + keep_iterating = last_visited_size != visit_stack.size(); + if (keep_iterating) + std::reverse(visit_stack.begin() + last_visited_size, visit_stack.end()); + } while (keep_iterating); + + // We've reached the end of some tree leaf. Resolve the stack. + // Any node which has been visited for real can be popped now. + while (!visit_stack.empty() && visit_order[visit_stack.back()].visited_branches) + { + post_order_visit_resolve(visit_stack.back()); + visit_stack.pop_back(); + } + } +} + +void CFG::visit_branch(uint32_t block_id) +{ + // Prune obvious duplicates. + if (std::find(visit_stack.begin() + last_visited_size, visit_stack.end(), block_id) == visit_stack.end() && + !has_visited_branch(block_id)) + { + visit_stack.push_back(block_id); + } +} + +void CFG::post_order_visit_branches(uint32_t block_id) +{ + auto &block = compiler.get(block_id); + + auto &visit = visit_order[block_id]; + if (visit.visited_branches) + return; + visit.visited_branches = true; + + if (block.merge == SPIRBlock::MergeLoop) + visit_branch(block.merge_block); + else if (block.merge == SPIRBlock::MergeSelection) + visit_branch(block.next_block); + + // First visit our branch targets. + switch (block.terminator) + { + case SPIRBlock::Direct: + visit_branch(block.next_block); + break; + + case SPIRBlock::Select: + visit_branch(block.true_block); + visit_branch(block.false_block); + break; + case SPIRBlock::MultiSelect: + { + const auto &cases = compiler.get_case_list(block); + for (const auto &target : cases) + visit_branch(target.block); + if (block.default_block) + visit_branch(block.default_block); + break; + } + + default: + break; + } +} + +void CFG::post_order_visit_resolve(uint32_t block_id) +{ auto &block = compiler.get(block_id); + auto &visit_block = visit_order[block_id]; + assert(visit_block.visited_branches); + auto &visited = visit_order[block_id].visited_resolve; + if (visited) + return; + // If this is a loop header, add an implied branch to the merge target. // This is needed to avoid annoying cases with do { ... } while(false) loops often generated by inliners. // To the CFG, this is linear control flow, but we risk picking the do/while scope as our dominating block. @@ -116,21 +190,21 @@ bool CFG::post_order_visit(uint32_t block_id) // is lower than inside the loop, which is going to be key for some traversal algorithms like post-dominance analysis. // For selection constructs true/false blocks will end up visiting the merge block directly and it works out fine, // but for loops, only the header might end up actually branching to merge block. - if (block.merge == SPIRBlock::MergeLoop && post_order_visit(block.merge_block)) + if (block.merge == SPIRBlock::MergeLoop && !is_back_edge(block.merge_block)) add_branch(block_id, block.merge_block); // First visit our branch targets. switch (block.terminator) { case SPIRBlock::Direct: - if (post_order_visit(block.next_block)) + if (!is_back_edge(block.next_block)) add_branch(block_id, block.next_block); break; case SPIRBlock::Select: - if (post_order_visit(block.true_block)) + if (!is_back_edge(block.true_block)) add_branch(block_id, block.true_block); - if (post_order_visit(block.false_block)) + if (!is_back_edge(block.false_block)) add_branch(block_id, block.false_block); break; @@ -139,10 +213,10 @@ bool CFG::post_order_visit(uint32_t block_id) const auto &cases = compiler.get_case_list(block); for (const auto &target : cases) { - if (post_order_visit(target.block)) + if (!is_back_edge(target.block)) add_branch(block_id, target.block); } - if (block.default_block && post_order_visit(block.default_block)) + if (block.default_block && !is_back_edge(block.default_block)) add_branch(block_id, block.default_block); break; } @@ -157,7 +231,7 @@ bool CFG::post_order_visit(uint32_t block_id) // We can use the variable without a Phi since there is only one possible parent here. // However, in this case, we need to hoist out the inner variable to outside the branch. // Use same strategy as loops. - if (block.merge == SPIRBlock::MergeSelection && post_order_visit(block.next_block)) + if (block.merge == SPIRBlock::MergeSelection && !is_back_edge(block.next_block)) { // If there is only one preceding edge to the merge block and it's not ourselves, we need a fixup. // Add a fake branch so any dominator in either the if (), or else () block, or a lone case statement @@ -201,10 +275,9 @@ bool CFG::post_order_visit(uint32_t block_id) } } - // Then visit ourselves. Start counting at one, to let 0 be a magic value for testing back vs. crossing edges. - visit_order[block_id].get() = ++visit_count; + visited = true; + visit_block.order = ++visit_count; post_order.push_back(block_id); - return true; } void CFG::build_post_order_visit_order() @@ -213,11 +286,12 @@ void CFG::build_post_order_visit_order() visit_count = 0; visit_order.clear(); post_order.clear(); - post_order_visit(block); + post_order_visit_entry(block); } void CFG::add_branch(uint32_t from, uint32_t to) { + assert(from && to); const auto add_unique = [](SmallVector &l, uint32_t value) { auto itr = find(begin(l), end(l), value); if (itr == end(l)) diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_cfg.hpp b/libs/bgfx/3rdparty/spirv-cross/spirv_cfg.hpp index 1d85fe0..1c21ea0 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_cfg.hpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_cfg.hpp @@ -68,7 +68,7 @@ class CFG { auto itr = visit_order.find(block); assert(itr != std::end(visit_order)); - int v = itr->second.get(); + int v = itr->second.order; assert(v > 0); return uint32_t(v); } @@ -114,17 +114,9 @@ class CFG private: struct VisitOrder { - int &get() - { - return v; - } - - const int &get() const - { - return v; - } - - int v = -1; + int order = -1; + bool visited_resolve = false; + bool visited_branches = false; }; Compiler &compiler; @@ -139,11 +131,17 @@ class CFG void add_branch(uint32_t from, uint32_t to); void build_post_order_visit_order(); void build_immediate_dominators(); - bool post_order_visit(uint32_t block); + void post_order_visit_branches(uint32_t block); + void post_order_visit_resolve(uint32_t block); + void post_order_visit_entry(uint32_t block); uint32_t visit_count = 0; bool is_back_edge(uint32_t to) const; - bool has_visited_forward_edge(uint32_t to) const; + bool has_visited_branch(uint32_t to) const; + void visit_branch(uint32_t block_id); + + SmallVector visit_stack; + size_t last_visited_size = 0; }; class DominatorBuilder diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_common.hpp b/libs/bgfx/3rdparty/spirv-cross/spirv_common.hpp index a4778c2..854efe5 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_common.hpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_common.hpp @@ -574,6 +574,7 @@ struct SPIRType : IVariant Sampler, AccelerationStructure, RayQuery, + CoopVecNV, // Keep internal types at the end. ControlPointArray, @@ -581,7 +582,11 @@ struct SPIRType : IVariant Char, // MSL specific type, that is used by 'object'(analog of 'task' from glsl) shader. MeshGridProperties, - BFloat16 + BFloat16, + FloatE4M3, + FloatE5M2, + + Tensor }; // Scalar/vector/matrix support. @@ -606,13 +611,29 @@ struct SPIRType : IVariant bool pointer = false; bool forward_pointer = false; - struct + union { - uint32_t use_id = 0; - uint32_t rows_id = 0; - uint32_t columns_id = 0; - uint32_t scope_id = 0; - } cooperative; + struct + { + uint32_t use_id; + uint32_t rows_id; + uint32_t columns_id; + uint32_t scope_id; + } cooperative; + + struct + { + uint32_t component_type_id; + uint32_t component_count_id; + } coopVecNV; + + struct + { + uint32_t type; + uint32_t rank; + uint32_t shape; + } tensor; + } ext; spv::StorageClass storage = spv::StorageClassGeneric; @@ -670,6 +691,12 @@ struct SPIRExtension : IVariant NonSemanticGeneric }; + enum ShaderDebugInfoOps + { + DebugLine = 103, + DebugSource = 35 + }; + explicit SPIRExtension(Extension ext_) : ext(ext_) { @@ -695,6 +722,11 @@ struct SPIREntryPoint FunctionID self = 0; std::string name; std::string orig_name; + std::unordered_map fp_fast_math_defaults; + bool signed_zero_inf_nan_preserve_8 = false; + bool signed_zero_inf_nan_preserve_16 = false; + bool signed_zero_inf_nan_preserve_32 = false; + bool signed_zero_inf_nan_preserve_64 = false; SmallVector interface_variables; Bitset flags; @@ -927,6 +959,7 @@ struct SPIRBlock : IVariant // All access to these variables are dominated by this block, // so before branching anywhere we need to make sure that we declare these variables. SmallVector dominated_variables; + SmallVector rearm_dominated_variables; // These are variables which should be declared in a for loop header, if we // fail to use a classic for-loop, @@ -1238,6 +1271,26 @@ struct SPIRConstant : IVariant return u.f32; } + static inline float fe4m3_to_f32(uint8_t v) + { + if ((v & 0x7f) == 0x7f) + { + union + { + float f32; + uint32_t u32; + } u; + + u.u32 = (v & 0x80) ? 0xffffffffu : 0x7fffffffu; + return u.f32; + } + else + { + // Reuse the FP16 to FP32 code. Cute bit-hackery. + return f16_to_f32((int16_t(int8_t(v)) << 7) & (0xffff ^ 0x4000)) * 256.0f; + } + } + inline uint32_t specialization_constant_id(uint32_t col, uint32_t row) const { return m.c[col].id[row]; @@ -1286,6 +1339,16 @@ struct SPIRConstant : IVariant return fp32; } + inline float scalar_floate4m3(uint32_t col = 0, uint32_t row = 0) const + { + return fe4m3_to_f32(scalar_u8(col, row)); + } + + inline float scalar_bf8(uint32_t col = 0, uint32_t row = 0) const + { + return f16_to_f32(scalar_u8(col, row) << 8); + } + inline float scalar_f32(uint32_t col = 0, uint32_t row = 0) const { return m.c[col].r[row].f32; @@ -1356,9 +1419,10 @@ struct SPIRConstant : IVariant SPIRConstant() = default; - SPIRConstant(TypeID constant_type_, const uint32_t *elements, uint32_t num_elements, bool specialized) + SPIRConstant(TypeID constant_type_, const uint32_t *elements, uint32_t num_elements, bool specialized, bool replicated_ = false) : constant_type(constant_type_) , specialization(specialized) + , replicated(replicated_) { subconstants.reserve(num_elements); for (uint32_t i = 0; i < num_elements; i++) @@ -1437,6 +1501,9 @@ struct SPIRConstant : IVariant // For composites which are constant arrays, etc. SmallVector subconstants; + // Whether the subconstants are intended to be replicated (e.g. OpConstantCompositeReplicateEXT) + bool replicated = false; + // Non-Vulkan GLSL, HLSL and sometimes MSL emits defines for each specialization constant, // and uses them to initialize the constant. This allows the user // to still be able to specialize the value by supplying corresponding @@ -1732,6 +1799,7 @@ struct Meta uint32_t spec_id = 0; uint32_t index = 0; spv::FPRoundingMode fp_rounding_mode = spv::FPRoundingModeMax; + spv::FPFastMathModeMask fp_fast_math_mode = spv::FPFastMathModeMaskNone; bool builtin = false; bool qualified_alias_explicit_override = false; @@ -1787,7 +1855,8 @@ class Hasher static inline bool type_is_floating_point(const SPIRType &type) { - return type.basetype == SPIRType::Half || type.basetype == SPIRType::Float || type.basetype == SPIRType::Double; + return type.basetype == SPIRType::Half || type.basetype == SPIRType::Float || type.basetype == SPIRType::Double || + type.basetype == SPIRType::BFloat16 || type.basetype == SPIRType::FloatE5M2 || type.basetype == SPIRType::FloatE4M3; } static inline bool type_is_integral(const SPIRType &type) diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_cross.cpp b/libs/bgfx/3rdparty/spirv-cross/spirv_cross.cpp index 8aa4e5e..4c1d39d 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_cross.cpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_cross.cpp @@ -280,6 +280,9 @@ bool Compiler::block_is_pure(const SPIRBlock &block) // This is a global side effect of the function. return false; + case OpTensorReadARM: + return false; + case OpExtInst: { uint32_t extension_set = ops[2]; @@ -373,6 +376,7 @@ void Compiler::register_global_read_dependencies(const SPIRBlock &block, uint32_ case OpLoad: case OpCooperativeMatrixLoadKHR: + case OpCooperativeVectorLoadNV: case OpImageRead: { // If we're in a storage class which does not get invalidated, adding dependencies here is no big deal. @@ -1152,6 +1156,11 @@ ShaderResources Compiler::get_shader_resources(const unordered_set * { res.acceleration_structures.push_back({ var.self, var.basetype, type.self, get_name(var.self) }); } + // Tensors + else if (type.basetype == SPIRType::Tensor) + { + res.tensors.push_back({ var.self, var.basetype, type.self, get_name(var.self) }); + } else { res.gl_plain_uniforms.push_back({ var.self, var.basetype, type.self, get_name(var.self) }); @@ -1169,11 +1178,8 @@ bool Compiler::type_is_top_level_block(const SPIRType &type) const return has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock); } -bool Compiler::type_is_block_like(const SPIRType &type) const +bool Compiler::type_is_explicit_layout(const SPIRType &type) const { - if (type_is_top_level_block(type)) - return true; - if (type.basetype == SPIRType::Struct) { // Block-like types may have Offset decorations. @@ -1185,6 +1191,14 @@ bool Compiler::type_is_block_like(const SPIRType &type) const return false; } +bool Compiler::type_is_block_like(const SPIRType &type) const +{ + if (type_is_top_level_block(type)) + return true; + else + return type_is_explicit_layout(type); +} + void Compiler::parse_fixup() { // Figure out specialization constants for work group sizes. @@ -2370,6 +2384,10 @@ void Compiler::set_execution_mode(ExecutionMode mode, uint32_t arg0, uint32_t ar execution.output_primitives = arg0; break; + case ExecutionModeFPFastMathDefault: + execution.fp_fast_math_defaults[arg0] = arg1; + break; + default: break; } @@ -4334,6 +4352,7 @@ bool Compiler::may_read_undefined_variable_in_block(const SPIRBlock &block, uint case OpCopyObject: case OpLoad: + case OpCooperativeVectorLoadNV: case OpCooperativeMatrixLoadKHR: if (ops[2] == var) return true; @@ -5151,7 +5170,7 @@ bool Compiler::is_depth_image(const SPIRType &type, uint32_t id) const bool Compiler::type_is_opaque_value(const SPIRType &type) const { return !type.pointer && (type.basetype == SPIRType::SampledImage || type.basetype == SPIRType::Image || - type.basetype == SPIRType::Sampler); + type.basetype == SPIRType::Sampler || type.basetype == SPIRType::Tensor); } // Make these member functions so we can easily break on any force_recompile events. @@ -5469,6 +5488,7 @@ bool Compiler::InterlockedResourceAccessHandler::handle(Op opcode, const uint32_ { case OpLoad: case OpCooperativeMatrixLoadKHR: + case OpCooperativeVectorLoadNV: { if (length < 3) return false; @@ -5547,6 +5567,7 @@ bool Compiler::InterlockedResourceAccessHandler::handle(Op opcode, const uint32_ case OpImageWrite: case OpAtomicStore: case OpCooperativeMatrixStoreKHR: + case OpCooperativeVectorStoreNV: { if (length < 1) return false; diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_cross.hpp b/libs/bgfx/3rdparty/spirv-cross/spirv_cross.hpp index b65b5ac..65e4bed 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_cross.hpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_cross.hpp @@ -95,6 +95,7 @@ struct ShaderResources SmallVector atomic_counters; SmallVector acceleration_structures; SmallVector gl_plain_uniforms; + SmallVector tensors; // There can only be one push constant block, // but keep the vector in case this restriction is lifted in the future. @@ -1171,6 +1172,7 @@ class Compiler bool type_contains_recursion(const SPIRType &type); bool type_is_array_of_pointers(const SPIRType &type) const; bool type_is_block_like(const SPIRType &type) const; + bool type_is_explicit_layout(const SPIRType &type) const; bool type_is_top_level_block(const SPIRType &type) const; bool type_is_opaque_value(const SPIRType &type) const; diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_cross_c.cpp b/libs/bgfx/3rdparty/spirv-cross/spirv_cross_c.cpp index 6827f61..8a4a492 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_cross_c.cpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_cross_c.cpp @@ -200,6 +200,7 @@ struct spvc_resources_s : ScratchMemoryAllocation SmallVector separate_samplers; SmallVector acceleration_structures; SmallVector gl_plain_uniforms; + SmallVector tensors; SmallVector builtin_inputs; SmallVector builtin_outputs; @@ -1872,6 +1873,8 @@ bool spvc_resources_s::copy_resources(const ShaderResources &resources) return false; if (!copy_resources(gl_plain_uniforms, resources.gl_plain_uniforms)) return false; + if (!copy_resources(tensors, resources.tensors)) + return false; if (!copy_resources(builtin_inputs, resources.builtin_inputs)) return false; if (!copy_resources(builtin_outputs, resources.builtin_outputs)) @@ -2025,6 +2028,11 @@ spvc_result spvc_resources_get_resource_list_for_type(spvc_resources resources, case SPVC_RESOURCE_TYPE_GL_PLAIN_UNIFORM: list = &resources->gl_plain_uniforms; + break; + + case SPVC_RESOURCE_TYPE_TENSOR: + list = &resources->tensors; + break; default: break; diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_cross_c.h b/libs/bgfx/3rdparty/spirv-cross/spirv_cross_c.h index 4eab922..f360711 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_cross_c.h +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_cross_c.h @@ -40,7 +40,7 @@ extern "C" { /* Bumped if ABI or API breaks backwards compatibility. */ #define SPVC_C_API_VERSION_MAJOR 0 /* Bumped if APIs or enumerations are added in a backwards compatible way. */ -#define SPVC_C_API_VERSION_MINOR 66 +#define SPVC_C_API_VERSION_MINOR 67 /* Bumped if internal implementation details change. */ #define SPVC_C_API_VERSION_PATCH 0 @@ -227,6 +227,7 @@ typedef enum spvc_resource_type SPVC_RESOURCE_TYPE_RAY_QUERY = 13, SPVC_RESOURCE_TYPE_SHADER_RECORD_BUFFER = 14, SPVC_RESOURCE_TYPE_GL_PLAIN_UNIFORM = 15, + SPVC_RESOURCE_TYPE_TENSOR = 16, SPVC_RESOURCE_TYPE_INT_MAX = 0x7fffffff } spvc_resource_type; diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_cross_parsed_ir.cpp b/libs/bgfx/3rdparty/spirv-cross/spirv_cross_parsed_ir.cpp index 397e40f..1dcd24e 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_cross_parsed_ir.cpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_cross_parsed_ir.cpp @@ -452,6 +452,10 @@ void ParsedIR::set_decoration(ID id, Decoration decoration, uint32_t argument) dec.fp_rounding_mode = static_cast(argument); break; + case DecorationFPFastMathMode: + dec.fp_fast_math_mode = static_cast(argument); + break; + default: break; } @@ -523,8 +527,27 @@ void ParsedIR::mark_used_as_array_length(ID id) switch (ids[id].get_type()) { case TypeConstant: - get(id).is_used_as_array_length = true; + { + auto &c = get(id); + c.is_used_as_array_length = true; + + // Mark composite dependencies as well. + for (auto &sub_id: c.m.id) + if (sub_id) + mark_used_as_array_length(sub_id); + + for (uint32_t col = 0; col < c.m.columns; col++) + { + for (auto &sub_id : c.m.c[col].id) + if (sub_id) + mark_used_as_array_length(sub_id); + } + + for (auto &sub_id : c.subconstants) + if (sub_id) + mark_used_as_array_length(sub_id); break; + } case TypeConstantOp: { @@ -643,6 +666,8 @@ uint32_t ParsedIR::get_decoration(ID id, Decoration decoration) const return dec.index; case DecorationFPRoundingMode: return dec.fp_rounding_mode; + case DecorationFPFastMathMode: + return dec.fp_fast_math_mode; default: return 1; } @@ -730,6 +755,10 @@ void ParsedIR::unset_decoration(ID id, Decoration decoration) dec.fp_rounding_mode = FPRoundingModeMax; break; + case DecorationFPFastMathMode: + dec.fp_fast_math_mode = FPFastMathModeMaskNone; + break; + case DecorationHlslCounterBufferGOOGLE: { auto &counter = meta[id].hlsl_magic_counter_buffer; diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_cross_parsed_ir.hpp b/libs/bgfx/3rdparty/spirv-cross/spirv_cross_parsed_ir.hpp index 3892248..8c30ef8 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_cross_parsed_ir.hpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_cross_parsed_ir.hpp @@ -111,6 +111,7 @@ class ParsedIR struct Source { + spv::SourceLanguage lang = spv::SourceLanguageUnknown; uint32_t version = 0; bool es = false; bool known = false; diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_glsl.cpp b/libs/bgfx/3rdparty/spirv-cross/spirv_glsl.cpp index ca9d030..5392bd7 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_glsl.cpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_glsl.cpp @@ -41,6 +41,9 @@ using namespace spv; using namespace SPIRV_CROSS_NAMESPACE; using namespace std; +namespace SPIRV_CROSS_NAMESPACE +{ + enum ExtraSubExpressionType { // Create masks above any legal ID range to allow multiple address spaces into the extra_sub_expressions map. @@ -48,6 +51,46 @@ enum ExtraSubExpressionType EXTRA_SUB_EXPRESSION_TYPE_AUX = 0x20000000 }; +struct GlslConstantNameMapping +{ + uint32_t value; + const char *alias; +}; + +#define DEF_GLSL_MAPPING(x) { x, "gl_" #x } +#define DEF_GLSL_MAPPING_EXT(x) { x##KHR, "gl_" #x } +static const GlslConstantNameMapping CoopVecComponentTypeNames[] = { + DEF_GLSL_MAPPING(ComponentTypeFloat16NV), + DEF_GLSL_MAPPING(ComponentTypeFloat32NV), + DEF_GLSL_MAPPING(ComponentTypeFloat64NV), + DEF_GLSL_MAPPING(ComponentTypeSignedInt8NV), + DEF_GLSL_MAPPING(ComponentTypeSignedInt16NV), + DEF_GLSL_MAPPING(ComponentTypeSignedInt32NV), + DEF_GLSL_MAPPING(ComponentTypeSignedInt64NV), + DEF_GLSL_MAPPING(ComponentTypeUnsignedInt8NV), + DEF_GLSL_MAPPING(ComponentTypeUnsignedInt16NV), + DEF_GLSL_MAPPING(ComponentTypeUnsignedInt32NV), + DEF_GLSL_MAPPING(ComponentTypeUnsignedInt64NV), + DEF_GLSL_MAPPING(ComponentTypeSignedInt8PackedNV), + DEF_GLSL_MAPPING(ComponentTypeUnsignedInt8PackedNV), + DEF_GLSL_MAPPING(ComponentTypeFloatE4M3NV), + DEF_GLSL_MAPPING(ComponentTypeFloatE5M2NV), +}; + +static const GlslConstantNameMapping CoopVecMatrixLayoutNames[] = { + DEF_GLSL_MAPPING(CooperativeVectorMatrixLayoutRowMajorNV), + DEF_GLSL_MAPPING(CooperativeVectorMatrixLayoutColumnMajorNV), + DEF_GLSL_MAPPING(CooperativeVectorMatrixLayoutInferencingOptimalNV), + DEF_GLSL_MAPPING(CooperativeVectorMatrixLayoutTrainingOptimalNV), +}; + +static const GlslConstantNameMapping CoopMatMatrixLayoutNames[] = { + DEF_GLSL_MAPPING_EXT(CooperativeMatrixLayoutRowMajor), + DEF_GLSL_MAPPING_EXT(CooperativeMatrixLayoutColumnMajor), +}; +#undef DEF_GLSL_MAPPING +#undef DEF_GLSL_MAPPING_EXT + static bool is_unsigned_opcode(Op op) { // Don't have to be exhaustive, only relevant for legacy target checking ... @@ -159,6 +202,7 @@ static BufferPackingStandard packing_to_substruct_packing(BufferPackingStandard return packing; } } +} void CompilerGLSL::init() { @@ -617,6 +661,19 @@ void CompilerGLSL::find_static_extensions() ray_tracing_is_khr = true; break; + case CapabilityRayTracingClusterAccelerationStructureNV: + if (options.es || options.version < 460 || !options.vulkan_semantics) + SPIRV_CROSS_THROW("Cluster AS requires Vulkan GLSL 460."); + require_extension_internal("GL_NV_cluster_acceleration_structure"); + ray_tracing_is_khr = true; + break; + + case CapabilityTensorsARM: + if (options.es || options.version < 460 || !options.vulkan_semantics) + SPIRV_CROSS_THROW("Tensor requires Vulkan GLSL 460."); + require_extension_internal("GL_ARM_tensors"); + break; + default: break; } @@ -1529,9 +1586,12 @@ uint32_t CompilerGLSL::type_to_packed_base_size(const SPIRType &type, BufferPack case SPIRType::Half: case SPIRType::Short: case SPIRType::UShort: + case SPIRType::BFloat16: return 2; case SPIRType::SByte: case SPIRType::UByte: + case SPIRType::FloatE4M3: + case SPIRType::FloatE5M2: return 1; default: @@ -2550,7 +2610,7 @@ void CompilerGLSL::emit_buffer_block_flattened(const SPIRVariable &var) SPIRV_CROSS_THROW("Basic types in a flattened UBO must be float, int or uint."); auto flags = ir.get_buffer_block_flags(var); - statement("uniform ", flags_to_qualifiers_glsl(tmp, flags), type_to_glsl(tmp), " ", buffer_name, "[", + statement("uniform ", flags_to_qualifiers_glsl(tmp, 0, flags), type_to_glsl(tmp), " ", buffer_name, "[", buffer_size, "];"); } else @@ -5791,8 +5851,22 @@ string CompilerGLSL::constant_op_expression(const SPIRConstantOp &cop) case OpCompositeExtract: { - auto expr = access_chain_internal(cop.arguments[0], &cop.arguments[1], uint32_t(cop.arguments.size() - 1), - ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, nullptr); + // Trivial vector extracts (of WorkGroupSize typically), + // punch through to the input spec constant if the composite is used as array size. + const auto *c = maybe_get(cop.arguments[0]); + + string expr; + if (c && cop.arguments.size() == 2 && c->is_used_as_array_length && + !backend.supports_spec_constant_array_size && + is_vector(get(c->constant_type))) + { + expr = to_expression(c->specialization_constant_id(0, cop.arguments[1])); + } + else + { + expr = access_chain_internal(cop.arguments[0], &cop.arguments[1], uint32_t(cop.arguments.size() - 1), + ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, nullptr); + } return expr; } @@ -5940,6 +6014,30 @@ string CompilerGLSL::constant_expression(const SPIRConstant &c, require_extension_internal("GL_EXT_null_initializer"); return backend.constant_null_initializer; } + else if (c.replicated && type.op != spv::OpTypeArray) + { + if (type.op == spv::OpTypeMatrix) + { + uint32_t num_elements = type.columns; + // GLSL does not allow the replication constructor for matrices + // mat4(vec4(0.0)) needs to be manually expanded to mat4(vec4(0.0), vec4(0.0), vec4(0.0), vec4(0.0)); + std::string res; + res += type_to_glsl(type); + res += "("; + for (uint32_t i = 0; i < num_elements; i++) + { + res += to_expression(c.subconstants[0]); + if (i < num_elements - 1) + res += ", "; + } + res += ")"; + return res; + } + else + { + return join(type_to_glsl(type), "(", to_expression(c.subconstants[0]), ")"); + } + } else if (!c.subconstants.empty()) { // Handles Arrays and structures. @@ -5989,8 +6087,16 @@ string CompilerGLSL::constant_expression(const SPIRConstant &c, } uint32_t subconstant_index = 0; - for (auto &elem : c.subconstants) + size_t num_elements = c.subconstants.size(); + if (c.replicated) { + if (type.array.size() != 1) + SPIRV_CROSS_THROW("Multidimensional arrays not yet supported as replicated constans"); + num_elements = type.array[0]; + } + for (size_t i = 0; i < num_elements; i++) + { + auto &elem = c.subconstants[c.replicated ? 0 : i]; if (auto *op = maybe_get(elem)) { res += constant_op_expression(*op); @@ -6021,7 +6127,7 @@ string CompilerGLSL::constant_expression(const SPIRConstant &c, } } - if (&elem != &c.subconstants.back()) + if (i != num_elements - 1) res += ", "; subconstant_index++; @@ -6095,17 +6201,44 @@ string CompilerGLSL::constant_expression(const SPIRConstant &c, #pragma warning(disable : 4996) #endif +string CompilerGLSL::convert_floate4m3_to_string(const SPIRConstant &c, uint32_t col, uint32_t row) +{ + string res; + float float_value = c.scalar_floate4m3(col, row); + + // There is no infinity in e4m3. + if (std::isnan(float_value)) + { + SPIRType type { OpTypeFloat }; + type.basetype = SPIRType::Half; + type.vecsize = 1; + type.columns = 1; + res = join(type_to_glsl(type), "(0.0 / 0.0)"); + } + else + { + SPIRType type { OpTypeFloat }; + type.basetype = SPIRType::FloatE4M3; + type.vecsize = 1; + type.columns = 1; + res = join(type_to_glsl(type), "(", format_float(float_value), ")"); + } + + return res; +} + string CompilerGLSL::convert_half_to_string(const SPIRConstant &c, uint32_t col, uint32_t row) { string res; - float float_value = c.scalar_f16(col, row); + bool is_bfloat8 = get(c.constant_type).basetype == SPIRType::FloatE5M2; + float float_value = is_bfloat8 ? c.scalar_bf8(col, row) : c.scalar_f16(col, row); // There is no literal "hf" in GL_NV_gpu_shader5, so to avoid lots // of complicated workarounds, just value-cast to the half type always. if (std::isnan(float_value) || std::isinf(float_value)) { SPIRType type { OpTypeFloat }; - type.basetype = SPIRType::Half; + type.basetype = is_bfloat8 ? SPIRType::FloatE5M2 : SPIRType::Half; type.vecsize = 1; type.columns = 1; @@ -6121,7 +6254,7 @@ string CompilerGLSL::convert_half_to_string(const SPIRConstant &c, uint32_t col, else { SPIRType type { OpTypeFloat }; - type.basetype = SPIRType::Half; + type.basetype = is_bfloat8 ? SPIRType::FloatE5M2 : SPIRType::Half; type.vecsize = 1; type.columns = 1; res = join(type_to_glsl(type), "(", format_float(float_value), ")"); @@ -6358,6 +6491,29 @@ string CompilerGLSL::constant_expression_vector(const SPIRConstant &c, uint32_t switch (type.basetype) { + case SPIRType::FloatE4M3: + if (splat || swizzle_splat) + { + res += convert_floate4m3_to_string(c, vector, 0); + if (swizzle_splat) + res = remap_swizzle(get(c.constant_type), 1, res); + } + else + { + for (uint32_t i = 0; i < c.vector_size(); i++) + { + if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0) + res += to_expression(c.specialization_constant_id(vector, i)); + else + res += convert_floate4m3_to_string(c, vector, i); + + if (i + 1 < c.vector_size()) + res += ", "; + } + } + break; + + case SPIRType::FloatE5M2: case SPIRType::Half: if (splat || swizzle_splat) { @@ -6722,7 +6878,7 @@ void CompilerGLSL::emit_uninitialized_temporary(uint32_t result_type, uint32_t r if (options.force_zero_initialized_variables && type_can_zero_initialize(type)) initializer = join(" = ", to_zero_initialized_expression(result_type)); - statement(flags_to_qualifiers_glsl(type, flags), variable_decl(type, to_name(result_id)), initializer, ";"); + statement(flags_to_qualifiers_glsl(type, result_id, flags), variable_decl(type, to_name(result_id)), initializer, ";"); } } @@ -6757,7 +6913,7 @@ string CompilerGLSL::declare_temporary(uint32_t result_type, uint32_t result_id) // The result_id has not been made into an expression yet, so use flags interface. add_local_variable_name(result_id); auto &flags = get_decoration_bitset(result_id); - return join(flags_to_qualifiers_glsl(type, flags), variable_decl(type, to_name(result_id)), " = "); + return join(flags_to_qualifiers_glsl(type, result_id, flags), variable_decl(type, to_name(result_id)), " = "); } } @@ -6830,7 +6986,7 @@ void CompilerGLSL::emit_binary_op(uint32_t result_type, uint32_t result_id, uint { // Various FP arithmetic opcodes such as add, sub, mul will hit this. bool force_temporary_precise = backend.support_precise_qualifier && - has_decoration(result_id, DecorationNoContraction) && + has_legacy_nocontract(result_type, result_id) && type_is_floating_point(get(result_type)); bool forward = should_forward(op0) && should_forward(op1) && !force_temporary_precise; @@ -9795,6 +9951,22 @@ string CompilerGLSL::bitcast_glsl_op(const SPIRType &out_type, const SPIRType &i return "bfloat16BitsToUintEXT"; else if (out_type.basetype == SPIRType::Short && in_type.basetype == SPIRType::BFloat16) return "bfloat16BitsToIntEXT"; + else if (out_type.basetype == SPIRType::FloatE4M3 && in_type.basetype == SPIRType::UByte) + return "uintBitsToFloate4m3EXT"; + else if (out_type.basetype == SPIRType::FloatE4M3 && in_type.basetype == SPIRType::SByte) + return "intBitsToFloate4m3EXT"; + else if (out_type.basetype == SPIRType::UByte && in_type.basetype == SPIRType::FloatE4M3) + return "floate4m3BitsToUintEXT"; + else if (out_type.basetype == SPIRType::SByte && in_type.basetype == SPIRType::FloatE4M3) + return "floate4m3BitsToIntEXT"; + else if (out_type.basetype == SPIRType::FloatE5M2 && in_type.basetype == SPIRType::UByte) + return "uintBitsToFloate5m2EXT"; + else if (out_type.basetype == SPIRType::FloatE5M2 && in_type.basetype == SPIRType::SByte) + return "intBitsToFloate5m2EXT"; + else if (out_type.basetype == SPIRType::UByte && in_type.basetype == SPIRType::FloatE5M2) + return "floate5m2BitsToUintEXT"; + else if (out_type.basetype == SPIRType::SByte && in_type.basetype == SPIRType::FloatE5M2) + return "floate5m2BitsToIntEXT"; return ""; } @@ -10198,6 +10370,14 @@ string CompilerGLSL::builtin_to_glsl(BuiltIn builtin, StorageClass storage) case BuiltInCullPrimitiveEXT: return "gl_CullPrimitiveEXT"; + case BuiltInClusterIDNV: + { + if (!options.vulkan_semantics) + SPIRV_CROSS_THROW("Can only use ClusterIDNV in Vulkan GLSL."); + require_extension_internal("GL_NV_cluster_acceleration_structure"); + return "gl_ClusterIDNV"; + } + default: return join("gl_BuiltIn_", convert_to_string(builtin)); } @@ -10441,8 +10621,8 @@ string CompilerGLSL::access_chain_internal(uint32_t base, const uint32_t *indice if (ptr_chain_array_entry) expr = join("(", expr, ")"); } - // Arrays - else if (!type->array.empty()) + // Arrays and OpTypeCooperativeVectorNV (aka fancy arrays) + else if (!type->array.empty() || type->op == spv::OpTypeCooperativeVectorNV) { // If we are flattening multidimensional arrays, only create opening bracket on first // array index. @@ -11547,7 +11727,7 @@ void CompilerGLSL::emit_variable_temporary_copies(const SPIRVariable &var) { auto &type = get(var.basetype); auto &flags = get_decoration_bitset(var.self); - statement(flags_to_qualifiers_glsl(type, flags), variable_decl(type, join("_", var.self, "_copy")), ";"); + statement(flags_to_qualifiers_glsl(type, var.self, flags), variable_decl(type, join("_", var.self, "_copy")), ";"); flushed_phi_variables.insert(var.self); } } @@ -13761,13 +13941,42 @@ void CompilerGLSL::emit_instruction(const Instruction &instruction) break; } + case OpCooperativeMatrixConvertNV: + if (!options.vulkan_semantics) + SPIRV_CROSS_THROW("CooperativeMatrixConvertNV requires vulkan semantics."); + require_extension_internal("GL_NV_cooperative_matrix2"); + // fallthrough case OpFConvert: { uint32_t result_type = ops[0]; uint32_t id = ops[1]; - auto func = type_to_glsl_constructor(get(result_type)); - emit_unary_func_op(result_type, id, ops[2], func.c_str()); + auto &type = get(result_type); + + if (type.op == OpTypeCooperativeMatrixKHR && opcode == OpFConvert) + { + auto &expr_type = expression_type(ops[2]); + if (get(type.ext.cooperative.use_id).scalar() != + get(expr_type.ext.cooperative.use_id).scalar()) + { + // Somewhat questionable with spec constant uses. + if (!options.vulkan_semantics) + SPIRV_CROSS_THROW("NV_cooperative_matrix2 requires vulkan semantics."); + require_extension_internal("GL_NV_cooperative_matrix2"); + } + } + + if ((type.basetype == SPIRType::FloatE4M3 || type.basetype == SPIRType::FloatE5M2) && + has_decoration(id, spv::DecorationSaturatedToLargestFloat8NormalConversionEXT)) + { + emit_uninitialized_temporary_expression(result_type, id); + statement("saturatedConvertEXT(", to_expression(id), ", ", to_unpacked_expression(ops[2]), ");"); + } + else + { + auto func = type_to_glsl_constructor(type); + emit_unary_func_op(result_type, id, ops[2], func.c_str()); + } break; } @@ -14913,8 +15122,11 @@ void CompilerGLSL::emit_instruction(const Instruction &instruction) { emit_spv_amd_gcn_shader_op(ops[0], ops[1], ops[3], &ops[4], length - 4); } + else if (ext == SPIRExtension::NonSemanticShaderDebugInfo) + { + emit_non_semantic_shader_debug_info(ops[0], ops[1], ops[3], &ops[4], length - 4); + } else if (ext == SPIRExtension::SPV_debug_info || - ext == SPIRExtension::NonSemanticShaderDebugInfo || ext == SPIRExtension::NonSemanticGeneric) { break; // Ignore SPIR-V debug information extended instructions. @@ -15319,7 +15531,81 @@ void CompilerGLSL::emit_instruction(const Instruction &instruction) GLSL_RAY_QUERY_GET_OP2(IntersectionWorldToObject); #undef GLSL_RAY_QUERY_GET_OP #undef GLSL_RAY_QUERY_GET_OP2 + case OpRayQueryGetClusterIdNV: + flush_variable_declaration(ops[2]); + emit_op(ops[0], ops[1], join("rayQueryGetIntersectionClusterIdNV(", to_expression(ops[2]), ", ", "bool(", to_expression(ops[3]), "))"), false); + break; + case OpTensorQuerySizeARM: + flush_variable_declaration(ops[1]); + // tensorSizeARM(tensor, dimension) + emit_binary_func_op(ops[0], ops[1], ops[2], ops[3], "tensorSizeARM"); + break; + case OpTensorReadARM: + { + flush_variable_declaration(ops[1]); + emit_uninitialized_temporary_expression(ops[0], ops[1]); + SmallVector args { + to_expression(ops[2]), // tensor + to_expression(ops[3]), // coordinates + to_expression(ops[1]), // out value + }; + if (length > 4) + { + std::string tensor_operands; + if (ops[4] == 0) + tensor_operands = "0x0u"; + else if (ops[4] == spv::TensorOperandsNontemporalARMMask) + tensor_operands = "gl_TensorOperandsNonTemporalARM"; + else if (ops[4] == spv::TensorOperandsOutOfBoundsValueARMMask) + tensor_operands = "gl_TensorOperandsOutOfBoundsValueARM"; + else if (ops[4] == (spv::TensorOperandsNontemporalARMMask | spv::TensorOperandsOutOfBoundsValueARMMask)) + tensor_operands = "gl_TensorOperandsNonTemporalARM | gl_TensorOperandsOutOfBoundsValueARM"; + else + SPIRV_CROSS_THROW("Invalid tensorOperands for tensorReadARM."); + if ((ops[4] & spv::TensorOperandsOutOfBoundsValueARMMask) && length != 6) + SPIRV_CROSS_THROW("gl_TensorOperandsOutOfBoundsValueARM requires an outOfBoundsValue argument."); + args.push_back(tensor_operands); // tensorOperands + } + if (length >= 6) + { + if ((length > 6) || (ops[4] & spv::TensorOperandsOutOfBoundsValueARMMask) == 0) + SPIRV_CROSS_THROW("Too many arguments to tensorReadARM."); + args.push_back(to_expression(ops[5])); // outOfBoundsValue + } + + // tensorRead(tensor, sizeof(type), coordinates, value, operand, ...) + statement("tensorReadARM(", merge(args), ");"); + break; + } + case OpTensorWriteARM: + { + flush_variable_declaration(ops[0]); + + SmallVector args { + to_expression(ops[0]), // tensor + to_expression(ops[1]), // coordinates + to_expression(ops[2]), // out value + }; + + if (length > 3) + { + std::string tensor_operands; + if (ops[3] == 0) + tensor_operands = "0x0u"; + else if (ops[3] == spv::TensorOperandsNontemporalARMMask) + tensor_operands = "gl_TensorOperandsNonTemporalARM"; + else + SPIRV_CROSS_THROW("Invalid tensorOperands for tensorWriteARM."); + args.push_back(tensor_operands); // tensorOperands + } + if (length > 4) + SPIRV_CROSS_THROW("Too many arguments to tensorWriteARM."); + + // tensorWrite(tensor, sizeof(type), coordinates, value) + statement("tensorWriteARM(", merge(args), ");"); + break; + } case OpConvertUToAccelerationStructureKHR: { require_extension_internal("GL_EXT_ray_tracing"); @@ -15465,6 +15751,104 @@ void CompilerGLSL::emit_instruction(const Instruction &instruction) break; } + case OpCooperativeVectorLoadNV: + { + uint32_t result_type = ops[0]; + uint32_t id = ops[1]; + + emit_uninitialized_temporary_expression(result_type, id); + + statement("coopVecLoadNV(", to_expression(id), ", ", to_expression(ops[2]), ", ", to_expression(ops[3]), ");"); + register_read(id, ops[2], false); + break; + } + + case OpCooperativeVectorStoreNV: + { + uint32_t id = ops[0]; + + statement("coopVecStoreNV(", to_expression(ops[2]), ", ", to_expression(id), ", ", to_expression(ops[1]), ");"); + register_write(ops[2]); + break; + } + + case OpCooperativeVectorOuterProductAccumulateNV: + { + auto buf = ops[0]; + auto offset = ops[1]; + auto v1 = ops[2]; + auto v2 = ops[3]; + auto matrix_layout_id = ops[4]; + auto matrix_iterpretation_id = ops[5]; + auto matrix_stride_id = length >= 6 ? ops[6] : 0; + statement(join("coopVecOuterProductAccumulateNV(", to_expression(v1), ", ", to_expression(v2), ", ", + to_expression(buf), ", ", to_expression(offset), ", ", + matrix_stride_id ? to_expression(matrix_stride_id) : "0", + ", ", to_pretty_expression_if_int_constant( + matrix_layout_id, std::begin(CoopVecMatrixLayoutNames), std::end(CoopVecMatrixLayoutNames)), + ", ", to_pretty_expression_if_int_constant( + matrix_iterpretation_id, std::begin(CoopVecComponentTypeNames), std::end(CoopVecComponentTypeNames)), + ");")); + register_write(ops[0]); + break; + } + + case OpCooperativeVectorReduceSumAccumulateNV: + { + auto buf = ops[0]; + auto offset = ops[1]; + auto v1 = ops[2]; + statement(join("coopVecReduceSumAccumulateNV(", to_expression(v1), ", ", to_expression(buf), ", ", + to_expression(offset), ");")); + register_write(ops[0]); + break; + } + + case OpCooperativeVectorMatrixMulNV: + case OpCooperativeVectorMatrixMulAddNV: + { + uint32_t result_type = ops[0]; + uint32_t id = ops[1]; + + emit_uninitialized_temporary_expression(result_type, id); + + std::string stmt; + switch (opcode) + { + case OpCooperativeVectorMatrixMulAddNV: + stmt += "coopVecMatMulAddNV("; + break; + case OpCooperativeVectorMatrixMulNV: + stmt += "coopVecMatMulNV("; + break; + default: + SPIRV_CROSS_THROW("Invalid op code for coopvec instruction."); + } + for (uint32_t i = 1; i < length; i++) + { + // arguments 3, 6 and in case of MulAddNv also 9 use component type int constants + if (i == 3 || i == 6 || (i == 9 && opcode == OpCooperativeVectorMatrixMulAddNV)) + { + stmt += to_pretty_expression_if_int_constant( + ops[i], std::begin(CoopVecComponentTypeNames), std::end(CoopVecComponentTypeNames)); + } + else if ((i == 12 && opcode == OpCooperativeVectorMatrixMulAddNV) || + (i == 9 && opcode == OpCooperativeVectorMatrixMulNV)) + { + stmt += to_pretty_expression_if_int_constant( + ops[i], std::begin(CoopVecMatrixLayoutNames), std::end(CoopVecMatrixLayoutNames)); + } + else + stmt += to_expression(ops[i]); + + if (i < length - 1) + stmt += ", "; + } + stmt += ");"; + statement(stmt); + break; + } + case OpCooperativeMatrixLengthKHR: { // Need to synthesize a dummy temporary, since the SPIR-V opcode is based on the type. @@ -15492,27 +15876,10 @@ void CompilerGLSL::emit_instruction(const Instruction &instruction) if (!is_forcing_recompilation()) split_expr = split_coopmat_pointer(expr); - string layout_expr; - if (const auto *layout = maybe_get(ops[3])) - { - if (!layout->specialization) - { - if (layout->scalar() == spv::CooperativeMatrixLayoutColumnMajorKHR) - layout_expr = "gl_CooperativeMatrixLayoutColumnMajor"; - else - layout_expr = "gl_CooperativeMatrixLayoutRowMajor"; - } - } - - if (layout_expr.empty()) - layout_expr = join("int(", to_expression(ops[3]), ")"); - - statement("coopMatLoad(", - to_expression(id), ", ", - split_expr.first, ", ", - split_expr.second, ", ", - to_expression(ops[4]), ", ", - layout_expr, ");"); + string layout_expr = to_pretty_expression_if_int_constant( + ops[3], std::begin(CoopMatMatrixLayoutNames), std::end(CoopMatMatrixLayoutNames)); + statement("coopMatLoad(", to_expression(id), ", ", split_expr.first, ", ", split_expr.second, ", ", + to_expression(ops[4]), ", ", layout_expr, ");"); register_read(id, ops[2], false); break; @@ -15532,27 +15899,11 @@ void CompilerGLSL::emit_instruction(const Instruction &instruction) if (!is_forcing_recompilation()) split_expr = split_coopmat_pointer(expr); - string layout_expr; - if (const auto *layout = maybe_get(ops[2])) - { - if (!layout->specialization) - { - if (layout->scalar() == spv::CooperativeMatrixLayoutColumnMajorKHR) - layout_expr = "gl_CooperativeMatrixLayoutColumnMajor"; - else - layout_expr = "gl_CooperativeMatrixLayoutRowMajor"; - } - } - - if (layout_expr.empty()) - layout_expr = join("int(", to_expression(ops[2]), ")"); + string layout_expr = to_pretty_expression_if_int_constant( + ops[2], std::begin(CoopMatMatrixLayoutNames), std::end(CoopMatMatrixLayoutNames)); - statement("coopMatStore(", - to_expression(ops[1]), ", ", - split_expr.first, ", ", - split_expr.second, ", ", - to_expression(ops[3]), ", ", - layout_expr, ");"); + statement("coopMatStore(", to_expression(ops[1]), ", ", split_expr.first, ", ", split_expr.second, ", ", + to_expression(ops[3]), ", ", layout_expr, ");"); // TODO: Do we care about memory operands? @@ -15583,6 +15934,51 @@ void CompilerGLSL::emit_instruction(const Instruction &instruction) break; } + case OpCompositeConstructReplicateEXT: + { + uint32_t result_type = ops[0]; + uint32_t id = ops[1]; + + auto &type = get(result_type); + auto value_to_replicate = to_expression(ops[2]); + std::string rhs; + // Matrices don't have a replicating constructor for vectors. Need to manually replicate + if (type.op == spv::OpTypeMatrix || type.op == spv::OpTypeArray) + { + if (type.op == spv::OpTypeArray && type.array.size() != 1) + { + SPIRV_CROSS_THROW( + "Multi-dimensional arrays currently not supported for OpCompositeConstructReplicateEXT"); + } + uint32_t num_elements = type.op == spv::OpTypeMatrix ? type.columns : type.array[0]; + if (backend.use_initializer_list && type.op == spv::OpTypeArray) + { + rhs += "{"; + } + else + { + rhs += type_to_glsl_constructor(type); + rhs += "("; + } + for (uint32_t i = 0; i < num_elements; i++) + { + rhs += value_to_replicate; + if (i < num_elements - 1) + rhs += ", "; + } + if (backend.use_initializer_list && type.op == spv::OpTypeArray) + rhs += "}"; + else + rhs += ")"; + } + else + { + rhs = join(type_to_glsl(type), "(", to_expression(ops[2]), ")"); + } + emit_op(result_type, id, rhs, true); + break; + } + default: statement("// unimplemented op ", instruction.op); break; @@ -15800,7 +16196,7 @@ void CompilerGLSL::emit_struct_member(const SPIRType &type, uint32_t member_type if (is_block) qualifiers = to_interpolation_qualifiers(memberflags); - statement(layout_for_member(type, index), qualifiers, qualifier, flags_to_qualifiers_glsl(membertype, memberflags), + statement(layout_for_member(type, index), qualifiers, qualifier, flags_to_qualifiers_glsl(membertype, 0, memberflags), variable_decl(membertype, to_member_name(type, index)), ";"); } @@ -15808,7 +16204,7 @@ void CompilerGLSL::emit_struct_padding_target(const SPIRType &) { } -string CompilerGLSL::flags_to_qualifiers_glsl(const SPIRType &type, const Bitset &flags) +string CompilerGLSL::flags_to_qualifiers_glsl(const SPIRType &type, uint32_t id, const Bitset &flags) { // GL_EXT_buffer_reference variables can be marked as restrict. if (flags.get(DecorationRestrictPointerEXT)) @@ -15816,8 +16212,12 @@ string CompilerGLSL::flags_to_qualifiers_glsl(const SPIRType &type, const Bitset string qual; - if (type_is_floating_point(type) && flags.get(DecorationNoContraction) && backend.support_precise_qualifier) + if (type_is_floating_point(type) && + (flags.get(DecorationNoContraction) || (type.self && has_legacy_nocontract(type.self, id))) && + backend.support_precise_qualifier) + { qual = "precise "; + } // Structs do not have precision qualifiers, neither do doubles (desktop only anyways, so no mediump/highp). bool type_supports_precision = @@ -15886,7 +16286,7 @@ string CompilerGLSL::to_precision_qualifiers_glsl(uint32_t id) if (result_type.width < 32) return "mediump "; } - return flags_to_qualifiers_glsl(type, ir.meta[id].decoration.decoration_flags); + return flags_to_qualifiers_glsl(type, id, ir.meta[id].decoration.decoration_flags); } void CompilerGLSL::fixup_io_block_patch_primitive_qualifiers(const SPIRVariable &var) @@ -15969,6 +16369,13 @@ string CompilerGLSL::to_qualifiers_glsl(uint32_t id) SPIRV_CROSS_THROW("Cannot use GL_EXT_shader_image_load_formatted in ESSL."); } } + else if (type.basetype == SPIRType::Tensor) + { + if (flags.get(DecorationNonWritable)) + res += "readonly "; + if (flags.get(DecorationNonReadable)) + res += "writeonly "; + } res += to_precision_qualifiers_glsl(id); @@ -16403,6 +16810,14 @@ string CompilerGLSL::type_to_glsl(const SPIRType &type, uint32_t id) case SPIRType::RayQuery: return "rayQueryEXT"; + case SPIRType::Tensor: + if (type.ext.tensor.rank == 0) + SPIRV_CROSS_THROW("GLSL tensors must have a Rank."); + if (type.ext.tensor.shape != 0) + SPIRV_CROSS_THROW("GLSL tensors cannot have a Shape."); + return join("tensorARM<", type_to_glsl(get(type.ext.tensor.type)), ", ", + to_expression(type.ext.tensor.rank), ">"); + case SPIRType::Void: return "void"; @@ -16430,6 +16845,17 @@ string CompilerGLSL::type_to_glsl(const SPIRType &type, uint32_t id) require_extension_internal("GL_ARB_shader_atomic_counters"); } + if (type.op == spv::OpTypeCooperativeVectorNV) + { + require_extension_internal("GL_NV_cooperative_vector"); + if (!options.vulkan_semantics) + SPIRV_CROSS_THROW("Cooperative vector NV only available in Vulkan."); + + std::string component_type_str = type_to_glsl(get(type.ext.coopVecNV.component_type_id)); + + return join("coopvecNV<", component_type_str, ", ", to_expression(type.ext.coopVecNV.component_count_id), ">"); + } + const SPIRType *coop_type = &type; while (is_pointer(*coop_type) || is_array(*coop_type)) coop_type = &get(coop_type->parent_type); @@ -16440,7 +16866,7 @@ string CompilerGLSL::type_to_glsl(const SPIRType &type, uint32_t id) if (!options.vulkan_semantics) SPIRV_CROSS_THROW("Cooperative matrix only available in Vulkan."); // GLSL doesn't support this as spec constant, which makes sense ... - uint32_t use_type = get(coop_type->cooperative.use_id).scalar(); + uint32_t use_type = get(coop_type->ext.cooperative.use_id).scalar(); const char *use = nullptr; switch (use_type) @@ -16462,7 +16888,7 @@ string CompilerGLSL::type_to_glsl(const SPIRType &type, uint32_t id) } string scope_expr; - if (const auto *scope = maybe_get(coop_type->cooperative.scope_id)) + if (const auto *scope = maybe_get(coop_type->ext.cooperative.scope_id)) { if (!scope->specialization) { @@ -16477,12 +16903,12 @@ string CompilerGLSL::type_to_glsl(const SPIRType &type, uint32_t id) } if (scope_expr.empty()) - scope_expr = to_expression(coop_type->cooperative.scope_id); + scope_expr = to_expression(coop_type->ext.cooperative.scope_id); return join("coopmat<", type_to_glsl(get(coop_type->parent_type)), ", ", scope_expr, ", ", - to_expression(coop_type->cooperative.rows_id), ", ", - to_expression(coop_type->cooperative.columns_id), ", ", use, ">"); + to_expression(coop_type->ext.cooperative.rows_id), ", ", + to_expression(coop_type->ext.cooperative.columns_id), ", ", use, ">"); } if (type.vecsize == 1 && type.columns == 1) // Scalar builtin @@ -16512,6 +16938,16 @@ string CompilerGLSL::type_to_glsl(const SPIRType &type, uint32_t id) SPIRV_CROSS_THROW("bfloat16 requires Vulkan semantics."); require_extension_internal("GL_EXT_bfloat16"); return "bfloat16_t"; + case SPIRType::FloatE4M3: + if (!options.vulkan_semantics) + SPIRV_CROSS_THROW("floate4m3_t requires Vulkan semantics."); + require_extension_internal("GL_EXT_float_e4m3"); + return "floate4m3_t"; + case SPIRType::FloatE5M2: + if (!options.vulkan_semantics) + SPIRV_CROSS_THROW("floate5m2_t requires Vulkan semantics."); + require_extension_internal("GL_EXT_float_e5m2"); + return "floate5m2_t"; case SPIRType::Float: return "float"; case SPIRType::Double: @@ -16549,6 +16985,16 @@ string CompilerGLSL::type_to_glsl(const SPIRType &type, uint32_t id) SPIRV_CROSS_THROW("bfloat16 requires Vulkan semantics."); require_extension_internal("GL_EXT_bfloat16"); return join("bf16vec", type.vecsize); + case SPIRType::FloatE4M3: + if (!options.vulkan_semantics) + SPIRV_CROSS_THROW("floate4m3_t requires Vulkan semantics."); + require_extension_internal("GL_EXT_float_e4m3"); + return join("fe4m3vec", type.vecsize); + case SPIRType::FloatE5M2: + if (!options.vulkan_semantics) + SPIRV_CROSS_THROW("floate5m2_t requires Vulkan semantics."); + require_extension_internal("GL_EXT_float_e5m2"); + return join("fe5m2vec", type.vecsize); case SPIRType::Float: return join("vec", type.vecsize); case SPIRType::Double: @@ -16785,7 +17231,7 @@ void CompilerGLSL::emit_function_prototype(SPIRFunction &func, const Bitset &ret string decl; auto &type = get(func.return_type); - decl += flags_to_qualifiers_glsl(type, return_flags); + decl += flags_to_qualifiers_glsl(type, 0, return_flags); decl += type_to_glsl(type); decl += type_to_array_glsl(type, 0); decl += " "; @@ -17643,7 +18089,7 @@ void CompilerGLSL::emit_hoisted_temporaries(SmallVector> &tempo if (options.force_zero_initialized_variables && type_can_zero_initialize(type)) initializer = join(" = ", to_zero_initialized_expression(tmp.first)); - statement(flags_to_qualifiers_glsl(type, flags), variable_decl(type, to_name(tmp.second)), initializer, ";"); + statement(flags_to_qualifiers_glsl(type, tmp.second, flags), variable_decl(type, to_name(tmp.second)), initializer, ";"); hoisted_temporaries.insert(tmp.second); forced_temporaries.insert(tmp.second); @@ -17658,7 +18104,7 @@ void CompilerGLSL::emit_hoisted_temporaries(SmallVector> &tempo { uint32_t mirror_id = mirrored_precision_itr->second; auto &mirror_flags = get_decoration_bitset(mirror_id); - statement(flags_to_qualifiers_glsl(type, mirror_flags), + statement(flags_to_qualifiers_glsl(type, mirror_id, mirror_flags), variable_decl(type, to_name(mirror_id)), initializer, ";"); // The temporary might be read from before it's assigned, set up the expression now. @@ -17669,6 +18115,26 @@ void CompilerGLSL::emit_hoisted_temporaries(SmallVector> &tempo } void CompilerGLSL::emit_block_chain(SPIRBlock &block) +{ + SmallVector cleanup_stack; + BlockID next_block = emit_block_chain_inner(block); + + while (next_block != 0) + { + cleanup_stack.push_back(next_block); + next_block = emit_block_chain_inner(get(next_block)); + } + + while (!cleanup_stack.empty()) + { + emit_block_chain_cleanup(get(cleanup_stack.back())); + cleanup_stack.pop_back(); + } + + emit_block_chain_cleanup(block); +} + +BlockID CompilerGLSL::emit_block_chain_inner(SPIRBlock &block) { bool select_branch_to_true_block = false; bool select_branch_to_false_block = false; @@ -17719,12 +18185,13 @@ void CompilerGLSL::emit_block_chain(SPIRBlock &block) } // Remember deferred declaration state. We will restore it before returning. - SmallVector rearm_dominated_variables(block.dominated_variables.size()); + assert(block.rearm_dominated_variables.empty()); + block.rearm_dominated_variables.resize(block.dominated_variables.size()); for (size_t i = 0; i < block.dominated_variables.size(); i++) { uint32_t var_id = block.dominated_variables[i]; auto &var = get(var_id); - rearm_dominated_variables[i] = var.deferred_declaration; + block.rearm_dominated_variables[i] = var.deferred_declaration; } // This is the method often used by spirv-opt to implement loops. @@ -18317,6 +18784,8 @@ void CompilerGLSL::emit_block_chain(SPIRBlock &block) SPIRV_CROSS_THROW("Unimplemented block terminator."); } + BlockID trailing_block_id = 0; + if (block.next_block && emit_next_block) { // If we hit this case, we're dealing with an unconditional branch, which means we will output @@ -18324,8 +18793,10 @@ void CompilerGLSL::emit_block_chain(SPIRBlock &block) if (block.merge != SPIRBlock::MergeSelection) { flush_phi(block.self, block.next_block); + // For a direct branch, need to remember to invalidate expressions in the next linear block instead. - get(block.next_block).invalidate_expressions = block.invalidate_expressions; + get(block.next_block).invalidate_expressions.clear(); + std::swap(get(block.next_block).invalidate_expressions, block.invalidate_expressions); } // For switch fallthrough cases, we terminate the chain here, but we still need to handle Phi. @@ -18346,7 +18817,15 @@ void CompilerGLSL::emit_block_chain(SPIRBlock &block) branch_to_continue(block.self, block.next_block); } else if (BlockID(block.self) != block.next_block) - emit_block_chain(get(block.next_block)); + { + // Recursing here is quite scary since it's quite easy to stack overflow if + // the SPIR-V is constructed a particular way. + // We have to simulate the tail call ourselves. + if (block.merge != SPIRBlock::MergeLoop) + trailing_block_id = block.next_block; + else + emit_block_chain(get(block.next_block)); + } } } @@ -18388,20 +18867,28 @@ void CompilerGLSL::emit_block_chain(SPIRBlock &block) if (is_continue(block.merge_block)) branch_to_continue(block.self, block.merge_block); else - emit_block_chain(get(block.merge_block)); + trailing_block_id = block.merge_block; } + return trailing_block_id; +} + +void CompilerGLSL::emit_block_chain_cleanup(SPIRBlock &block) +{ // Forget about control dependent expressions now. block.invalidate_expressions.clear(); - // After we return, we must be out of scope, so if we somehow have to re-emit this function, + // After we return, we must be out of scope, so if we somehow have to re-emit this block, // re-declare variables if necessary. - assert(rearm_dominated_variables.size() == block.dominated_variables.size()); + // We only need one array here for rearm_dominated_variables, + // since it should be impossible for the same block to be remitted in the same chain twice. + assert(block.rearm_dominated_variables.size() == block.dominated_variables.size()); for (size_t i = 0; i < block.dominated_variables.size(); i++) { uint32_t var = block.dominated_variables[i]; - get(var).deferred_declaration = rearm_dominated_variables[i]; + get(var).deferred_declaration = block.rearm_dominated_variables[i]; } + block.rearm_dominated_variables.clear(); // Just like for deferred declaration, we need to forget about loop variable enable // if our block chain is reinstantiated later. @@ -18943,6 +19430,34 @@ void CompilerGLSL::emit_line_directive(uint32_t file_id, uint32_t line_literal) } } +void CompilerGLSL::emit_non_semantic_shader_debug_info(uint32_t, uint32_t result_id, uint32_t eop, + const uint32_t *args, uint32_t) +{ + if (!options.emit_line_directives) + return; + + switch (eop) + { + case SPIRExtension::DebugLine: + { + // We're missing line end and columns here, but I don't think we can emit those in any meaningful way. + emit_line_directive(args[0], get(args[1]).scalar()); + break; + } + + case SPIRExtension::DebugSource: + { + // Forward the string declaration here. We ignore the optional text operand. + auto &str = get(args[0]).str; + set(result_id, str); + break; + } + + default: + break; + } +} + void CompilerGLSL::emit_copy_logical_type(uint32_t lhs_id, uint32_t lhs_type_id, uint32_t rhs_id, uint32_t rhs_type_id, SmallVector chain) { @@ -19582,3 +20097,96 @@ std::string CompilerGLSL::format_double(double value) const return convert_to_string(value, current_locale_radix_character); } +std::string CompilerGLSL::to_pretty_expression_if_int_constant( + uint32_t id, + const GlslConstantNameMapping *mapping_start, const GlslConstantNameMapping *mapping_end, + bool register_expression_read) +{ + auto *c = maybe_get(id); + if (c && !c->specialization) + { + auto value = c->scalar(); + auto pretty_name = std::find_if(mapping_start, mapping_end, + [value](const GlslConstantNameMapping &mapping) { return mapping.value == value; }); + if (pretty_name != mapping_end) + return pretty_name->alias; + } + return join("int(", to_expression(id, register_expression_read), ")"); +} + +uint32_t CompilerGLSL::get_fp_fast_math_flags_for_op(uint32_t result_type, uint32_t id) const +{ + uint32_t fp_flags = ~0; + + if (!type_is_floating_point(get(result_type))) + return fp_flags; + + auto &ep = get_entry_point(); + + // Per-operation flag supersedes all defaults. + if (id != 0 && has_decoration(id, DecorationFPFastMathMode)) + return get_decoration(id, DecorationFPFastMathMode); + + // Handle float_controls1 execution modes. + uint32_t width = get(result_type).width; + + bool szinp = false; + + switch (width) + { + case 8: + szinp = ep.signed_zero_inf_nan_preserve_8; + break; + + case 16: + szinp = ep.signed_zero_inf_nan_preserve_16; + break; + + case 32: + szinp = ep.signed_zero_inf_nan_preserve_32; + break; + + case 64: + szinp = ep.signed_zero_inf_nan_preserve_64; + break; + + default: + break; + } + + if (szinp) + fp_flags &= ~(FPFastMathModeNSZMask | FPFastMathModeNotInfMask | FPFastMathModeNotNaNMask); + + // Legacy NoContraction deals with any kind of transform to the expression. + if (id != 0 && has_decoration(id, DecorationNoContraction)) + fp_flags &= ~(FPFastMathModeAllowContractMask | FPFastMathModeAllowTransformMask | FPFastMathModeAllowReassocMask); + + // Handle float_controls2 execution modes. + bool found_default = false; + for (auto &fp_pair : ep.fp_fast_math_defaults) + { + if (get(fp_pair.first).width == width && fp_pair.second) + { + fp_flags &= get(fp_pair.second).scalar(); + found_default = true; + } + } + + // From SPV_KHR_float_controls2: + // "This definition implies that, if the entry point set any FPFastMathDefault execution mode + // then any type for which a default is not set uses no fast math flags + // (although this can still be overridden on a per-operation basis). + // Modules must not mix setting fast math modes explicitly using this extension and relying on older API defaults." + if (!found_default && !ep.fp_fast_math_defaults.empty()) + fp_flags = 0; + + return fp_flags; +} + +bool CompilerGLSL::has_legacy_nocontract(uint32_t result_type, uint32_t id) const +{ + const auto fp_flags = FPFastMathModeAllowContractMask | + FPFastMathModeAllowTransformMask | + FPFastMathModeAllowReassocMask; + return (get_fp_fast_math_flags_for_op(result_type, id) & fp_flags) != fp_flags; +} diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_glsl.hpp b/libs/bgfx/3rdparty/spirv-cross/spirv_glsl.hpp index cea150f..776ab8a 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_glsl.hpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_glsl.hpp @@ -32,6 +32,8 @@ namespace SPIRV_CROSS_NAMESPACE { +struct GlslConstantNameMapping; + enum PlsFormat { PlsNone = 0, @@ -426,6 +428,8 @@ class CompilerGLSL : public Compiler const uint32_t *args, uint32_t count); virtual void emit_spv_amd_gcn_shader_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args, uint32_t count); + void emit_non_semantic_shader_debug_info(uint32_t result_type, uint32_t result_id, uint32_t op, + const uint32_t *args, uint32_t count); virtual void emit_header(); void emit_line_directive(uint32_t file_id, uint32_t line_literal); void build_workgroup_size(SmallVector &arguments, const SpecializationConstant &x, @@ -662,6 +666,7 @@ class CompilerGLSL : public Compiler bool workgroup_size_is_hidden = false; bool requires_relaxed_precision_analysis = false; bool implicit_c_integer_promotion_rules = false; + bool supports_spec_constant_array_size = true; } backend; void emit_struct(SPIRType &type); @@ -685,6 +690,8 @@ class CompilerGLSL : public Compiler void emit_flattened_io_block_member(const std::string &basename, const SPIRType &type, const char *qual, const SmallVector &indices); void emit_block_chain(SPIRBlock &block); + BlockID emit_block_chain_inner(SPIRBlock &block); + void emit_block_chain_cleanup(SPIRBlock &block); void emit_hoisted_temporaries(SmallVector> &temporaries); int get_constant_mapping_to_workgroup_component(const SPIRConstant &constant) const; void emit_constant(const SPIRConstant &constant); @@ -802,6 +809,10 @@ class CompilerGLSL : public Compiler virtual void append_global_func_args(const SPIRFunction &func, uint32_t index, SmallVector &arglist); std::string to_non_uniform_aware_expression(uint32_t id); std::string to_atomic_ptr_expression(uint32_t id); + std::string to_pretty_expression_if_int_constant( + uint32_t id, + const GlslConstantNameMapping *mapping_start, const GlslConstantNameMapping *mapping_end, + bool register_expression_read = true); std::string to_expression(uint32_t id, bool register_expression_read = true); std::string to_composite_constructor_expression(const SPIRType &parent_type, uint32_t id, bool block_like_type); std::string to_rerolled_array_expression(const SPIRType &parent_type, const std::string &expr, const SPIRType &type); @@ -830,7 +841,7 @@ class CompilerGLSL : public Compiler void emit_output_variable_initializer(const SPIRVariable &var); std::string to_precision_qualifiers_glsl(uint32_t id); virtual const char *to_storage_qualifiers_glsl(const SPIRVariable &var); - std::string flags_to_qualifiers_glsl(const SPIRType &type, const Bitset &flags); + std::string flags_to_qualifiers_glsl(const SPIRType &type, uint32_t id, const Bitset &flags); const char *format_to_glsl(spv::ImageFormat format); virtual std::string layout_for_member(const SPIRType &type, uint32_t index); virtual std::string to_interpolation_qualifiers(const Bitset &flags); @@ -1017,6 +1028,8 @@ class CompilerGLSL : public Compiler const Instruction *get_next_instruction_in_block(const Instruction &instr); static uint32_t mask_relevant_memory_semantics(uint32_t semantics); + std::string convert_floate4m3_to_string(const SPIRConstant &value, uint32_t col, uint32_t row); + std::string convert_floate5m2_to_string(const SPIRConstant &value, uint32_t col, uint32_t row); std::string convert_half_to_string(const SPIRConstant &value, uint32_t col, uint32_t row); std::string convert_float_to_string(const SPIRConstant &value, uint32_t col, uint32_t row); std::string convert_double_to_string(const SPIRConstant &value, uint32_t col, uint32_t row); @@ -1068,6 +1081,9 @@ class CompilerGLSL : public Compiler std::string format_float(float value) const; std::string format_double(double value) const; + uint32_t get_fp_fast_math_flags_for_op(uint32_t result_type, uint32_t id) const; + bool has_legacy_nocontract(uint32_t result_type, uint32_t id) const; + private: void init(); diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_hlsl.cpp b/libs/bgfx/3rdparty/spirv-cross/spirv_hlsl.cpp index 1ec4cb7..0db81c4 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_hlsl.cpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_hlsl.cpp @@ -3029,7 +3029,7 @@ string CompilerHLSL::get_inner_entry_point_name() const SPIRV_CROSS_THROW("Unsupported execution model."); } -uint32_t CompilerHLSL::input_vertices_from_execution_mode(spirv_cross::SPIREntryPoint &execution) const +uint32_t CompilerHLSL::input_vertices_from_execution_mode(SPIREntryPoint &execution) const { uint32_t input_vertices = 1; @@ -3061,7 +3061,7 @@ void CompilerHLSL::emit_function_prototype(SPIRFunction &func, const Bitset &ret auto &type = get(func.return_type); if (type.array.empty()) { - decl += flags_to_qualifiers_glsl(type, return_flags); + decl += flags_to_qualifiers_glsl(type, 0, return_flags); decl += type_to_glsl(type); decl += " "; } diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_msl.cpp b/libs/bgfx/3rdparty/spirv-cross/spirv_msl.cpp index 53f74f1..f604314 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_msl.cpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_msl.cpp @@ -510,7 +510,7 @@ void CompilerMSL::build_implicit_builtins() has_local_invocation_index = true; } - if (need_workgroup_size && builtin == BuiltInLocalInvocationId) + if (need_workgroup_size && builtin == BuiltInWorkgroupSize) { builtin_workgroup_size_id = var.self; mark_implicit_builtin(StorageClassInput, BuiltInWorkgroupSize, var.self); @@ -684,28 +684,6 @@ void CompilerMSL::build_implicit_builtins() mark_implicit_builtin(StorageClassInput, BuiltInBaseInstance, var_id); } - if (need_multiview) - { - // Multiview shaders are not allowed to write to gl_Layer, ostensibly because - // it is implicitly written from gl_ViewIndex, but we have to do that explicitly. - // Note that we can't just abuse gl_ViewIndex for this purpose: it's an input, but - // gl_Layer is an output in vertex-pipeline shaders. - uint32_t type_ptr_out_id = ir.increase_bound_by(2); - SPIRType uint_type_ptr_out = get_uint_type(); - uint_type_ptr.op = OpTypePointer; - uint_type_ptr_out.pointer = true; - uint_type_ptr_out.pointer_depth++; - uint_type_ptr_out.parent_type = get_uint_type_id(); - uint_type_ptr_out.storage = StorageClassOutput; - auto &ptr_out_type = set(type_ptr_out_id, uint_type_ptr_out); - ptr_out_type.self = get_uint_type_id(); - uint32_t var_id = type_ptr_out_id + 1; - set(var_id, type_ptr_out_id, StorageClassOutput); - set_decoration(var_id, DecorationBuiltIn, BuiltInLayer); - builtin_layer_id = var_id; - mark_implicit_builtin(StorageClassOutput, BuiltInLayer, var_id); - } - if (need_multiview && !has_view_idx) { uint32_t var_id = ir.increase_bound_by(1); @@ -718,6 +696,28 @@ void CompilerMSL::build_implicit_builtins() } } + if (need_multiview) + { + // Multiview shaders are not allowed to write to gl_Layer, ostensibly because + // it is implicitly written from gl_ViewIndex, but we have to do that explicitly. + // Note that we can't just abuse gl_ViewIndex for this purpose: it's an input, but + // gl_Layer is an output in vertex-pipeline shaders. + uint32_t type_ptr_out_id = ir.increase_bound_by(2); + SPIRType uint_type_ptr_out = get_uint_type(); + uint_type_ptr_out.op = OpTypePointer; + uint_type_ptr_out.pointer = true; + uint_type_ptr_out.pointer_depth++; + uint_type_ptr_out.parent_type = get_uint_type_id(); + uint_type_ptr_out.storage = StorageClassOutput; + auto &ptr_out_type = set(type_ptr_out_id, uint_type_ptr_out); + ptr_out_type.self = get_uint_type_id(); + uint32_t var_id = type_ptr_out_id + 1; + set(var_id, type_ptr_out_id, StorageClassOutput); + set_decoration(var_id, DecorationBuiltIn, BuiltInLayer); + builtin_layer_id = var_id; + mark_implicit_builtin(StorageClassOutput, BuiltInLayer, var_id); + } + if ((need_tesc_params && (msl_options.multi_patch_workgroup || !has_invocation_id || !has_primitive_id)) || (need_tese_params && !has_primitive_id) || need_grid_params) { @@ -932,25 +932,55 @@ void CompilerMSL::build_implicit_builtins() if (need_workgroup_size && !has_workgroup_size) { - uint32_t offset = ir.increase_bound_by(2); - uint32_t type_ptr_id = offset; - uint32_t var_id = offset + 1; - - // Create gl_WorkgroupSize. - uint32_t type_id = build_extended_vector_type(get_uint_type_id(), 3); - SPIRType uint_type_ptr = get(type_id); - uint_type_ptr.op = OpTypePointer; - uint_type_ptr.pointer = true; - uint_type_ptr.pointer_depth++; - uint_type_ptr.parent_type = type_id; - uint_type_ptr.storage = StorageClassInput; + auto &execution = get_entry_point(); + // First, check if the workgroup size _constant_ were defined. + // If it were, we don't need to do--in fact, shouldn't do--anything. + builtin_workgroup_size_id = execution.workgroup_size.constant; + if (builtin_workgroup_size_id == 0) + { + uint32_t var_id = ir.increase_bound_by(1); - auto &ptr_type = set(type_ptr_id, uint_type_ptr); - ptr_type.self = type_id; - set(var_id, type_ptr_id, StorageClassInput); - set_decoration(var_id, DecorationBuiltIn, BuiltInWorkgroupSize); - builtin_workgroup_size_id = var_id; - mark_implicit_builtin(StorageClassInput, BuiltInWorkgroupSize, var_id); + // Create gl_WorkgroupSize. + uint32_t type_id = build_extended_vector_type(get_uint_type_id(), 3); + // If we have LocalSize or LocalSizeId, use those to define the workgroup size. + if (execution.flags.get(ExecutionModeLocalSizeId)) + { + const SPIRConstant *init[] = { &get(execution.workgroup_size.id_x), + &get(execution.workgroup_size.id_y), + &get(execution.workgroup_size.id_z) }; + bool specialized = init[0]->specialization || init[1]->specialization || init[2]->specialization; + set(var_id, type_id, init, 3, specialized); + execution.workgroup_size.constant = var_id; + } + else if (execution.flags.get(ExecutionModeLocalSize)) + { + uint32_t offset = ir.increase_bound_by(3); + const SPIRConstant *init[] = { + &set(offset, get_uint_type_id(), execution.workgroup_size.x, false), + &set(offset + 1, get_uint_type_id(), execution.workgroup_size.y, false), + &set(offset + 2, get_uint_type_id(), execution.workgroup_size.z, false) + }; + set(var_id, type_id, init, 3, false); + execution.workgroup_size.constant = var_id; + } + else + { + uint32_t type_ptr_id = ir.increase_bound_by(1); + SPIRType uint_type_ptr = get(type_id); + uint_type_ptr.op = OpTypePointer; + uint_type_ptr.pointer = true; + uint_type_ptr.pointer_depth++; + uint_type_ptr.parent_type = type_id; + uint_type_ptr.storage = StorageClassInput; + + auto &ptr_type = set(type_ptr_id, uint_type_ptr); + ptr_type.self = type_id; + set(var_id, type_ptr_id, StorageClassInput); + mark_implicit_builtin(StorageClassInput, BuiltInWorkgroupSize, var_id); + } + set_decoration(var_id, DecorationBuiltIn, BuiltInWorkgroupSize); + builtin_workgroup_size_id = var_id; + } } if (!has_frag_depth && force_frag_depth_passthrough) @@ -1681,6 +1711,7 @@ string CompilerMSL::compile() backend.array_is_value_type_in_buffer_blocks = false; backend.support_pointer_to_pointer = true; backend.implicit_c_integer_promotion_rules = true; + backend.supports_spec_constant_array_size = false; capture_output_to_buffer = msl_options.capture_output_to_buffer; is_rasterization_disabled = msl_options.disable_rasterization || capture_output_to_buffer; @@ -1841,7 +1872,7 @@ void CompilerMSL::preprocess_op_codes() if (preproc.uses_atomics) { add_header_line("#include "); - add_pragma_line("#pragma clang diagnostic ignored \"-Wunused-variable\""); + add_pragma_line("#pragma clang diagnostic ignored \"-Wunused-variable\"", false); } // Before MSL 2.1 (2.2 for textures), Metal vertex functions that write to @@ -1850,6 +1881,10 @@ void CompilerMSL::preprocess_op_codes() (preproc.uses_image_write && !msl_options.supports_msl_version(2, 2))) is_rasterization_disabled = true; + // FIXME: This currently does not consider BDA side effects, so we cannot deduce const device for BDA. + if (preproc.uses_buffer_write || preproc.uses_image_write) + has_descriptor_side_effects = true; + // Tessellation control shaders are run as compute functions in Metal, and so // must capture their output to a buffer. if (is_tesc_shader() || (get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation)) @@ -5720,22 +5755,44 @@ void CompilerMSL::emit_header() { // This particular line can be overridden during compilation, so make it a flag and not a pragma line. if (suppress_missing_prototypes) - statement("#pragma clang diagnostic ignored \"-Wmissing-prototypes\""); + add_pragma_line("#pragma clang diagnostic ignored \"-Wmissing-prototypes\"", false); if (suppress_incompatible_pointer_types_discard_qualifiers) - statement("#pragma clang diagnostic ignored \"-Wincompatible-pointer-types-discards-qualifiers\""); + add_pragma_line("#pragma clang diagnostic ignored \"-Wincompatible-pointer-types-discards-qualifiers\"", false); // Disable warning about "sometimes unitialized" when zero-initializing simple threadgroup variables if (suppress_sometimes_unitialized) - statement("#pragma clang diagnostic ignored \"-Wsometimes-uninitialized\""); + add_pragma_line("#pragma clang diagnostic ignored \"-Wsometimes-uninitialized\"", false); // Disable warning about missing braces for array template to make arrays a value type if (spv_function_implementations.count(SPVFuncImplUnsafeArray) != 0) - statement("#pragma clang diagnostic ignored \"-Wmissing-braces\""); + add_pragma_line("#pragma clang diagnostic ignored \"-Wmissing-braces\"", false); + + // Floating point fast math compile declarations + if (msl_options.use_fast_math_pragmas && msl_options.supports_msl_version(3, 2)) + { + uint32_t contract_mask = FPFastMathModeAllowContractMask; + uint32_t relax_mask = (FPFastMathModeNSZMask | FPFastMathModeAllowRecipMask | FPFastMathModeAllowReassocMask); + uint32_t fast_mask = (relax_mask | FPFastMathModeNotNaNMask | FPFastMathModeNotInfMask); + + // FP math mode + uint32_t fp_flags = get_fp_fast_math_flags(true); + const char *math_mode = "safe"; + if ((fp_flags & fast_mask) == fast_mask) // Must have all flags + math_mode = "fast"; + else if ((fp_flags & relax_mask) == relax_mask) // Must have all flags + math_mode = "relaxed"; + + add_pragma_line(join("#pragma metal fp math_mode(", math_mode, ")"), false); + + // FP contraction + const char *contract_mode = ((fp_flags & contract_mask) == contract_mask) ? "fast" : "off"; + add_pragma_line(join("#pragma metal fp contract(", contract_mode, ")"), false); + } for (auto &pragma : pragma_lines) statement(pragma); - if (!pragma_lines.empty() || suppress_missing_prototypes) + if (!pragma_lines.empty()) statement(""); statement("#include "); @@ -5755,18 +5812,23 @@ void CompilerMSL::emit_header() statement(""); } -void CompilerMSL::add_pragma_line(const string &line) +void CompilerMSL::add_pragma_line(const string &line, bool recompile_on_unique) { - auto rslt = pragma_lines.insert(line); - if (rslt.second) - force_recompile(); + if (std::find(pragma_lines.begin(), pragma_lines.end(), line) == pragma_lines.end()) + { + pragma_lines.push_back(line); + if (recompile_on_unique) + force_recompile(); + } } void CompilerMSL::add_typedef_line(const string &line) { - auto rslt = typedef_lines.insert(line); - if (rslt.second) + if (std::find(typedef_lines.begin(), typedef_lines.end(), line) == typedef_lines.end()) + { + typedef_lines.push_back(line); force_recompile(); + } } // Template struct like spvUnsafeArray<> need to be declared *before* any resources are declared @@ -8353,9 +8415,22 @@ void CompilerMSL::emit_specialization_constants_and_structs() if (unique_func_constants[constant_id] == c.self) statement("constant ", sc_type_name, " ", sc_tmp_name, " [[function_constant(", constant_id, ")]];"); - statement("constant ", sc_type_name, " ", sc_name, " = is_function_constant_defined(", sc_tmp_name, - ") ? ", bitcast_expression(type, sc_tmp_type, sc_tmp_name), " : ", constant_expression(c), - ";"); + // RenderDoc and other instrumentation may reuse the same SpecId with different base types. + // We deduplicate to one [[function_constant(id)]] temp and then initialize all variants from it. + // Metal forbids as_type to/from 'bool', so if either side is Boolean, avoid bitcasting here and + // prefer a value cast via a constructor instead (e.g. uint(tmp) / float(tmp) / bool(tmp)). + // This preserves expected toggle semantics and prevents illegal MSL like as_type(bool_tmp). + { + string sc_true_expr; + if (sc_tmp_type == type.basetype) + sc_true_expr = sc_tmp_name; + else if (sc_tmp_type == SPIRType::Boolean || type.basetype == SPIRType::Boolean) + sc_true_expr = join(sc_type_name, "(", sc_tmp_name, ")"); + else + sc_true_expr = bitcast_expression(type, sc_tmp_type, sc_tmp_name); + statement("constant ", sc_type_name, " ", sc_name, " = is_function_constant_defined(", sc_tmp_name, + ") ? ", sc_true_expr, " : ", constant_expression(c), ";"); + } } else if (has_decoration(c.self, DecorationSpecId)) { @@ -9161,7 +9236,12 @@ bool CompilerMSL::prepare_access_chain_for_scalar_access(std::string &expr, cons // and there is a risk of concurrent write access to other components, // we must cast the access chain to a plain pointer to ensure we only access the exact scalars we expect. // The MSL compiler refuses to allow component-level access for any non-packed vector types. - if (!is_packed && (storage == StorageClassStorageBuffer || storage == StorageClassWorkgroup)) + // MSL refuses to take address or reference to vector component, even for packed types, so just force + // through the pointer cast. No much we can do sadly. + // For packed types, we could technically omit this if we know the reference does not have to turn into a pointer + // of some kind, but that requires external analysis passes to figure out, and + // this case is likely rare enough that we don't need to bother. + if (storage == StorageClassStorageBuffer || storage == StorageClassWorkgroup) { const char *addr_space = storage == StorageClassWorkgroup ? "threadgroup" : "device"; expr = join("((", addr_space, " ", type_to_glsl(type), "*)&", enclose_expression(expr), ")"); @@ -9485,21 +9565,21 @@ void CompilerMSL::emit_instruction(const Instruction &instruction) break; case OpFMul: - if (msl_options.invariant_float_math || has_decoration(ops[1], DecorationNoContraction)) + if (msl_options.invariant_float_math || has_legacy_nocontract(ops[0], ops[1])) MSL_BFOP(spvFMul); else MSL_BOP(*); break; case OpFAdd: - if (msl_options.invariant_float_math || has_decoration(ops[1], DecorationNoContraction)) + if (msl_options.invariant_float_math || has_legacy_nocontract(ops[0], ops[1])) MSL_BFOP(spvFAdd); else MSL_BOP(+); break; case OpFSub: - if (msl_options.invariant_float_math || has_decoration(ops[1], DecorationNoContraction)) + if (msl_options.invariant_float_math || has_legacy_nocontract(ops[0], ops[1])) MSL_BFOP(spvFSub); else MSL_BOP(-); @@ -9997,7 +10077,7 @@ void CompilerMSL::emit_instruction(const Instruction &instruction) case OpVectorTimesMatrix: case OpMatrixTimesVector: { - if (!msl_options.invariant_float_math && !has_decoration(ops[1], DecorationNoContraction)) + if (!msl_options.invariant_float_math && !has_legacy_nocontract(ops[0], ops[1])) { CompilerGLSL::emit_instruction(instruction); break; @@ -10039,7 +10119,7 @@ void CompilerMSL::emit_instruction(const Instruction &instruction) case OpMatrixTimesMatrix: { - if (!msl_options.invariant_float_math && !has_decoration(ops[1], DecorationNoContraction)) + if (!msl_options.invariant_float_math && !has_legacy_nocontract(ops[0], ops[1])) { CompilerGLSL::emit_instruction(instruction); break; @@ -10725,13 +10805,13 @@ bool CompilerMSL::emit_array_copy(const char *expr, uint32_t lhs_id, uint32_t rh auto *lhs_var = maybe_get_backing_variable(lhs_id); if (lhs_var && lhs_storage == StorageClassStorageBuffer && storage_class_array_is_thread(lhs_var->storage)) lhs_is_array_template = true; - else if (lhs_var && lhs_storage != StorageClassGeneric && type_is_block_like(get(lhs_var->basetype))) + else if (lhs_var && lhs_storage != StorageClassGeneric && type_is_explicit_layout(get(lhs_var->basetype))) lhs_is_array_template = false; auto *rhs_var = maybe_get_backing_variable(rhs_id); if (rhs_var && rhs_storage == StorageClassStorageBuffer && storage_class_array_is_thread(rhs_var->storage)) rhs_is_array_template = true; - else if (rhs_var && rhs_storage != StorageClassGeneric && type_is_block_like(get(rhs_var->basetype))) + else if (rhs_var && rhs_storage != StorageClassGeneric && type_is_explicit_layout(get(rhs_var->basetype))) rhs_is_array_template = false; // If threadgroup storage qualifiers are *not* used: @@ -11182,35 +11262,76 @@ void CompilerMSL::emit_glsl_op(uint32_t result_type, uint32_t id, uint32_t eop, auto &restype = get(result_type); + // Only precise:: preserves NaN in trancendentals (supposedly, cannot find documentation for this). + const auto drop_nan_inf = FPFastMathModeNotInfMask | FPFastMathModeNotNaNMask; + bool preserve_nan = (get_fp_fast_math_flags_for_op(result_type, id) & drop_nan_inf) != drop_nan_inf; + const char *preserve_str = preserve_nan ? "precise" : "fast"; + + // TODO: Emit the default behavior to match existing code. Might need to be revisited. + // Only fp32 has the precise:: override. +#define EMIT_PRECISE_OVERRIDE(glsl_op, op) \ + case GLSLstd450##glsl_op: \ + if (restype.basetype == SPIRType::Float && preserve_nan) \ + emit_unary_func_op(result_type, id, args[0], "precise::" op); \ + else \ + CompilerGLSL::emit_glsl_op(result_type, id, eop, args, count); \ + break + switch (op) { + EMIT_PRECISE_OVERRIDE(Cos, "cos"); + EMIT_PRECISE_OVERRIDE(Sin, "sin"); + EMIT_PRECISE_OVERRIDE(Tan, "tan"); + EMIT_PRECISE_OVERRIDE(Acos, "acos"); + EMIT_PRECISE_OVERRIDE(Asin, "asin"); + EMIT_PRECISE_OVERRIDE(Atan, "atan"); + EMIT_PRECISE_OVERRIDE(Exp, "exp"); + EMIT_PRECISE_OVERRIDE(Exp2, "exp2"); + EMIT_PRECISE_OVERRIDE(Log, "log"); + EMIT_PRECISE_OVERRIDE(Log2, "log2"); + EMIT_PRECISE_OVERRIDE(Sqrt, "sqrt"); +#undef EMIT_PRECISE_OVERRIDE + case GLSLstd450Sinh: if (restype.basetype == SPIRType::Half) { + auto ftype = restype; + ftype.basetype = SPIRType::Float; + // MSL does not have overload for half. Force-cast back to half. - auto expr = join("half(fast::sinh(", to_unpacked_expression(args[0]), "))"); + auto expr = join(type_to_glsl(restype), "(", preserve_str, "::sinh(", type_to_glsl(ftype), "(", to_unpacked_expression(args[0]), ")))"); emit_op(result_type, id, expr, should_forward(args[0])); inherit_expression_dependencies(id, args[0]); } + else if (preserve_nan) + emit_unary_func_op(result_type, id, args[0], "precise::sinh"); else emit_unary_func_op(result_type, id, args[0], "fast::sinh"); break; case GLSLstd450Cosh: if (restype.basetype == SPIRType::Half) { + auto ftype = restype; + ftype.basetype = SPIRType::Float; + // MSL does not have overload for half. Force-cast back to half. - auto expr = join("half(fast::cosh(", to_unpacked_expression(args[0]), "))"); + auto expr = join(type_to_glsl(restype), "(", preserve_str, "::cosh(", type_to_glsl(ftype), "(", to_unpacked_expression(args[0]), ")))"); emit_op(result_type, id, expr, should_forward(args[0])); inherit_expression_dependencies(id, args[0]); } + else if (preserve_nan) + emit_unary_func_op(result_type, id, args[0], "precise::cosh"); else emit_unary_func_op(result_type, id, args[0], "fast::cosh"); break; case GLSLstd450Tanh: if (restype.basetype == SPIRType::Half) { + auto ftype = restype; + ftype.basetype = SPIRType::Float; + // MSL does not have overload for half. Force-cast back to half. - auto expr = join("half(fast::tanh(", to_unpacked_expression(args[0]), "))"); + auto expr = join(type_to_glsl(restype), "(", preserve_str, "::tanh(", type_to_glsl(ftype), "(", to_unpacked_expression(args[0]), ")))"); emit_op(result_type, id, expr, should_forward(args[0])); inherit_expression_dependencies(id, args[0]); } @@ -11221,7 +11342,13 @@ void CompilerMSL::emit_glsl_op(uint32_t result_type, uint32_t id, uint32_t eop, if (restype.basetype == SPIRType::Half) { // MSL does not have overload for half. Force-cast back to half. - auto expr = join("half(fast::atan2(", to_unpacked_expression(args[0]), ", ", to_unpacked_expression(args[1]), "))"); + auto ftype = restype; + ftype.basetype = SPIRType::Float; + + auto expr = join(type_to_glsl(restype), + "(", preserve_str, "::atan2(", + type_to_glsl(ftype), "(", to_unpacked_expression(args[0]), "), ", + type_to_glsl(ftype), "(", to_unpacked_expression(args[1]), ")))"); emit_op(result_type, id, expr, should_forward(args[0]) && should_forward(args[1])); inherit_expression_dependencies(id, args[0]); inherit_expression_dependencies(id, args[1]); @@ -11230,7 +11357,10 @@ void CompilerMSL::emit_glsl_op(uint32_t result_type, uint32_t id, uint32_t eop, emit_binary_func_op(result_type, id, args[0], args[1], "precise::atan2"); break; case GLSLstd450InverseSqrt: - emit_unary_func_op(result_type, id, args[0], "rsqrt"); + if (restype.basetype == SPIRType::Float && preserve_nan) + emit_unary_func_op(result_type, id, args[0], "precise::rsqrt"); + else + emit_unary_func_op(result_type, id, args[0], "rsqrt"); break; case GLSLstd450RoundEven: emit_unary_func_op(result_type, id, args[0], "rint"); @@ -11462,11 +11592,14 @@ void CompilerMSL::emit_glsl_op(uint32_t result_type, uint32_t id, uint32_t eop, { auto &exp_type = expression_type(args[0]); // MSL does not support scalar versions here. - // MSL has no implementation for normalize in the fast:: namespace for half2 and half3 + // MSL has no implementation for normalize in the fast:: namespace for half // Returns -1 or 1 for valid input, sign() does the job. + + // precise::normalize asm looks ridiculous. + // Don't think this actually matters unless proven otherwise. if (exp_type.vecsize == 1) emit_unary_func_op(result_type, id, args[0], "sign"); - else if (exp_type.vecsize <= 3 && exp_type.basetype == SPIRType::Half) + else if (exp_type.basetype == SPIRType::Half) emit_unary_func_op(result_type, id, args[0], "normalize"); else emit_unary_func_op(result_type, id, args[0], "fast::normalize"); @@ -11529,7 +11662,10 @@ void CompilerMSL::emit_glsl_op(uint32_t result_type, uint32_t id, uint32_t eop, case GLSLstd450Pow: // powr makes x < 0.0 undefined, just like SPIR-V. - emit_binary_func_op(result_type, id, args[0], args[1], "powr"); + if (restype.basetype == SPIRType::Float && preserve_nan) + emit_binary_func_op(result_type, id, args[0], args[1], "precise::powr"); + else + emit_binary_func_op(result_type, id, args[0], args[1], "powr"); break; default: @@ -13753,6 +13889,24 @@ uint32_t CompilerMSL::get_or_allocate_builtin_output_member_location(spv::BuiltI return loc; } +bool CompilerMSL::entry_point_returns_stage_output() const +{ + if (get_execution_model() == ExecutionModelVertex && msl_options.vertex_for_tessellation) + return false; + bool ep_should_return_output = !get_is_rasterization_disabled(); + return stage_out_var_id && ep_should_return_output; +} + +bool CompilerMSL::entry_point_requires_const_device_buffers() const +{ + // For fragment, we don't really need it, but it might help avoid pessimization + // if the compiler deduces it needs to use late-Z for whatever reason. + return (get_execution_model() == ExecutionModelFragment && !has_descriptor_side_effects) || + (entry_point_returns_stage_output() && + (get_execution_model() == ExecutionModelVertex || + get_execution_model() == ExecutionModelTessellationEvaluation)); +} + // Returns the type declaration for a function, including the // entry type if the current function is the entry point function string CompilerMSL::func_type_decl(SPIRType &type) @@ -13763,8 +13917,7 @@ string CompilerMSL::func_type_decl(SPIRType &type) return return_type; // If an outgoing interface block has been defined, and it should be returned, override the entry point return type - bool ep_should_return_output = !get_is_rasterization_disabled(); - if (stage_out_var_id && ep_should_return_output) + if (entry_point_returns_stage_output()) return_type = type_to_glsl(get_stage_out_struct_type()) + type_to_array_glsl(type, 0); // Prepend a entry type, based on the execution model @@ -13888,16 +14041,14 @@ string CompilerMSL::get_type_address_space(const SPIRType &type, uint32_t id, bo case StorageClassStorageBuffer: { - // For arguments from variable pointers, we use the write count deduction, so - // we should not assume any constness here. Only for global SSBOs. - bool readonly = false; - if (!var || has_decoration(type.self, DecorationBlock)) - readonly = flags.get(DecorationNonWritable); - - if (decoration_flags_signal_coherent(flags)) - readonly = false; - - addr_space = readonly ? "const device" : "device"; + // When dealing with descriptor aliasing, it becomes very problematic to make use of + // readonly qualifiers. + // If rasterization is not disabled in vertex/tese, Metal does not allow side effects and refuses to compile "device", + // even if there are no writes. Just force const device. + if (entry_point_requires_const_device_buffers()) + addr_space = "const device"; + else + addr_space = "device"; break; } @@ -13914,7 +14065,12 @@ string CompilerMSL::get_type_address_space(const SPIRType &type, uint32_t id, bo { bool ssbo = has_decoration(type.self, DecorationBufferBlock); if (ssbo) - addr_space = flags.get(DecorationNonWritable) ? "const device" : "device"; + { + if (entry_point_requires_const_device_buffers()) + addr_space = "const device"; + else + addr_space = "device"; + } else addr_space = "constant"; } @@ -16553,7 +16709,7 @@ string CompilerMSL::type_to_array_glsl(const SPIRType &type, uint32_t variable_i default: if (type_is_array_of_pointers(type) || using_builtin_array()) { - const SPIRVariable *var = variable_id ? &get(variable_id) : nullptr; + const SPIRVariable *var = variable_id ? maybe_get(variable_id) : nullptr; if (var && (var->storage == StorageClassUniform || var->storage == StorageClassStorageBuffer) && is_array(get_variable_data_type(*var))) { @@ -16854,6 +17010,8 @@ string CompilerMSL::image_type_glsl(const SPIRType &type, uint32_t id, bool memb if (p_var && p_var->basevariable) p_var = maybe_get(p_var->basevariable); + bool has_access_qualifier = true; + switch (img_type.access) { case AccessQualifierReadOnly: @@ -16879,12 +17037,21 @@ string CompilerMSL::image_type_glsl(const SPIRType &type, uint32_t id, bool memb img_type_name += "write"; } + else + { + has_access_qualifier = false; + } break; } } if (p_var && has_decoration(p_var->self, DecorationCoherent) && msl_options.supports_msl_version(3, 2)) + { + // Cannot declare memory_coherence_device without access qualifier. + if (!has_access_qualifier) + img_type_name += ", access::read"; img_type_name += ", memory_coherence_device"; + } } img_type_name += ">"; @@ -17317,13 +17484,18 @@ void CompilerMSL::emit_subgroup_cluster_op_cast(uint32_t result_type, uint32_t r inherit_expression_dependencies(result_id, op0); } +// Note: Metal forbids bitcasting to/from 'bool' using as_type. This function is used widely +// for generating casts in the backend. To avoid generating illegal MSL when the canonical +// function constant type (from deduplicated SpecId) is Boolean, fall back to value-cast in +// that case by returning type_to_glsl(out_type) instead of as_type<...>. string CompilerMSL::bitcast_glsl_op(const SPIRType &out_type, const SPIRType &in_type) { if (out_type.basetype == in_type.basetype) return ""; - assert(out_type.basetype != SPIRType::Boolean); - assert(in_type.basetype != SPIRType::Boolean); + // Avoid bitcasting to/from booleans in MSL; use value cast instead. + if (out_type.basetype == SPIRType::Boolean || in_type.basetype == SPIRType::Boolean) + return type_to_glsl(out_type); bool integral_cast = type_is_integral(out_type) && type_is_integral(in_type) && (out_type.vecsize == in_type.vecsize); bool same_size_cast = (out_type.width * out_type.vecsize) == (in_type.width * in_type.vecsize); @@ -17679,6 +17851,9 @@ string CompilerMSL::builtin_qualifier(BuiltIn builtin) case BuiltInGlobalInvocationId: return "thread_position_in_grid"; + case BuiltInWorkgroupSize: + return "threads_per_threadgroup"; + case BuiltInWorkgroupId: return "threadgroup_position_in_grid"; @@ -17864,6 +18039,7 @@ string CompilerMSL::builtin_type_decl(BuiltIn builtin, uint32_t id) case BuiltInLocalInvocationId: case BuiltInNumWorkgroups: case BuiltInWorkgroupId: + case BuiltInWorkgroupSize: return "uint3"; case BuiltInLocalInvocationIndex: case BuiltInNumSubgroups: @@ -18531,11 +18707,8 @@ CompilerMSL::SPVFuncImpl CompilerMSL::OpCodePreprocessor::get_spv_func_impl(Op o case OpFAdd: case OpFSub: - if (compiler.msl_options.invariant_float_math || - compiler.has_decoration(args[1], DecorationNoContraction)) - { + if (compiler.msl_options.invariant_float_math || compiler.has_legacy_nocontract(args[0], args[1])) return opcode == OpFAdd ? SPVFuncImplFAdd : SPVFuncImplFSub; - } break; case OpFMul: @@ -18543,11 +18716,8 @@ CompilerMSL::SPVFuncImpl CompilerMSL::OpCodePreprocessor::get_spv_func_impl(Op o case OpMatrixTimesVector: case OpVectorTimesMatrix: case OpMatrixTimesMatrix: - if (compiler.msl_options.invariant_float_math || - compiler.has_decoration(args[1], DecorationNoContraction)) - { + if (compiler.msl_options.invariant_float_math || compiler.has_legacy_nocontract(args[0], args[1])) return SPVFuncImplFMul; - } break; case OpQuantizeToF16: @@ -19572,7 +19742,7 @@ void CompilerMSL::analyze_argument_buffers() SetBindingPair pair = { desc_set, binding }; if (resource.basetype == SPIRType::Image || resource.basetype == SPIRType::Sampler || - resource.basetype == SPIRType::SampledImage) + resource.basetype == SPIRType::SampledImage || resource.basetype == SPIRType::AccelerationStructure) { // Drop pointer information when we emit the resources into a struct. buffer_type.member_types.push_back(get_variable_data_type_id(var)); @@ -19827,6 +19997,30 @@ bool CompilerMSL::specialization_constant_is_macro(uint32_t const_id) const return constant_macro_ids.find(const_id) != constant_macro_ids.end(); } +// Start with all fast math flags enabled, and selectively disable based execution modes and float controls +uint32_t CompilerMSL::get_fp_fast_math_flags(bool incl_ops) const +{ + uint32_t fp_flags = ~0; + auto &ep = get_entry_point(); + + if (ep.flags.get(ExecutionModeSignedZeroInfNanPreserve)) + fp_flags &= ~(FPFastMathModeNSZMask | FPFastMathModeNotInfMask | FPFastMathModeNotNaNMask); + + if (ep.flags.get(ExecutionModeContractionOff)) + fp_flags &= ~(FPFastMathModeAllowContractMask); + + for (auto &fp_pair : ep.fp_fast_math_defaults) + if (fp_pair.second) + fp_flags &= get(fp_pair.second).scalar(); + + if (incl_ops) + for (auto &p_m : ir.meta) + if (p_m.second.decoration.decoration_flags.get(DecorationFPFastMathMode)) + fp_flags &= p_m.second.decoration.fp_fast_math_mode; + + return fp_flags; +} + void CompilerMSL::emit_block_hints(const SPIRBlock &) { } diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_msl.hpp b/libs/bgfx/3rdparty/spirv-cross/spirv_msl.hpp index a3d08bf..cd767ea 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_msl.hpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_msl.hpp @@ -542,6 +542,10 @@ class CompilerMSL : public CompilerGLSL // The result can be queried with get_is_rasterization_disabled. bool auto_disable_rasterization = false; + // Use Fast Math pragmas in MSL code, based on SPIR-V float controls and FP ExecutionModes. + // Requires MSL 3.2 or above, and has no effect with earlier MSL versions. + bool use_fast_math_pragmas = false; + bool is_ios() const { return platform == iOS; @@ -767,6 +771,14 @@ class CompilerMSL : public CompilerGLSL // These must only be called after a successful call to CompilerMSL::compile(). bool specialization_constant_is_macro(uint32_t constant_id) const; + // Returns a mask of SPIR-V FP Fast Math Mode flags, that represents the set of flags that can be applied + // across all floating-point types. Each FPFastMathDefault execution mode operation identifies the flags + // for one floating-point type, and the value returned here is a bitwise-AND combination across all types. + // If incl_ops is enabled, the FPFastMathMode of any SPIR-V operations are also included in the bitwise-AND + // to determine the minimal fast-math that applies to all default execution modes and all operations. + // The returned value is also affected by execution modes SignedZeroInfNanPreserve and ContractionOff. + uint32_t get_fp_fast_math_flags(bool incl_ops) const; + protected: // An enum of SPIR-V functions that are implemented in additional // source code that is added to the shader if necessary. @@ -1047,6 +1059,8 @@ class CompilerMSL : public CompilerGLSL void fix_up_shader_inputs_outputs(); + bool entry_point_returns_stage_output() const; + bool entry_point_requires_const_device_buffers() const; std::string func_type_decl(SPIRType &type); std::string entry_point_args_classic(bool append_comma); std::string entry_point_args_argument_buffer(bool append_comma); @@ -1126,7 +1140,7 @@ class CompilerMSL : public CompilerGLSL uint32_t mem_order_1, uint32_t mem_order_2, bool has_mem_order_2, uint32_t op0, uint32_t op1 = 0, bool op1_is_pointer = false, bool op1_is_literal = false, uint32_t op2 = 0); const char *get_memory_order(uint32_t spv_mem_sem); - void add_pragma_line(const std::string &line); + void add_pragma_line(const std::string &line, bool recompile_on_unique); void add_typedef_line(const std::string &line); void emit_barrier(uint32_t id_exe_scope, uint32_t id_mem_scope, uint32_t id_mem_sem); bool emit_array_copy(const char *expr, uint32_t lhs_id, uint32_t rhs_id, @@ -1209,8 +1223,8 @@ class CompilerMSL : public CompilerGLSL std::unordered_map fragment_output_components; std::unordered_map builtin_to_automatic_input_location; std::unordered_map builtin_to_automatic_output_location; - std::set pragma_lines; - std::set typedef_lines; + std::vector pragma_lines; + std::vector typedef_lines; SmallVector vars_needing_early_declaration; std::unordered_set constant_macro_ids; @@ -1252,6 +1266,7 @@ class CompilerMSL : public CompilerGLSL bool using_builtin_array() const; bool is_rasterization_disabled = false; + bool has_descriptor_side_effects = false; bool capture_output_to_buffer = false; bool needs_swizzle_buffer_def = false; bool used_swizzle_buffer = false; diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_parser.cpp b/libs/bgfx/3rdparty/spirv-cross/spirv_parser.cpp index 745ab6e..f3ea7e2 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_parser.cpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_parser.cpp @@ -213,8 +213,8 @@ void Parser::parse(const Instruction &instruction) case OpSource: { - auto lang = static_cast(ops[0]); - switch (lang) + ir.source.lang = static_cast(ops[0]); + switch (ir.source.lang) { case SourceLanguageESSL: ir.source.es = true; @@ -318,6 +318,19 @@ void Parser::parse(const Instruction &instruction) ir.load_type_width.insert({ ops[1], type->width }); } } + else if (op == OpExtInst) + { + // Don't want to deal with ForwardRefs here. + + auto &ext = get(ops[2]); + if (ext.ext == SPIRExtension::NonSemanticShaderDebugInfo) + { + // Parse global ShaderDebugInfo we care about. + // Just forward the string information. + if (ops[3] == SPIRExtension::DebugSource) + set(ops[1], get(ops[4]).str); + } + } break; } @@ -369,6 +382,30 @@ void Parser::parse(const Instruction &instruction) execution.output_primitives = ops[2]; break; + case ExecutionModeSignedZeroInfNanPreserve: + switch (ops[2]) + { + case 8: + execution.signed_zero_inf_nan_preserve_8 = true; + break; + + case 16: + execution.signed_zero_inf_nan_preserve_16 = true; + break; + + case 32: + execution.signed_zero_inf_nan_preserve_32 = true; + break; + + case 64: + execution.signed_zero_inf_nan_preserve_64 = true; + break; + + default: + SPIRV_CROSS_THROW("Invalid bit-width for SignedZeroInfNanPreserve."); + } + break; + default: break; } @@ -381,13 +418,21 @@ void Parser::parse(const Instruction &instruction) auto mode = static_cast(ops[1]); execution.flags.set(mode); - if (mode == ExecutionModeLocalSizeId) + switch (mode) { + case ExecutionModeLocalSizeId: execution.workgroup_size.id_x = ops[2]; execution.workgroup_size.id_y = ops[3]; execution.workgroup_size.id_z = ops[4]; - } + break; + + case ExecutionModeFPFastMathDefault: + execution.fp_fast_math_defaults[ops[2]] = ops[3]; + break; + default: + break; + } break; } @@ -538,7 +583,7 @@ void Parser::parse(const Instruction &instruction) uint32_t width = ops[1]; auto &type = set(id, op); - if (width != 16 && length > 2) + if (width != 16 && width != 8 && length > 2) SPIRV_CROSS_THROW("Unrecognized FP encoding mode for OpTypeFloat."); if (width == 64) @@ -557,6 +602,17 @@ void Parser::parse(const Instruction &instruction) else type.basetype = SPIRType::Half; } + else if (width == 8) + { + if (length < 2) + SPIRV_CROSS_THROW("Missing encoding for OpTypeFloat 8."); + else if (ops[2] == spv::FPEncodingFloat8E4M3EXT) + type.basetype = SPIRType::FloatE4M3; + else if (ops[2] == spv::FPEncodingFloat8E5M2EXT) + type.basetype = SPIRType::FloatE5M2; + else + SPIRV_CROSS_THROW("Invalid encoding for OpTypeFloat 8."); + } else SPIRV_CROSS_THROW("Unrecognized bit-width of floating point type."); type.width = width; @@ -614,15 +670,33 @@ void Parser::parse(const Instruction &instruction) auto &matrixbase = set(id, base); matrixbase.op = op; - matrixbase.cooperative.scope_id = ops[2]; - matrixbase.cooperative.rows_id = ops[3]; - matrixbase.cooperative.columns_id = ops[4]; - matrixbase.cooperative.use_id = ops[5]; + matrixbase.ext.cooperative.scope_id = ops[2]; + matrixbase.ext.cooperative.rows_id = ops[3]; + matrixbase.ext.cooperative.columns_id = ops[4]; + matrixbase.ext.cooperative.use_id = ops[5]; matrixbase.self = id; matrixbase.parent_type = ops[1]; break; } + case OpTypeCooperativeVectorNV: + { + uint32_t id = ops[0]; + auto &type = set(id, op); + + type.basetype = SPIRType::CoopVecNV; + type.op = op; + type.ext.coopVecNV.component_type_id = ops[1]; + type.ext.coopVecNV.component_count_id = ops[2]; + type.parent_type = ops[1]; + + // CoopVec-Nv can be used with integer operations like SMax where + // where spirv-opt does explicit checks on integer bitwidth + auto component_type = get(type.ext.coopVecNV.component_type_id); + type.width = component_type.width; + break; + } + case OpTypeArray: { uint32_t id = ops[0]; @@ -820,6 +894,20 @@ void Parser::parse(const Instruction &instruction) break; } + case OpTypeTensorARM: + { + uint32_t id = ops[0]; + auto &type = set(id, op); + type.basetype = SPIRType::Tensor; + type.ext.tensor = {}; + type.ext.tensor.type = ops[1]; + if (length >= 3) + type.ext.tensor.rank = ops[2]; + if (length >= 4) + type.ext.tensor.shape = ops[3]; + break; + } + // Variable declaration // All variables are essentially pointers with a storage qualifier. case OpVariable: @@ -866,17 +954,27 @@ void Parser::parse(const Instruction &instruction) break; } - // Constants + // Constants case OpSpecConstant: case OpConstant: + case OpConstantCompositeReplicateEXT: + case OpSpecConstantCompositeReplicateEXT: { uint32_t id = ops[1]; auto &type = get(ops[0]); - - if (type.width > 32) - set(id, ops[0], ops[2] | (uint64_t(ops[3]) << 32), op == OpSpecConstant); + if (op == OpConstantCompositeReplicateEXT || op == OpSpecConstantCompositeReplicateEXT) + { + auto subconstant = uint32_t(ops[2]); + set(id, ops[0], &subconstant, 1, op == OpSpecConstantCompositeReplicateEXT, true); + } else - set(id, ops[0], ops[2], op == OpSpecConstant); + { + + if (type.width > 32) + set(id, ops[0], ops[2] | (uint64_t(ops[3]) << 32), op == OpSpecConstant); + else + set(id, ops[0], ops[2], op == OpSpecConstant); + } break; } diff --git a/libs/bgfx/3rdparty/spirv-cross/spirv_reflect.cpp b/libs/bgfx/3rdparty/spirv-cross/spirv_reflect.cpp index 552d671..ab5a91f 100644 --- a/libs/bgfx/3rdparty/spirv-cross/spirv_reflect.cpp +++ b/libs/bgfx/3rdparty/spirv-cross/spirv_reflect.cpp @@ -477,6 +477,12 @@ string CompilerReflection::execution_model_to_str(spv::ExecutionModel model) return "rmiss"; case ExecutionModelCallableNV: return "rcall"; + case ExecutionModelMeshNV: + case ExecutionModelMeshEXT: + return "mesh"; + case ExecutionModelTaskNV: + case ExecutionModelTaskEXT: + return "task"; default: return "???"; } @@ -504,7 +510,9 @@ void CompilerReflection::emit_entry_points() json_stream->begin_json_object(); json_stream->emit_json_key_value("name", e.name); json_stream->emit_json_key_value("mode", execution_model_to_str(e.execution_model)); - if (e.execution_model == ExecutionModelGLCompute) + if (e.execution_model == ExecutionModelGLCompute || e.execution_model == spv::ExecutionModelMeshEXT || + e.execution_model == spv::ExecutionModelMeshNV || e.execution_model == spv::ExecutionModelTaskEXT || + e.execution_model == spv::ExecutionModelTaskNV) { const auto &spv_entry = get_entry_point(e.name, e.execution_model); @@ -547,6 +555,7 @@ void CompilerReflection::emit_resources() emit_resources("push_constants", res.push_constant_buffers); emit_resources("counters", res.atomic_counters); emit_resources("acceleration_structures", res.acceleration_structures); + emit_resources("tensors", res.tensors); } void CompilerReflection::emit_resources(const char *tag, const SmallVector &resources) diff --git a/libs/bgfx/3rdparty/spirv-headers/LICENSE b/libs/bgfx/3rdparty/spirv-headers/LICENSE index a02ace1..a63e9c6 100644 --- a/libs/bgfx/3rdparty/spirv-headers/LICENSE +++ b/libs/bgfx/3rdparty/spirv-headers/LICENSE @@ -101,3 +101,402 @@ SOFTWARE. ======================================================================== --- + +Files: **.md, WORKSPACE, .git** + +Attribution 4.0 International + +======================================================================= + +Creative Commons Corporation ("Creative Commons") is not a law firm and +does not provide legal services or legal advice. Distribution of +Creative Commons public licenses does not create a lawyer-client or +other relationship. Creative Commons makes its licenses and related +information available on an "as-is" basis. Creative Commons gives no +warranties regarding its licenses, any material licensed under their +terms and conditions, or any related information. Creative Commons +disclaims all liability for damages resulting from their use to the +fullest extent possible. + +Using Creative Commons Public Licenses + +Creative Commons public licenses provide a standard set of terms and +conditions that creators and other rights holders may use to share +original works of authorship and other material subject to copyright +and certain other rights specified in the public license below. The +following considerations are for informational purposes only, are not +exhaustive, and do not form part of our licenses. + + Considerations for licensors: Our public licenses are + intended for use by those authorized to give the public + permission to use material in ways otherwise restricted by + copyright and certain other rights. Our licenses are + irrevocable. Licensors should read and understand the terms + and conditions of the license they choose before applying it. + Licensors should also secure all rights necessary before + applying our licenses so that the public can reuse the + material as expected. Licensors should clearly mark any + material not subject to the license. This includes other CC- + licensed material, or material used under an exception or + limitation to copyright. More considerations for licensors: + wiki.creativecommons.org/Considerations_for_licensors + + Considerations for the public: By using one of our public + licenses, a licensor grants the public permission to use the + licensed material under specified terms and conditions. If + the licensor's permission is not necessary for any reason--for + example, because of any applicable exception or limitation to + copyright--then that use is not regulated by the license. Our + licenses grant only permissions under copyright and certain + other rights that a licensor has authority to grant. Use of + the licensed material may still be restricted for other + reasons, including because others have copyright or other + rights in the material. A licensor may make special requests, + such as asking that all changes be marked or described. + Although not required by our licenses, you are encouraged to + respect those requests where reasonable. More considerations + for the public: + wiki.creativecommons.org/Considerations_for_licensees + +======================================================================= + +Creative Commons Attribution 4.0 International Public License + +By exercising the Licensed Rights (defined below), You accept and agree +to be bound by the terms and conditions of this Creative Commons +Attribution 4.0 International Public License ("Public License"). To the +extent this Public License may be interpreted as a contract, You are +granted the Licensed Rights in consideration of Your acceptance of +these terms and conditions, and the Licensor grants You such rights in +consideration of benefits the Licensor receives from making the +Licensed Material available under these terms and conditions. + + +Section 1 -- Definitions. + + a. Adapted Material means material subject to Copyright and Similar + Rights that is derived from or based upon the Licensed Material + and in which the Licensed Material is translated, altered, + arranged, transformed, or otherwise modified in a manner requiring + permission under the Copyright and Similar Rights held by the + Licensor. For purposes of this Public License, where the Licensed + Material is a musical work, performance, or sound recording, + Adapted Material is always produced where the Licensed Material is + synched in timed relation with a moving image. + + b. Adapter's License means the license You apply to Your Copyright + and Similar Rights in Your contributions to Adapted Material in + accordance with the terms and conditions of this Public License. + + c. Copyright and Similar Rights means copyright and/or similar rights + closely related to copyright including, without limitation, + performance, broadcast, sound recording, and Sui Generis Database + Rights, without regard to how the rights are labeled or + categorized. For purposes of this Public License, the rights + specified in Section 2(b)(1)-(2) are not Copyright and Similar + Rights. + + d. Effective Technological Measures means those measures that, in the + absence of proper authority, may not be circumvented under laws + fulfilling obligations under Article 11 of the WIPO Copyright + Treaty adopted on December 20, 1996, and/or similar international + agreements. + + e. Exceptions and Limitations means fair use, fair dealing, and/or + any other exception or limitation to Copyright and Similar Rights + that applies to Your use of the Licensed Material. + + f. Licensed Material means the artistic or literary work, database, + or other material to which the Licensor applied this Public + License. + + g. Licensed Rights means the rights granted to You subject to the + terms and conditions of this Public License, which are limited to + all Copyright and Similar Rights that apply to Your use of the + Licensed Material and that the Licensor has authority to license. + + h. Licensor means the individual(s) or entity(ies) granting rights + under this Public License. + + i. Share means to provide material to the public by any means or + process that requires permission under the Licensed Rights, such + as reproduction, public display, public performance, distribution, + dissemination, communication, or importation, and to make material + available to the public including in ways that members of the + public may access the material from a place and at a time + individually chosen by them. + + j. Sui Generis Database Rights means rights other than copyright + resulting from Directive 96/9/EC of the European Parliament and of + the Council of 11 March 1996 on the legal protection of databases, + as amended and/or succeeded, as well as other essentially + equivalent rights anywhere in the world. + + k. You means the individual or entity exercising the Licensed Rights + under this Public License. Your has a corresponding meaning. + + +Section 2 -- Scope. + + a. License grant. + + 1. Subject to the terms and conditions of this Public License, + the Licensor hereby grants You a worldwide, royalty-free, + non-sublicensable, non-exclusive, irrevocable license to + exercise the Licensed Rights in the Licensed Material to: + + a. reproduce and Share the Licensed Material, in whole or + in part; and + + b. produce, reproduce, and Share Adapted Material. + + 2. Exceptions and Limitations. For the avoidance of doubt, where + Exceptions and Limitations apply to Your use, this Public + License does not apply, and You do not need to comply with + its terms and conditions. + + 3. Term. The term of this Public License is specified in Section + 6(a). + + 4. Media and formats; technical modifications allowed. The + Licensor authorizes You to exercise the Licensed Rights in + all media and formats whether now known or hereafter created, + and to make technical modifications necessary to do so. The + Licensor waives and/or agrees not to assert any right or + authority to forbid You from making technical modifications + necessary to exercise the Licensed Rights, including + technical modifications necessary to circumvent Effective + Technological Measures. For purposes of this Public License, + simply making modifications authorized by this Section 2(a) + (4) never produces Adapted Material. + + 5. Downstream recipients. + + a. Offer from the Licensor -- Licensed Material. Every + recipient of the Licensed Material automatically + receives an offer from the Licensor to exercise the + Licensed Rights under the terms and conditions of this + Public License. + + b. No downstream restrictions. You may not offer or impose + any additional or different terms or conditions on, or + apply any Effective Technological Measures to, the + Licensed Material if doing so restricts exercise of the + Licensed Rights by any recipient of the Licensed + Material. + + 6. No endorsement. Nothing in this Public License constitutes or + may be construed as permission to assert or imply that You + are, or that Your use of the Licensed Material is, connected + with, or sponsored, endorsed, or granted official status by, + the Licensor or others designated to receive attribution as + provided in Section 3(a)(1)(A)(i). + + b. Other rights. + + 1. Moral rights, such as the right of integrity, are not + licensed under this Public License, nor are publicity, + privacy, and/or other similar personality rights; however, to + the extent possible, the Licensor waives and/or agrees not to + assert any such rights held by the Licensor to the limited + extent necessary to allow You to exercise the Licensed + Rights, but not otherwise. + + 2. Patent and trademark rights are not licensed under this + Public License. + + 3. To the extent possible, the Licensor waives any right to + collect royalties from You for the exercise of the Licensed + Rights, whether directly or through a collecting society + under any voluntary or waivable statutory or compulsory + licensing scheme. In all other cases the Licensor expressly + reserves any right to collect such royalties. + + +Section 3 -- License Conditions. + +Your exercise of the Licensed Rights is expressly made subject to the +following conditions. + + a. Attribution. + + 1. If You Share the Licensed Material (including in modified + form), You must: + + a. retain the following if it is supplied by the Licensor + with the Licensed Material: + + i. identification of the creator(s) of the Licensed + Material and any others designated to receive + attribution, in any reasonable manner requested by + the Licensor (including by pseudonym if + designated); + + ii. a copyright notice; + + iii. a notice that refers to this Public License; + + iv. a notice that refers to the disclaimer of + warranties; + + v. a URI or hyperlink to the Licensed Material to the + extent reasonably practicable; + + b. indicate if You modified the Licensed Material and + retain an indication of any previous modifications; and + + c. indicate the Licensed Material is licensed under this + Public License, and include the text of, or the URI or + hyperlink to, this Public License. + + 2. You may satisfy the conditions in Section 3(a)(1) in any + reasonable manner based on the medium, means, and context in + which You Share the Licensed Material. For example, it may be + reasonable to satisfy the conditions by providing a URI or + hyperlink to a resource that includes the required + information. + + 3. If requested by the Licensor, You must remove any of the + information required by Section 3(a)(1)(A) to the extent + reasonably practicable. + + 4. If You Share Adapted Material You produce, the Adapter's + License You apply must not prevent recipients of the Adapted + Material from complying with this Public License. + + +Section 4 -- Sui Generis Database Rights. + +Where the Licensed Rights include Sui Generis Database Rights that +apply to Your use of the Licensed Material: + + a. for the avoidance of doubt, Section 2(a)(1) grants You the right + to extract, reuse, reproduce, and Share all or a substantial + portion of the contents of the database; + + b. if You include all or a substantial portion of the database + contents in a database in which You have Sui Generis Database + Rights, then the database in which You have Sui Generis Database + Rights (but not its individual contents) is Adapted Material; and + + c. You must comply with the conditions in Section 3(a) if You Share + all or a substantial portion of the contents of the database. + +For the avoidance of doubt, this Section 4 supplements and does not +replace Your obligations under this Public License where the Licensed +Rights include other Copyright and Similar Rights. + + +Section 5 -- Disclaimer of Warranties and Limitation of Liability. + + a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE + EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS + AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF + ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS, + IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION, + WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR + PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS, + ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT + KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT + ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU. + + b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE + TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION, + NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT, + INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES, + COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR + USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN + ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR + DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR + IN PART, THIS LIMITATION MAY NOT APPLY TO YOU. + + c. The disclaimer of warranties and limitation of liability provided + above shall be interpreted in a manner that, to the extent + possible, most closely approximates an absolute disclaimer and + waiver of all liability. + + +Section 6 -- Term and Termination. + + a. This Public License applies for the term of the Copyright and + Similar Rights licensed here. However, if You fail to comply with + this Public License, then Your rights under this Public License + terminate automatically. + + b. Where Your right to use the Licensed Material has terminated under + Section 6(a), it reinstates: + + 1. automatically as of the date the violation is cured, provided + it is cured within 30 days of Your discovery of the + violation; or + + 2. upon express reinstatement by the Licensor. + + For the avoidance of doubt, this Section 6(b) does not affect any + right the Licensor may have to seek remedies for Your violations + of this Public License. + + c. For the avoidance of doubt, the Licensor may also offer the + Licensed Material under separate terms or conditions or stop + distributing the Licensed Material at any time; however, doing so + will not terminate this Public License. + + d. Sections 1, 5, 6, 7, and 8 survive termination of this Public + License. + + +Section 7 -- Other Terms and Conditions. + + a. The Licensor shall not be bound by any additional or different + terms or conditions communicated by You unless expressly agreed. + + b. Any arrangements, understandings, or agreements regarding the + Licensed Material not stated herein are separate from and + independent of the terms and conditions of this Public License. + + +Section 8 -- Interpretation. + + a. For the avoidance of doubt, this Public License does not, and + shall not be interpreted to, reduce, limit, restrict, or impose + conditions on any use of the Licensed Material that could lawfully + be made without permission under this Public License. + + b. To the extent possible, if any provision of this Public License is + deemed unenforceable, it shall be automatically reformed to the + minimum extent necessary to make it enforceable. If the provision + cannot be reformed, it shall be severed from this Public License + without affecting the enforceability of the remaining terms and + conditions. + + c. No term or condition of this Public License will be waived and no + failure to comply consented to unless expressly agreed to by the + Licensor. + + d. Nothing in this Public License constitutes or may be interpreted + as a limitation upon, or waiver of, any privileges and immunities + that apply to the Licensor or You, including from the legal + processes of any jurisdiction or authority. + + +======================================================================= + +Creative Commons is not a party to its public +licenses. Notwithstanding, Creative Commons may elect to apply one of +its public licenses to material it publishes and in those instances +will be considered the “Licensor.” The text of the Creative Commons +public licenses is dedicated to the public domain under the CC0 Public +Domain Dedication. Except for the limited purpose of indicating that +material is shared under a Creative Commons public license or as +otherwise permitted by the Creative Commons policies published at +creativecommons.org/policies, Creative Commons does not authorize the +use of the trademark "Creative Commons" or any other trademark or logo +of Creative Commons without its prior written consent including, +without limitation, in connection with any unauthorized modifications +to any of its public licenses or any other arrangements, +understandings, or agreements concerning use of licensed material. For +the avoidance of doubt, this paragraph does not form part of the +public licenses. + +Creative Commons may be contacted at creativecommons.org. + diff --git a/libs/bgfx/3rdparty/spirv-headers/include/spirv/spir-v.xml b/libs/bgfx/3rdparty/spirv-headers/include/spirv/spir-v.xml index b7c7947..ba45e3d 100644 --- a/libs/bgfx/3rdparty/spirv-headers/include/spirv/spir-v.xml +++ b/libs/bgfx/3rdparty/spirv-headers/include/spirv/spir-v.xml @@ -81,7 +81,8 @@ - + + diff --git a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/ArmMotionEngine.100.h b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/ArmMotionEngine.100.h new file mode 100644 index 0000000..b784290 --- /dev/null +++ b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/ArmMotionEngine.100.h @@ -0,0 +1,32 @@ +// SPDX-FileCopyrightText: 2022-2025 Arm Ltd. +// SPDX-License-Identifier: MIT + +#ifndef SPIRV_UNIFIED1_ArmMotionEngine_100_H_ +#define SPIRV_UNIFIED1_ArmMotionEngine_100_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + ArmMotionEngineVersion = 100, + ArmMotionEngineVersion_BitWidthPadding = 0x7fffffff +}; +enum { + ArmMotionEngineRevision = 1, + ArmMotionEngineRevision_BitWidthPadding = 0x7fffffff +}; + +enum ArmMotionEngineInstructions { + ArmMotionEngineMIN_SAD = 0, + ArmMotionEngineMIN_SAD_COST = 1, + ArmMotionEngineRAW_SAD = 2, + ArmMotionEngineInstructionsMax = 0x7fffffff +}; + + +#ifdef __cplusplus +} +#endif + +#endif // SPIRV_UNIFIED1_ArmMotionEngine_100_H_ diff --git a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/TOSA.001000.1.h b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/TOSA.001000.1.h new file mode 100644 index 0000000..3da2969 --- /dev/null +++ b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/TOSA.001000.1.h @@ -0,0 +1,95 @@ +// SPDX-FileCopyrightText: 2022-2025 Arm Ltd. +// SPDX-License-Identifier: MIT + +#ifndef SPIRV_UNIFIED1_TOSA_001000_1_H_ +#define SPIRV_UNIFIED1_TOSA_001000_1_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + TOSAVersion = 1000000, + TOSAVersion_BitWidthPadding = 0x7fffffff +}; +enum { + TOSARevision = 1, + TOSARevision_BitWidthPadding = 0x7fffffff +}; + +enum TOSAInstructions { + TOSAARGMAX = 0, + TOSAAVG_POOL2D = 1, + TOSACONV2D = 2, + TOSACONV3D = 3, + TOSADEPTHWISE_CONV2D = 4, + TOSAFFT2D = 5, + TOSAMATMUL = 6, + TOSAMAX_POOL2D = 7, + TOSARFFT2D = 8, + TOSATRANSPOSE_CONV2D = 9, + TOSACLAMP = 10, + TOSAERF = 11, + TOSASIGMOID = 12, + TOSATANH = 13, + TOSAADD = 14, + TOSAARITHMETIC_RIGHT_SHIFT = 15, + TOSABITWISE_AND = 16, + TOSABITWISE_OR = 17, + TOSABITWISE_XOR = 18, + TOSAINTDIV = 19, + TOSALOGICAL_AND = 20, + TOSALOGICAL_LEFT_SHIFT = 21, + TOSALOGICAL_RIGHT_SHIFT = 22, + TOSALOGICAL_OR = 23, + TOSALOGICAL_XOR = 24, + TOSAMAXIMUM = 25, + TOSAMINIMUM = 26, + TOSAMUL = 27, + TOSAPOW = 28, + TOSASUB = 29, + TOSATABLE = 30, + TOSAABS = 31, + TOSABITWISE_NOT = 32, + TOSACEIL = 33, + TOSACLZ = 34, + TOSACOS = 35, + TOSAEXP = 36, + TOSAFLOOR = 37, + TOSALOG = 38, + TOSALOGICAL_NOT = 39, + TOSANEGATE = 40, + TOSARECIPROCAL = 41, + TOSARSQRT = 42, + TOSASIN = 43, + TOSASELECT = 44, + TOSAEQUAL = 45, + TOSAGREATER = 46, + TOSAGREATER_EQUAL = 47, + TOSAREDUCE_ALL = 48, + TOSAREDUCE_ANY = 49, + TOSAREDUCE_MAX = 50, + TOSAREDUCE_MIN = 51, + TOSAREDUCE_PRODUCT = 52, + TOSAREDUCE_SUM = 53, + TOSACONCAT = 54, + TOSAPAD = 55, + TOSARESHAPE = 56, + TOSAREVERSE = 57, + TOSASLICE = 58, + TOSATILE = 59, + TOSATRANSPOSE = 60, + TOSAGATHER = 61, + TOSASCATTER = 62, + TOSARESIZE = 63, + TOSACAST = 64, + TOSARESCALE = 65, + TOSAInstructionsMax = 0x7fffffff +}; + + +#ifdef __cplusplus +} +#endif + +#endif // SPIRV_UNIFIED1_TOSA_001000_1_H_ diff --git a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/extinst.arm.motion-engine.100.grammar.json b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/extinst.arm.motion-engine.100.grammar.json new file mode 100644 index 0000000..abcc16e --- /dev/null +++ b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/extinst.arm.motion-engine.100.grammar.json @@ -0,0 +1,133 @@ +{ + "copyright": [ + "SPDX-FileCopyrightText: 2022-2025 Arm Ltd.", + "SPDX-License-Identifier: MIT" + ], + "version": 100, + "revision": 1, + "instructions": [ + { + "opname": "MIN_SAD", + "opcode": 0, + "operands": [ + { + "kind": "IdRef", + "name": "kernel_sizes" + }, + { + "kind": "IdRef", + "name": "search_window_sizes" + }, + { + "kind": "IdRef", + "name": "input_strides" + }, + { + "kind": "IdRef", + "name": "window_strides" + }, + { + "kind": "IdRef", + "name": "window_offsets" + }, + { + "kind": "IdRef", + "name": "padding" + }, + { + "kind": "IdRef", + "name": "search_pattern" + }, + { + "kind": "IdRef", + "name": "input0" + }, + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "MIN_SAD_COST", + "opcode": 1, + "operands": [ + { + "kind": "IdRef", + "name": "kernel_sizes" + }, + { + "kind": "IdRef", + "name": "search_window_sizes" + }, + { + "kind": "IdRef", + "name": "input_strides" + }, + { + "kind": "IdRef", + "name": "window_strides" + }, + { + "kind": "IdRef", + "name": "window_offsets" + }, + { + "kind": "IdRef", + "name": "padding" + }, + { + "kind": "IdRef", + "name": "search_pattern" + }, + { + "kind": "IdRef", + "name": "input0" + }, + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "RAW_SAD", + "opcode": 2, + "operands": [ + { + "kind": "IdRef", + "name": "kernel_sizes" + }, + { + "kind": "IdRef", + "name": "search_window_sizes" + }, + { + "kind": "IdRef", + "name": "input_strides" + }, + { + "kind": "IdRef", + "name": "window_strides" + }, + { + "kind": "IdRef", + "name": "window_offsets" + }, + { + "kind": "IdRef", + "name": "padding" + }, + { + "kind": "IdRef", + "name": "input0" + }, + { + "kind": "IdRef", + "name": "input1" + } + ] + } + ], + "operand_kinds": [] +} diff --git a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/extinst.opencl.std.100.grammar.json b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/extinst.opencl.std.100.grammar.json index 79394dd..0b335af 100644 --- a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/extinst.opencl.std.100.grammar.json +++ b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/extinst.opencl.std.100.grammar.json @@ -708,6 +708,130 @@ { "kind" : "IdRef", "name" : "x" } ] }, + { + "opname" : "fclamp", + "opcode" : 95, + "operands" : [ + { "kind" : "IdRef", "name" : "x" }, + { "kind" : "IdRef", "name" : "minval" }, + { "kind" : "IdRef", "name" : "maxval" } + ] + }, + { + "opname" : "degrees", + "opcode" :96, + "operands" : [ + { "kind" : "IdRef", "name" : "radians" } + ] + }, + { + "opname" : "fmax_common", + "opcode" : 97, + "operands" : [ + { "kind" : "IdRef", "name" : "x" }, + { "kind" : "IdRef", "name" : "y" } + ] + }, + { + "opname" : "fmin_common", + "opcode" : 98, + "operands" : [ + { "kind" : "IdRef", "name" : "x" }, + { "kind" : "IdRef", "name" : "y" } + ] + }, + { + "opname" : "mix", + "opcode" : 99, + "operands" : [ + { "kind" : "IdRef", "name" : "x" }, + { "kind" : "IdRef", "name" : "y" }, + { "kind" : "IdRef", "name" : "a" } + ] + }, + { + "opname" : "radians", + "opcode" : 100, + "operands" : [ + { "kind" : "IdRef", "name" : "degrees" } + ] + }, + { + "opname" : "step", + "opcode" : 101, + "operands" : [ + { "kind" : "IdRef", "name" : "edge" }, + { "kind" : "IdRef", "name" : "x" } + ] + }, + { + "opname" : "smoothstep", + "opcode" : 102, + "operands" : [ + { "kind" : "IdRef", "name" : "edge0" }, + { "kind" : "IdRef", "name" : "edge1" }, + { "kind" : "IdRef", "name" : "x" } + ] + }, + { + "opname" : "sign", + "opcode" : 103, + "operands" : [ + { "kind" : "IdRef", "name" : "x" } + ] + }, + { + "opname" : "cross", + "opcode" : 104, + "operands" : [ + { "kind" : "IdRef", "name" : "p0" }, + { "kind" : "IdRef", "name" : "p1" } + ] + }, + { + "opname" : "distance", + "opcode" : 105, + "operands" : [ + { "kind" : "IdRef", "name" : "p0" }, + { "kind" : "IdRef", "name" : "p1" } + ] + }, + { + "opname" : "length", + "opcode" : 106, + "operands" : [ + { "kind" : "IdRef", "name" : "p" } + ] + }, + { + "opname" : "normalize", + "opcode" : 107, + "operands" : [ + { "kind" : "IdRef", "name" : "p" } + ] + }, + { + "opname" : "fast_distance", + "opcode" : 108, + "operands" : [ + { "kind" : "IdRef", "name" : "p0" }, + { "kind" : "IdRef", "name" : "p1" } + ] + }, + { + "opname" : "fast_length", + "opcode" : 109, + "operands" : [ + { "kind" : "IdRef", "name" : "p" } + ] + }, + { + "opname" : "fast_normalize", + "opcode" : 110, + "operands" : [ + { "kind" : "IdRef", "name" : "p" } + ] + }, { "opname" : "s_abs", "opcode" : 141, @@ -951,180 +1075,6 @@ { "kind" : "IdRef", "name" : "y" } ] }, - { - "opname" : "u_abs", - "opcode" : 201, - "operands" : [ - { "kind" : "IdRef", "name" : "x" } - ] - }, - { - "opname" : "u_abs_diff", - "opcode" : 202, - "operands" : [ - { "kind" : "IdRef", "name" : "x" }, - { "kind" : "IdRef", "name" : "y" } - ] - }, - { - "opname" : "u_mul_hi", - "opcode" : 203, - "operands" : [ - { "kind" : "IdRef", "name" : "x" }, - { "kind" : "IdRef", "name" : "y" } - ] - }, - { - "opname" : "u_mad_hi", - "opcode" : 204, - "operands" : [ - { "kind" : "IdRef", "name" : "a" }, - { "kind" : "IdRef", "name" : "b" }, - { "kind" : "IdRef", "name" : "c" } - ] - }, - { - "opname" : "fclamp", - "opcode" : 95, - "operands" : [ - { "kind" : "IdRef", "name" : "x" }, - { "kind" : "IdRef", "name" : "minval" }, - { "kind" : "IdRef", "name" : "maxval" } - ] - }, - { - "opname" : "degrees", - "opcode" :96, - "operands" : [ - { "kind" : "IdRef", "name" : "radians" } - ] - }, - { - "opname" : "fmax_common", - "opcode" : 97, - "operands" : [ - { "kind" : "IdRef", "name" : "x" }, - { "kind" : "IdRef", "name" : "y" } - ] - }, - { - "opname" : "fmin_common", - "opcode" : 98, - "operands" : [ - { "kind" : "IdRef", "name" : "x" }, - { "kind" : "IdRef", "name" : "y" } - ] - }, - { - "opname" : "mix", - "opcode" : 99, - "operands" : [ - { "kind" : "IdRef", "name" : "x" }, - { "kind" : "IdRef", "name" : "y" }, - { "kind" : "IdRef", "name" : "a" } - ] - }, - { - "opname" : "radians", - "opcode" : 100, - "operands" : [ - { "kind" : "IdRef", "name" : "degrees" } - ] - }, - { - "opname" : "step", - "opcode" : 101, - "operands" : [ - { "kind" : "IdRef", "name" : "edge" }, - { "kind" : "IdRef", "name" : "x" } - ] - }, - { - "opname" : "smoothstep", - "opcode" : 102, - "operands" : [ - { "kind" : "IdRef", "name" : "edge0" }, - { "kind" : "IdRef", "name" : "edge1" }, - { "kind" : "IdRef", "name" : "x" } - ] - }, - { - "opname" : "sign", - "opcode" : 103, - "operands" : [ - { "kind" : "IdRef", "name" : "x" } - ] - }, - { - "opname" : "cross", - "opcode" : 104, - "operands" : [ - { "kind" : "IdRef", "name" : "p0" }, - { "kind" : "IdRef", "name" : "p1" } - ] - }, - { - "opname" : "distance", - "opcode" : 105, - "operands" : [ - { "kind" : "IdRef", "name" : "p0" }, - { "kind" : "IdRef", "name" : "p1" } - ] - }, - { - "opname" : "length", - "opcode" : 106, - "operands" : [ - { "kind" : "IdRef", "name" : "p" } - ] - }, - { - "opname" : "normalize", - "opcode" : 107, - "operands" : [ - { "kind" : "IdRef", "name" : "p" } - ] - }, - { - "opname" : "fast_distance", - "opcode" : 108, - "operands" : [ - { "kind" : "IdRef", "name" : "p0" }, - { "kind" : "IdRef", "name" : "p1" } - ] - }, - { - "opname" : "fast_length", - "opcode" : 109, - "operands" : [ - { "kind" : "IdRef", "name" : "p" } - ] - }, - { - "opname" : "fast_normalize", - "opcode" : 110, - "operands" : [ - { "kind" : "IdRef", "name" : "p" } - ] - }, - { - "opname" : "bitselect", - "opcode" : 186, - "operands" : [ - { "kind" : "IdRef", "name" : "a" }, - { "kind" : "IdRef", "name" : "b" }, - { "kind" : "IdRef", "name" : "c" } - ] - }, - { - "opname" : "select", - "opcode" : 187, - "operands" : [ - { "kind" : "IdRef", "name" : "a" }, - { "kind" : "IdRef", "name" : "b" }, - { "kind" : "IdRef", "name" : "c" } - ] - }, { "opname" : "vloadn", "opcode" : 171, @@ -1258,6 +1208,56 @@ { "kind" : "IdRef", "name" : "ptr" }, { "kind" : "IdRef", "name" : "num elements" } ] + }, + { + "opname" : "bitselect", + "opcode" : 186, + "operands" : [ + { "kind" : "IdRef", "name" : "a" }, + { "kind" : "IdRef", "name" : "b" }, + { "kind" : "IdRef", "name" : "c" } + ] + }, + { + "opname" : "select", + "opcode" : 187, + "operands" : [ + { "kind" : "IdRef", "name" : "a" }, + { "kind" : "IdRef", "name" : "b" }, + { "kind" : "IdRef", "name" : "c" } + ] + }, + { + "opname" : "u_abs", + "opcode" : 201, + "operands" : [ + { "kind" : "IdRef", "name" : "x" } + ] + }, + { + "opname" : "u_abs_diff", + "opcode" : 202, + "operands" : [ + { "kind" : "IdRef", "name" : "x" }, + { "kind" : "IdRef", "name" : "y" } + ] + }, + { + "opname" : "u_mul_hi", + "opcode" : 203, + "operands" : [ + { "kind" : "IdRef", "name" : "x" }, + { "kind" : "IdRef", "name" : "y" } + ] + }, + { + "opname" : "u_mad_hi", + "opcode" : 204, + "operands" : [ + { "kind" : "IdRef", "name" : "a" }, + { "kind" : "IdRef", "name" : "b" }, + { "kind" : "IdRef", "name" : "c" } + ] } ] } diff --git a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/extinst.tosa.001000.1.grammar.json b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/extinst.tosa.001000.1.grammar.json new file mode 100644 index 0000000..cabab82 --- /dev/null +++ b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/extinst.tosa.001000.1.grammar.json @@ -0,0 +1,1144 @@ +{ + "copyright": [ + "SPDX-FileCopyrightText: 2022-2025 Arm Ltd.", + "SPDX-License-Identifier: MIT" + ], + "version": 1000000, + "revision": 1, + "instructions": [ + { + "opname": "ARGMAX", + "opcode": 0, + "operands": [ + { + "kind": "IdRef", + "name": "axis" + }, + { + "kind": "IdRef", + "name": "nan_mode" + }, + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "AVG_POOL2D", + "opcode": 1, + "operands": [ + { + "kind": "IdRef", + "name": "kernel" + }, + { + "kind": "IdRef", + "name": "stride" + }, + { + "kind": "IdRef", + "name": "pad" + }, + { + "kind": "IdRef", + "name": "acc_type" + }, + { + "kind": "IdRef", + "name": "input" + }, + { + "kind": "IdRef", + "name": "input_zp" + }, + { + "kind": "IdRef", + "name": "output_zp" + } + ] + }, + { + "opname": "CONV2D", + "opcode": 2, + "operands": [ + { + "kind": "IdRef", + "name": "pad" + }, + { + "kind": "IdRef", + "name": "stride" + }, + { + "kind": "IdRef", + "name": "dilation" + }, + { + "kind": "IdRef", + "name": "acc_type" + }, + { + "kind": "IdRef", + "name": "local_bound" + }, + { + "kind": "IdRef", + "name": "input" + }, + { + "kind": "IdRef", + "name": "weight" + }, + { + "kind": "IdRef", + "name": "bias" + }, + { + "kind": "IdRef", + "name": "input_zp" + }, + { + "kind": "IdRef", + "name": "weight_zp" + } + ] + }, + { + "opname": "CONV3D", + "opcode": 3, + "operands": [ + { + "kind": "IdRef", + "name": "pad" + }, + { + "kind": "IdRef", + "name": "stride" + }, + { + "kind": "IdRef", + "name": "dilation" + }, + { + "kind": "IdRef", + "name": "acc_type" + }, + { + "kind": "IdRef", + "name": "local_bound" + }, + { + "kind": "IdRef", + "name": "input" + }, + { + "kind": "IdRef", + "name": "weight" + }, + { + "kind": "IdRef", + "name": "bias" + }, + { + "kind": "IdRef", + "name": "input_zp" + }, + { + "kind": "IdRef", + "name": "weight_zp" + } + ] + }, + { + "opname": "DEPTHWISE_CONV2D", + "opcode": 4, + "operands": [ + { + "kind": "IdRef", + "name": "pad" + }, + { + "kind": "IdRef", + "name": "stride" + }, + { + "kind": "IdRef", + "name": "dilation" + }, + { + "kind": "IdRef", + "name": "acc_type" + }, + { + "kind": "IdRef", + "name": "local_bound" + }, + { + "kind": "IdRef", + "name": "input" + }, + { + "kind": "IdRef", + "name": "weight" + }, + { + "kind": "IdRef", + "name": "bias" + }, + { + "kind": "IdRef", + "name": "input_zp" + }, + { + "kind": "IdRef", + "name": "weight_zp" + } + ] + }, + { + "opname": "FFT2D", + "opcode": 5, + "operands": [ + { + "kind": "IdRef", + "name": "inverse" + }, + { + "kind": "IdRef", + "name": "local_bound" + }, + { + "kind": "IdRef", + "name": "input_real" + }, + { + "kind": "IdRef", + "name": "input_imag" + } + ] + }, + { + "opname": "MATMUL", + "opcode": 6, + "operands": [ + { + "kind": "IdRef", + "name": "A" + }, + { + "kind": "IdRef", + "name": "B" + }, + { + "kind": "IdRef", + "name": "A_zp" + }, + { + "kind": "IdRef", + "name": "B_zp" + } + ] + }, + { + "opname": "MAX_POOL2D", + "opcode": 7, + "operands": [ + { + "kind": "IdRef", + "name": "kernel" + }, + { + "kind": "IdRef", + "name": "stride" + }, + { + "kind": "IdRef", + "name": "pad" + }, + { + "kind": "IdRef", + "name": "nan_mode" + }, + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "RFFT2D", + "opcode": 8, + "operands": [ + { + "kind": "IdRef", + "name": "local_bound" + }, + { + "kind": "IdRef", + "name": "input_real" + } + ] + }, + { + "opname": "TRANSPOSE_CONV2D", + "opcode": 9, + "operands": [ + { + "kind": "IdRef", + "name": "out_pad" + }, + { + "kind": "IdRef", + "name": "stride" + }, + { + "kind": "IdRef", + "name": "acc_type" + }, + { + "kind": "IdRef", + "name": "local_bound" + }, + { + "kind": "IdRef", + "name": "input" + }, + { + "kind": "IdRef", + "name": "weight" + }, + { + "kind": "IdRef", + "name": "bias" + }, + { + "kind": "IdRef", + "name": "input_zp" + }, + { + "kind": "IdRef", + "name": "weight_zp" + } + ] + }, + { + "opname": "CLAMP", + "opcode": 10, + "operands": [ + { + "kind": "IdRef", + "name": "min_val" + }, + { + "kind": "IdRef", + "name": "max_val" + }, + { + "kind": "IdRef", + "name": "nan_mode" + }, + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "ERF", + "opcode": 11, + "operands": [ + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "SIGMOID", + "opcode": 12, + "operands": [ + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "TANH", + "opcode": 13, + "operands": [ + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "ADD", + "opcode": 14, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "ARITHMETIC_RIGHT_SHIFT", + "opcode": 15, + "operands": [ + { + "kind": "IdRef", + "name": "round" + }, + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "BITWISE_AND", + "opcode": 16, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "BITWISE_OR", + "opcode": 17, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "BITWISE_XOR", + "opcode": 18, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "INTDIV", + "opcode": 19, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "LOGICAL_AND", + "opcode": 20, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "LOGICAL_LEFT_SHIFT", + "opcode": 21, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "LOGICAL_RIGHT_SHIFT", + "opcode": 22, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "LOGICAL_OR", + "opcode": 23, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "LOGICAL_XOR", + "opcode": 24, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "MAXIMUM", + "opcode": 25, + "operands": [ + { + "kind": "IdRef", + "name": "nan_mode" + }, + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "MINIMUM", + "opcode": 26, + "operands": [ + { + "kind": "IdRef", + "name": "nan_mode" + }, + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "MUL", + "opcode": 27, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + }, + { + "kind": "IdRef", + "name": "shift" + } + ] + }, + { + "opname": "POW", + "opcode": 28, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "SUB", + "opcode": 29, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "TABLE", + "opcode": 30, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "table" + } + ] + }, + { + "opname": "ABS", + "opcode": 31, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "BITWISE_NOT", + "opcode": 32, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "CEIL", + "opcode": 33, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "CLZ", + "opcode": 34, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "COS", + "opcode": 35, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "EXP", + "opcode": 36, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "FLOOR", + "opcode": 37, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "LOG", + "opcode": 38, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "LOGICAL_NOT", + "opcode": 39, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "NEGATE", + "opcode": 40, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input1_zp" + }, + { + "kind": "IdRef", + "name": "output_zp" + } + ] + }, + { + "opname": "RECIPROCAL", + "opcode": 41, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "RSQRT", + "opcode": 42, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "SIN", + "opcode": 43, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "SELECT", + "opcode": 44, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + }, + { + "kind": "IdRef", + "name": "input3" + } + ] + }, + { + "opname": "EQUAL", + "opcode": 45, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "GREATER", + "opcode": 46, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "GREATER_EQUAL", + "opcode": 47, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "input2" + } + ] + }, + { + "opname": "REDUCE_ALL", + "opcode": 48, + "operands": [ + { + "kind": "IdRef", + "name": "axis" + }, + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "REDUCE_ANY", + "opcode": 49, + "operands": [ + { + "kind": "IdRef", + "name": "axis" + }, + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "REDUCE_MAX", + "opcode": 50, + "operands": [ + { + "kind": "IdRef", + "name": "axis" + }, + { + "kind": "IdRef", + "name": "nan_mode" + }, + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "REDUCE_MIN", + "opcode": 51, + "operands": [ + { + "kind": "IdRef", + "name": "axis" + }, + { + "kind": "IdRef", + "name": "nan_mode" + }, + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "REDUCE_PRODUCT", + "opcode": 52, + "operands": [ + { + "kind": "IdRef", + "name": "axis" + }, + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "REDUCE_SUM", + "opcode": 53, + "operands": [ + { + "kind": "IdRef", + "name": "axis" + }, + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "CONCAT", + "opcode": 54, + "operands": [ + { + "kind": "IdRef", + "name": "axis" + }, + { + "kind": "IdRef", + "name": "input1", + "quantifier": "*" + } + ] + }, + { + "opname": "PAD", + "opcode": 55, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "padding" + }, + { + "kind": "IdRef", + "name": "pad_const" + } + ] + }, + { + "opname": "RESHAPE", + "opcode": 56, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "shape" + } + ] + }, + { + "opname": "REVERSE", + "opcode": 57, + "operands": [ + { + "kind": "IdRef", + "name": "axis" + }, + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "SLICE", + "opcode": 58, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "start" + }, + { + "kind": "IdRef", + "name": "size" + } + ] + }, + { + "opname": "TILE", + "opcode": 59, + "operands": [ + { + "kind": "IdRef", + "name": "input1" + }, + { + "kind": "IdRef", + "name": "multiples" + } + ] + }, + { + "opname": "TRANSPOSE", + "opcode": 60, + "operands": [ + { + "kind": "IdRef", + "name": "perms" + }, + { + "kind": "IdRef", + "name": "input1" + } + ] + }, + { + "opname": "GATHER", + "opcode": 61, + "operands": [ + { + "kind": "IdRef", + "name": "values" + }, + { + "kind": "IdRef", + "name": "indices" + } + ] + }, + { + "opname": "SCATTER", + "opcode": 62, + "operands": [ + { + "kind": "IdRef", + "name": "values_in" + }, + { + "kind": "IdRef", + "name": "indices" + }, + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "RESIZE", + "opcode": 63, + "operands": [ + { + "kind": "IdRef", + "name": "mode" + }, + { + "kind": "IdRef", + "name": "input" + }, + { + "kind": "IdRef", + "name": "scale" + }, + { + "kind": "IdRef", + "name": "offset" + }, + { + "kind": "IdRef", + "name": "border" + } + ] + }, + { + "opname": "CAST", + "opcode": 64, + "operands": [ + { + "kind": "IdRef", + "name": "input" + } + ] + }, + { + "opname": "RESCALE", + "opcode": 65, + "operands": [ + { + "kind": "IdRef", + "name": "scale32" + }, + { + "kind": "IdRef", + "name": "rounding_mode" + }, + { + "kind": "IdRef", + "name": "per_channel" + }, + { + "kind": "IdRef", + "name": "input_unsigned" + }, + { + "kind": "IdRef", + "name": "output_unsigned" + }, + { + "kind": "IdRef", + "name": "input" + }, + { + "kind": "IdRef", + "name": "multiplier" + }, + { + "kind": "IdRef", + "name": "shift" + }, + { + "kind": "IdRef", + "name": "input_zp" + }, + { + "kind": "IdRef", + "name": "output_zp" + } + ] + } + ], + "operand_kinds": [] +} diff --git a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.core.grammar.json b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.core.grammar.json index b7df252..1c3ed72 100644 --- a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.core.grammar.json +++ b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.core.grammar.json @@ -116,6 +116,10 @@ "tag" : "Tensor", "heading" : "Tensor Instructions" }, + { + "tag" : "Graph", + "heading" : "Graph Instructions" + }, { "tag" : "Reserved", "heading" : "Reserved Instructions" @@ -1355,6 +1359,7 @@ { "kind" : "IdResult" }, { "kind" : "IdRef", "name" : "Value" } ], + "capabilities" : [ "Shader" ], "version": "1.0" }, { @@ -3914,7 +3919,7 @@ { "kind" : "IdResult" }, { "kind" : "IdScope", "name" : "Execution" }, { "kind" : "IdRef", "name" : "Value" }, - { "kind" : "IdRef", "name" : "Id" } + { "kind" : "IdRef", "name" : "Invocation Id" } ], "capabilities" : [ "GroupNonUniformBallot" ], "version" : "1.3" @@ -4021,7 +4026,7 @@ { "kind" : "IdResult" }, { "kind" : "IdScope", "name" : "Execution" }, { "kind" : "IdRef", "name" : "Value" }, - { "kind" : "IdRef", "name" : "Id" } + { "kind" : "IdRef", "name" : "Invocation Id" } ], "capabilities" : [ "GroupNonUniformShuffle" ], "version" : "1.3" @@ -4474,6 +4479,85 @@ "capabilities" : [ "TensorsARM" ], "version" : "None" }, + { + "opname" : "OpGraphConstantARM", + "class" : "Graph", + "opcode" : 4181, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "LiteralInteger", "name" : "GraphConstantID" } + ], + "capabilities" : [ "GraphARM" ], + "version" : "None" + }, + { + "opname" : "OpGraphEntryPointARM", + "class" : "Graph", + "opcode" : 4182, + "operands" : [ + { "kind" : "IdRef", "name" : "Graph" }, + { "kind" : "LiteralString", "name" : "Name" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "Interface" } + ], + "capabilities" : [ "GraphARM" ], + "version" : "None" + }, + { + "opname" : "OpGraphARM", + "class" : "Graph", + "opcode" : 4183, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ], + "capabilities" : [ "GraphARM" ], + "version" : "None" + }, + { + "opname" : "OpGraphInputARM", + "class" : "Graph", + "opcode" : 4184, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "InputIndex" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "ElementIndex" } + ], + "capabilities" : [ "GraphARM" ], + "version" : "None" + }, + { + "opname" : "OpGraphSetOutputARM", + "class" : "Graph", + "opcode" : 4185, + "operands" : [ + { "kind" : "IdRef", "name": "Value" }, + { "kind" : "IdRef", "name" : "OutputIndex" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "ElementIndex" } + ], + "capabilities" : [ "GraphARM" ], + "version" : "None" + }, + { + "opname" : "OpGraphEndARM", + "class" : "Graph", + "opcode" : 4186, + "capabilities" : [ "GraphARM" ], + "version" : "None" + }, + { + "opname" : "OpTypeGraphARM", + "class" : "Type-Declaration", + "opcode" : 4190, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "LiteralInteger", "name" : "NumInputs" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "InOutTypes" } + ], + "capabilities" : [ "GraphARM" ], + "version" : "None" + }, { "opname" : "OpTerminateInvocation", "class" : "Control-Flow", @@ -4491,7 +4575,6 @@ "capabilities" : [ "UntypedPointersKHR" ], - "provisional" : true, "version" : "None", "operands" : [ { "kind" : "IdResult" }, @@ -4503,7 +4586,6 @@ "class" : "Memory", "opcode" : 4418, "capabilities" : [ "UntypedPointersKHR" ], - "provisional" : true, "version" : "None", "operands" : [ { "kind" : "IdResultType" }, @@ -4518,7 +4600,6 @@ "class" : "Memory", "opcode" : 4419, "capabilities" : [ "UntypedPointersKHR" ], - "provisional" : true, "version" : "None", "operands" : [ { "kind" : "IdResultType" }, @@ -4533,7 +4614,6 @@ "class" : "Memory", "opcode" : 4420, "capabilities" : [ "UntypedPointersKHR" ], - "provisional" : true, "version" : "None", "operands" : [ { "kind" : "IdResultType" }, @@ -4574,7 +4654,6 @@ "class" : "Memory", "opcode" : 4423, "capabilities" : [ "UntypedPointersKHR" ], - "provisional" : true, "version" : "None", "operands" : [ { "kind" : "IdResultType" }, @@ -4590,7 +4669,6 @@ "class" : "Memory", "opcode" : 4424, "capabilities" : [ "UntypedPointersKHR" ], - "provisional" : true, "version" : "None", "operands" : [ { "kind" : "IdResultType" }, @@ -4606,7 +4684,6 @@ "class" : "Memory", "opcode" : 4425, "capabilities" : [ "UntypedPointersKHR" ], - "provisional" : true, "version" : "None", "operands" : [ { "kind" : "IdResultType" }, @@ -4621,7 +4698,6 @@ "class" : "Memory", "opcode" : 4426, "capabilities" : [ "UntypedPointersKHR" ], - "provisional" : true, "version" : "None", "operands" : [ { "kind" : "IdRef", "name" : "Pointer Type" }, @@ -4631,6 +4707,20 @@ { "kind" : "IdRef", "quantifier" : "?", "name" : "Cache Type" } ] }, + { + "opname" : "OpFmaKHR", + "class" : "Arithmetic", + "opcode" : 4427, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "Operand 1" }, + { "kind" : "IdRef", "name" : "Operand 2" }, + { "kind" : "IdRef", "name" : "Operand 3" } + ], + "capabilities" : [ "FMAKHR" ], + "version" : "None" + }, { "opname" : "OpSubgroupAllKHR", "class" : "Group", @@ -4719,6 +4809,26 @@ "extensions" : [ "SPV_KHR_relaxed_extended_instruction" ], "version": "None" }, + { + "opname" : "OpUntypedGroupAsyncCopyKHR", + "class" : "Group", + "opcode" : 4434, + "capabilities" : [ "UntypedPointersKHR" ], + "version" : "None", + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "Execution" }, + { "kind" : "IdRef", "name" : "Destination" }, + { "kind" : "IdRef", "name" : "Source" }, + { "kind" : "IdRef", "name" : "Element Num Bytes" }, + { "kind" : "IdRef", "name" : "Num Elements" }, + { "kind" : "IdRef", "name" : "Stride" }, + { "kind" : "IdRef", "name" : "Event" }, + { "kind" : "MemoryAccess", "quantifier" : "?", "name" : "Destination Memory Operands" }, + { "kind" : "MemoryAccess", "quantifier" : "?", "name" : "Source Memory Operands" } + ] + }, { "opname" : "OpTraceRayKHR", "class" : "Reserved", @@ -5185,6 +5295,18 @@ "capabilities" : [ "TextureBlockMatchQCOM" ], "version" : "None" }, + { + "opname" : "OpBitCastArrayQCOM", + "class" : "Conversion", + "opcode" : 4497, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "Source Array" } + ], + "capabilities" : [ "CooperativeMatrixConversionQCOM" ], + "version" : "None" + }, { "opname" : "OpImageBlockMatchWindowSSDQCOM", "class" : "Image", @@ -5249,6 +5371,43 @@ "capabilities" : [ "TextureBlockMatch2QCOM" ], "version" : "None" }, + { + "opname" : "OpCompositeConstructCoopMatQCOM", + "class" : "Composite", + "opcode" : 4540, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "Source Array" } + ], + "capabilities" : [ "CooperativeMatrixConversionQCOM" ], + "version" : "None" + }, + { + "opname" : "OpCompositeExtractCoopMatQCOM", + "class" : "Composite", + "opcode" : 4541, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "Source Cooperative Matrix" } + ], + "capabilities" : [ "CooperativeMatrixConversionQCOM" ], + "version" : "None" + }, + { + "opname" : "OpExtractSubArrayQCOM", + "class" : "Composite", + "opcode" : 4542, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "Source Array" }, + { "kind" : "IdRef", "name" : "index" } + ], + "capabilities" : [ "CooperativeMatrixConversionQCOM" ], + "version" : "None" + }, { "opname" : "OpGroupIAddNonUniformAMD", "class" : "Group", @@ -6359,8 +6518,9 @@ "version" : "None" }, { - "opname" : "OpRayQueryGetClusterIdNV", + "opname" : "OpRayQueryGetIntersectionClusterIdNV", "class" : "Reserved", + "aliases" : ["OpRayQueryGetClusterIdNV"], "opcode" : 5345, "operands" : [ { "kind" : "IdResultType" }, @@ -8093,7 +8253,7 @@ { "kind" : "IdResult" }, { "kind" : "IdRef", "name" : "Fwd Ref Offset" }, { "kind" : "IdRef", "name" : "Bwd Ref Offset" }, - { "kind" : "IdRef", "name" : "id> Search Window Config" }, + { "kind" : "IdRef", "name" : "Search Window Config" }, { "kind" : "IdRef", "name" : "Payload" } ], "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], @@ -9010,19 +9170,19 @@ }, { "opname" : "OpVariableLengthArrayINTEL", - "class" : "@exclude", + "class" : "Memory", "opcode" : 5818, "operands" : [ { "kind" : "IdResultType" }, { "kind" : "IdResult" }, - { "kind" : "IdRef", "name" : "Lenght" } + { "kind" : "IdRef", "name" : "Length" } ], "capabilities" : [ "VariableLengthArrayINTEL" ], "version" : "None" }, { "opname" : "OpSaveMemoryINTEL", - "class" : "@exclude", + "class" : "Memory", "opcode" : 5819, "operands" : [ { "kind" : "IdResultType" }, @@ -9033,7 +9193,7 @@ }, { "opname" : "OpRestoreMemoryINTEL", - "class" : "@exclude", + "class" : "Memory", "opcode" : 5820, "operands" : [ { "kind" : "IdRef", "name" : "Ptr" } @@ -10694,6 +10854,114 @@ "capabilities" : [ "TernaryBitwiseFunctionINTEL" ], "version" : "None" }, + { + "opname" : "OpUntypedVariableLengthArrayINTEL", + "class" : "Memory", + "opcode" : 6244, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "Element Type" }, + { "kind" : "IdRef", "name" : "Length" } + ], + "capabilities" : [ "UntypedVariableLengthArrayINTEL" ], + "version" : "None" + }, + { + "opname" : "OpConditionalExtensionINTEL", + "class" : "Extension", + "opcode" : 6248, + "operands" : [ + { "kind" : "IdRef", "name" : "Condition" }, + { "kind" : "LiteralString", "name" : "Name" } + ], + "capabilities" : [ "SpecConditionalINTEL" ], + "provisional" : true, + "version" : "None" + }, + { + "opname" : "OpConditionalEntryPointINTEL", + "class" : "Mode-Setting", + "opcode" : 6249, + "operands" : [ + { "kind" : "IdRef", "name" : "Condition" }, + { "kind" : "ExecutionModel" }, + { "kind" : "IdRef", "name" : "Entry Point" }, + { "kind" : "LiteralString", "name" : "Name" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "Interface" } + ], + "capabilities" : [ "SpecConditionalINTEL" ], + "provisional" : true, + "version" : "None" + }, + { + "opname" : "OpConditionalCapabilityINTEL", + "class" : "Mode-Setting", + "opcode" : 6250, + "operands" : [ + { "kind" : "IdRef", "name" : "Condition" }, + { "kind" : "Capability", "name" : "Capability" } + ], + "capabilities" : [ "SpecConditionalINTEL" ], + "provisional" : true, + "version" : "None" + }, + { + "opname" : "OpSpecConstantTargetINTEL", + "class" : "Constant-Creation", + "opcode" : 6251, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "LiteralInteger", "name" : "Target" }, + { "kind" : "LiteralInteger", "quantifier" : "*", "name" : "Features" } + ], + "capabilities" : [ "FunctionVariantsINTEL" ], + "provisional" : true, + "version": "None" + }, + { + "opname" : "OpSpecConstantArchitectureINTEL", + "class" : "Constant-Creation", + "opcode" : 6252, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "LiteralInteger", "name" : "Category" }, + { "kind" : "LiteralInteger", "name" : "Family" }, + { "kind" : "LiteralInteger", "name" : "Opcode" }, + { "kind" : "LiteralInteger", "name" : "Architecture" } + ], + "capabilities" : [ "FunctionVariantsINTEL" ], + "provisional" : true, + "version": "None" + }, + { + "opname" : "OpSpecConstantCapabilitiesINTEL", + "class" : "Constant-Creation", + "opcode" : 6253, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "Capability", "quantifier" : "*", "name" : "Capabilities" } + ], + "capabilities" : [ "FunctionVariantsINTEL" ], + "provisional" : true, + "version": "None" + }, + { + "opname" : "OpConditionalCopyObjectINTEL", + "class" : "Composite", + "opcode" : 6254, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "Condition 0, Operand 0, +\nCondition 1, Operand 1, +\n..." } + ], + "capabilities" : [ "SpecConditionalINTEL" ], + "provisional" : true, + "version" : "None" + }, { "opname" : "OpGroupIMulKHR", "class" : "Group", @@ -12408,7 +12676,7 @@ "enumerant" : "DerivativeGroupQuadsKHR", "aliases" : ["DerivativeGroupQuadsNV"], "value" : 5289, - "capabilities" : [ "ComputeDerivativeGroupQuadsNV", "ComputeDerivativeGroupQuadsKHR" ], + "capabilities" : [ "ComputeDerivativeGroupQuadsKHR" ], "extensions" : [ "SPV_NV_compute_shader_derivatives", "SPV_KHR_compute_shader_derivatives" ], "version" : "None" }, @@ -12416,7 +12684,7 @@ "enumerant" : "DerivativeGroupLinearKHR", "aliases" : ["DerivativeGroupLinearNV"], "value" : 5290, - "capabilities" : [ "ComputeDerivativeGroupLinearNV", "ComputeDerivativeGroupLinearKHR" ], + "capabilities" : [ "ComputeDerivativeGroupLinearKHR" ], "extensions" : [ "SPV_NV_compute_shader_derivatives", "SPV_KHR_compute_shader_derivatives" ], "version" : "None" }, @@ -14817,6 +15085,16 @@ "capabilities" : [ "GlobalVariableFPGADecorationsINTEL" ], "version" : "None" }, + { + "enumerant" : "ConditionalINTEL", + "value" : 6247, + "parameters": [ + { "kind" : "IdRef", "name" : "Condition" } + ], + "capabilities" : [ "SpecConditionalINTEL" ], + "provisional" : true, + "version" : "None" + }, { "enumerant" : "CacheControlLoadINTEL", "value" : 6442, @@ -16252,6 +16530,12 @@ "extensions" : [ "SPV_ARM_tensors"], "version" : "None" }, + { + "enumerant" : "GraphARM", + "value" : 4191, + "extensions" : [ "SPV_ARM_graph"], + "version" : "None" + }, { "enumerant" : "CooperativeMatrixLayoutsARM", "value" : 4201, @@ -16267,6 +16551,7 @@ { "enumerant" : "Float8CooperativeMatrixEXT", "value" : 4213, + "capabilities" : [ "Float8EXT", "CooperativeMatrixKHR" ], "extensions" : [ "SPV_EXT_float8"], "version" : "None" }, @@ -16451,7 +16736,6 @@ "enumerant" : "UntypedPointersKHR", "value" : 4473, "extensions" : [ "SPV_KHR_untyped_pointers" ], - "provisional" : true, "version" : "None" }, { @@ -16493,6 +16777,13 @@ "extensions" : [ "SPV_QCOM_tile_shading" ], "version" : "None" }, + { + "enumerant" : "CooperativeMatrixConversionQCOM", + "value" : 4496, + "capabilities" : [ "CooperativeMatrixKHR" ], + "extensions" : [ "SPV_QCOM_cooperative_matrix_conversion" ], + "version" : "None" + }, { "enumerant" : "TextureBlockMatch2QCOM", "value" : 4498, @@ -17330,6 +17621,12 @@ "extensions" : [ "SPV_KHR_float_controls2" ], "version" : "None" }, + { + "enumerant" : "FMAKHR", + "value" : 6030, + "extensions" : [ "SPV_KHR_fma" ], + "version" : "None" + }, { "enumerant" : "AtomicFloat32AddEXT", "value" : 6033, @@ -17473,6 +17770,28 @@ "extensions" : [ "SPV_INTEL_ternary_bitwise_function"], "version" : "None" }, + { + "enumerant" : "UntypedVariableLengthArrayINTEL", + "value" : 6243, + "capabilities" : [ "VariableLengthArrayINTEL", "UntypedPointersKHR" ], + "extensions" : [ "SPV_INTEL_variable_length_array" ], + "version" : "None" + }, + { + "enumerant" : "SpecConditionalINTEL", + "value" : 6245, + "extensions" : [ "SPV_INTEL_function_variants" ], + "provisional" : true, + "version": "None" + }, + { + "enumerant" : "FunctionVariantsINTEL", + "value" : 6246, + "capabilities" : [ "SpecConditionalINTEL" ], + "extensions" : [ "SPV_INTEL_function_variants" ], + "provisional" : true, + "version": "None" + }, { "enumerant" : "GroupUniformArithmeticKHR", "value" : 6400, diff --git a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.h b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.h index 4128040..26bc6d9 100644 --- a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.h +++ b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.h @@ -642,6 +642,7 @@ typedef enum SpvDecoration_ { SpvDecorationHostAccessINTEL = 6188, SpvDecorationInitModeINTEL = 6190, SpvDecorationImplementInRegisterMapINTEL = 6191, + SpvDecorationConditionalINTEL = 6247, SpvDecorationCacheControlLoadINTEL = 6442, SpvDecorationCacheControlStoreINTEL = 6443, SpvDecorationMax = 0x7fffffff, @@ -1067,6 +1068,7 @@ typedef enum SpvCapability_ { SpvCapabilityTensorsARM = 4174, SpvCapabilityStorageTensorArrayDynamicIndexingARM = 4175, SpvCapabilityStorageTensorArrayNonUniformIndexingARM = 4176, + SpvCapabilityGraphARM = 4191, SpvCapabilityCooperativeMatrixLayoutsARM = 4201, SpvCapabilityFloat8EXT = 4212, SpvCapabilityFloat8CooperativeMatrixEXT = 4213, @@ -1106,6 +1108,7 @@ typedef enum SpvCapability_ { SpvCapabilityTextureBoxFilterQCOM = 4485, SpvCapabilityTextureBlockMatchQCOM = 4486, SpvCapabilityTileShadingQCOM = 4495, + SpvCapabilityCooperativeMatrixConversionQCOM = 4496, SpvCapabilityTextureBlockMatch2QCOM = 4498, SpvCapabilityFloat16ImageAMD = 5008, SpvCapabilityImageGatherBiasLodAMD = 5009, @@ -1257,6 +1260,7 @@ typedef enum SpvCapability_ { SpvCapabilityBitInstructions = 6025, SpvCapabilityGroupNonUniformRotateKHR = 6026, SpvCapabilityFloatControls2 = 6029, + SpvCapabilityFMAKHR = 6030, SpvCapabilityAtomicFloat32AddEXT = 6033, SpvCapabilityAtomicFloat64AddEXT = 6034, SpvCapabilityLongCompositesINTEL = 6089, @@ -1281,6 +1285,9 @@ typedef enum SpvCapability_ { SpvCapabilitySubgroup2DBlockTransposeINTEL = 6230, SpvCapabilitySubgroupMatrixMultiplyAccumulateINTEL = 6236, SpvCapabilityTernaryBitwiseFunctionINTEL = 6241, + SpvCapabilityUntypedVariableLengthArrayINTEL = 6243, + SpvCapabilitySpecConditionalINTEL = 6245, + SpvCapabilityFunctionVariantsINTEL = 6246, SpvCapabilityGroupUniformArithmeticKHR = 6400, SpvCapabilityTensorFloat32RoundingINTEL = 6425, SpvCapabilityMaskedGatherScatterINTEL = 6427, @@ -1951,6 +1958,13 @@ typedef enum SpvOp_ { SpvOpTensorReadARM = 4164, SpvOpTensorWriteARM = 4165, SpvOpTensorQuerySizeARM = 4166, + SpvOpGraphConstantARM = 4181, + SpvOpGraphEntryPointARM = 4182, + SpvOpGraphARM = 4183, + SpvOpGraphInputARM = 4184, + SpvOpGraphSetOutputARM = 4185, + SpvOpGraphEndARM = 4186, + SpvOpTypeGraphARM = 4190, SpvOpTerminateInvocation = 4416, SpvOpTypeUntypedPointerKHR = 4417, SpvOpUntypedVariableKHR = 4418, @@ -1962,12 +1976,14 @@ typedef enum SpvOp_ { SpvOpUntypedInBoundsPtrAccessChainKHR = 4424, SpvOpUntypedArrayLengthKHR = 4425, SpvOpUntypedPrefetchKHR = 4426, + SpvOpFmaKHR = 4427, SpvOpSubgroupAllKHR = 4428, SpvOpSubgroupAnyKHR = 4429, SpvOpSubgroupAllEqualKHR = 4430, SpvOpGroupNonUniformRotateKHR = 4431, SpvOpSubgroupReadInvocationKHR = 4432, SpvOpExtInstWithForwardRefsKHR = 4433, + SpvOpUntypedGroupAsyncCopyKHR = 4434, SpvOpTraceRayKHR = 4445, SpvOpExecuteCallableKHR = 4446, SpvOpConvertUToAccelerationStructureKHR = 4447, @@ -2004,10 +2020,14 @@ typedef enum SpvOp_ { SpvOpImageBoxFilterQCOM = 4481, SpvOpImageBlockMatchSSDQCOM = 4482, SpvOpImageBlockMatchSADQCOM = 4483, + SpvOpBitCastArrayQCOM = 4497, SpvOpImageBlockMatchWindowSSDQCOM = 4500, SpvOpImageBlockMatchWindowSADQCOM = 4501, SpvOpImageBlockMatchGatherSSDQCOM = 4502, SpvOpImageBlockMatchGatherSADQCOM = 4503, + SpvOpCompositeConstructCoopMatQCOM = 4540, + SpvOpCompositeExtractCoopMatQCOM = 4541, + SpvOpExtractSubArrayQCOM = 4542, SpvOpGroupIAddNonUniformAMD = 5000, SpvOpGroupFAddNonUniformAMD = 5001, SpvOpGroupFMinNonUniformAMD = 5002, @@ -2089,6 +2109,7 @@ typedef enum SpvOp_ { SpvOpTypeAccelerationStructureNV = 5341, SpvOpExecuteCallableNV = 5344, SpvOpRayQueryGetClusterIdNV = 5345, + SpvOpRayQueryGetIntersectionClusterIdNV = 5345, SpvOpHitObjectGetClusterIdNV = 5346, SpvOpTypeCooperativeMatrixNV = 5358, SpvOpCooperativeMatrixLoadNV = 5359, @@ -2398,6 +2419,14 @@ typedef enum SpvOp_ { SpvOpSubgroup2DBlockStoreINTEL = 6235, SpvOpSubgroupMatrixMultiplyAccumulateINTEL = 6237, SpvOpBitwiseFunctionINTEL = 6242, + SpvOpUntypedVariableLengthArrayINTEL = 6244, + SpvOpConditionalExtensionINTEL = 6248, + SpvOpConditionalEntryPointINTEL = 6249, + SpvOpConditionalCapabilityINTEL = 6250, + SpvOpSpecConstantTargetINTEL = 6251, + SpvOpSpecConstantArchitectureINTEL = 6252, + SpvOpSpecConstantCapabilitiesINTEL = 6253, + SpvOpConditionalCopyObjectINTEL = 6254, SpvOpGroupIMulKHR = 6401, SpvOpGroupFMulKHR = 6402, SpvOpGroupBitwiseAndKHR = 6403, @@ -2774,6 +2803,13 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy case SpvOpTensorReadARM: *hasResult = true; *hasResultType = true; break; case SpvOpTensorWriteARM: *hasResult = false; *hasResultType = false; break; case SpvOpTensorQuerySizeARM: *hasResult = true; *hasResultType = true; break; + case SpvOpGraphConstantARM: *hasResult = true; *hasResultType = true; break; + case SpvOpGraphEntryPointARM: *hasResult = false; *hasResultType = false; break; + case SpvOpGraphARM: *hasResult = true; *hasResultType = true; break; + case SpvOpGraphInputARM: *hasResult = true; *hasResultType = true; break; + case SpvOpGraphSetOutputARM: *hasResult = false; *hasResultType = false; break; + case SpvOpGraphEndARM: *hasResult = false; *hasResultType = false; break; + case SpvOpTypeGraphARM: *hasResult = true; *hasResultType = false; break; case SpvOpTerminateInvocation: *hasResult = false; *hasResultType = false; break; case SpvOpTypeUntypedPointerKHR: *hasResult = true; *hasResultType = false; break; case SpvOpUntypedVariableKHR: *hasResult = true; *hasResultType = true; break; @@ -2785,12 +2821,14 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy case SpvOpUntypedInBoundsPtrAccessChainKHR: *hasResult = true; *hasResultType = true; break; case SpvOpUntypedArrayLengthKHR: *hasResult = true; *hasResultType = true; break; case SpvOpUntypedPrefetchKHR: *hasResult = false; *hasResultType = false; break; + case SpvOpFmaKHR: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; case SpvOpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break; case SpvOpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; case SpvOpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpUntypedGroupAsyncCopyKHR: *hasResult = true; *hasResultType = true; break; case SpvOpTraceRayKHR: *hasResult = false; *hasResultType = false; break; case SpvOpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break; case SpvOpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break; @@ -2821,10 +2859,14 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy case SpvOpImageBoxFilterQCOM: *hasResult = true; *hasResultType = true; break; case SpvOpImageBlockMatchSSDQCOM: *hasResult = true; *hasResultType = true; break; case SpvOpImageBlockMatchSADQCOM: *hasResult = true; *hasResultType = true; break; + case SpvOpBitCastArrayQCOM: *hasResult = true; *hasResultType = true; break; case SpvOpImageBlockMatchWindowSSDQCOM: *hasResult = true; *hasResultType = true; break; case SpvOpImageBlockMatchWindowSADQCOM: *hasResult = true; *hasResultType = true; break; case SpvOpImageBlockMatchGatherSSDQCOM: *hasResult = true; *hasResultType = true; break; case SpvOpImageBlockMatchGatherSADQCOM: *hasResult = true; *hasResultType = true; break; + case SpvOpCompositeConstructCoopMatQCOM: *hasResult = true; *hasResultType = true; break; + case SpvOpCompositeExtractCoopMatQCOM: *hasResult = true; *hasResultType = true; break; + case SpvOpExtractSubArrayQCOM: *hasResult = true; *hasResultType = true; break; case SpvOpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; case SpvOpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; case SpvOpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; @@ -2903,7 +2945,7 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy case SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break; case SpvOpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break; case SpvOpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; - case SpvOpRayQueryGetClusterIdNV: *hasResult = true; *hasResultType = true; break; + case SpvOpRayQueryGetIntersectionClusterIdNV: *hasResult = true; *hasResultType = true; break; case SpvOpHitObjectGetClusterIdNV: *hasResult = true; *hasResultType = true; break; case SpvOpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; case SpvOpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; @@ -3210,6 +3252,14 @@ inline void SpvHasResultAndType(SpvOp opcode, bool *hasResult, bool *hasResultTy case SpvOpSubgroup2DBlockStoreINTEL: *hasResult = false; *hasResultType = false; break; case SpvOpSubgroupMatrixMultiplyAccumulateINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpBitwiseFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpUntypedVariableLengthArrayINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpConditionalExtensionINTEL: *hasResult = false; *hasResultType = false; break; + case SpvOpConditionalEntryPointINTEL: *hasResult = false; *hasResultType = false; break; + case SpvOpConditionalCapabilityINTEL: *hasResult = false; *hasResultType = false; break; + case SpvOpSpecConstantTargetINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSpecConstantArchitectureINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpSpecConstantCapabilitiesINTEL: *hasResult = true; *hasResultType = true; break; + case SpvOpConditionalCopyObjectINTEL: *hasResult = true; *hasResultType = true; break; case SpvOpGroupIMulKHR: *hasResult = true; *hasResultType = true; break; case SpvOpGroupFMulKHR: *hasResult = true; *hasResultType = true; break; case SpvOpGroupBitwiseAndKHR: *hasResult = true; *hasResultType = true; break; @@ -3750,6 +3800,7 @@ inline const char* SpvDecorationToString(SpvDecoration value) { case SpvDecorationHostAccessINTEL: return "HostAccessINTEL"; case SpvDecorationInitModeINTEL: return "InitModeINTEL"; case SpvDecorationImplementInRegisterMapINTEL: return "ImplementInRegisterMapINTEL"; + case SpvDecorationConditionalINTEL: return "ConditionalINTEL"; case SpvDecorationCacheControlLoadINTEL: return "CacheControlLoadINTEL"; case SpvDecorationCacheControlStoreINTEL: return "CacheControlStoreINTEL"; default: return "Unknown"; @@ -4002,6 +4053,7 @@ inline const char* SpvCapabilityToString(SpvCapability value) { case SpvCapabilityTensorsARM: return "TensorsARM"; case SpvCapabilityStorageTensorArrayDynamicIndexingARM: return "StorageTensorArrayDynamicIndexingARM"; case SpvCapabilityStorageTensorArrayNonUniformIndexingARM: return "StorageTensorArrayNonUniformIndexingARM"; + case SpvCapabilityGraphARM: return "GraphARM"; case SpvCapabilityCooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM"; case SpvCapabilityFloat8EXT: return "Float8EXT"; case SpvCapabilityFloat8CooperativeMatrixEXT: return "Float8CooperativeMatrixEXT"; @@ -4039,6 +4091,7 @@ inline const char* SpvCapabilityToString(SpvCapability value) { case SpvCapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM"; case SpvCapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM"; case SpvCapabilityTileShadingQCOM: return "TileShadingQCOM"; + case SpvCapabilityCooperativeMatrixConversionQCOM: return "CooperativeMatrixConversionQCOM"; case SpvCapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM"; case SpvCapabilityFloat16ImageAMD: return "Float16ImageAMD"; case SpvCapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; @@ -4165,6 +4218,7 @@ inline const char* SpvCapabilityToString(SpvCapability value) { case SpvCapabilityBitInstructions: return "BitInstructions"; case SpvCapabilityGroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR"; case SpvCapabilityFloatControls2: return "FloatControls2"; + case SpvCapabilityFMAKHR: return "FMAKHR"; case SpvCapabilityAtomicFloat32AddEXT: return "AtomicFloat32AddEXT"; case SpvCapabilityAtomicFloat64AddEXT: return "AtomicFloat64AddEXT"; case SpvCapabilityLongCompositesINTEL: return "LongCompositesINTEL"; @@ -4188,6 +4242,9 @@ inline const char* SpvCapabilityToString(SpvCapability value) { case SpvCapabilitySubgroup2DBlockTransposeINTEL: return "Subgroup2DBlockTransposeINTEL"; case SpvCapabilitySubgroupMatrixMultiplyAccumulateINTEL: return "SubgroupMatrixMultiplyAccumulateINTEL"; case SpvCapabilityTernaryBitwiseFunctionINTEL: return "TernaryBitwiseFunctionINTEL"; + case SpvCapabilityUntypedVariableLengthArrayINTEL: return "UntypedVariableLengthArrayINTEL"; + case SpvCapabilitySpecConditionalINTEL: return "SpecConditionalINTEL"; + case SpvCapabilityFunctionVariantsINTEL: return "FunctionVariantsINTEL"; case SpvCapabilityGroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR"; case SpvCapabilityTensorFloat32RoundingINTEL: return "TensorFloat32RoundingINTEL"; case SpvCapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL"; @@ -4739,6 +4796,13 @@ inline const char* SpvOpToString(SpvOp value) { case SpvOpTensorReadARM: return "OpTensorReadARM"; case SpvOpTensorWriteARM: return "OpTensorWriteARM"; case SpvOpTensorQuerySizeARM: return "OpTensorQuerySizeARM"; + case SpvOpGraphConstantARM: return "OpGraphConstantARM"; + case SpvOpGraphEntryPointARM: return "OpGraphEntryPointARM"; + case SpvOpGraphARM: return "OpGraphARM"; + case SpvOpGraphInputARM: return "OpGraphInputARM"; + case SpvOpGraphSetOutputARM: return "OpGraphSetOutputARM"; + case SpvOpGraphEndARM: return "OpGraphEndARM"; + case SpvOpTypeGraphARM: return "OpTypeGraphARM"; case SpvOpTerminateInvocation: return "OpTerminateInvocation"; case SpvOpTypeUntypedPointerKHR: return "OpTypeUntypedPointerKHR"; case SpvOpUntypedVariableKHR: return "OpUntypedVariableKHR"; @@ -4750,12 +4814,14 @@ inline const char* SpvOpToString(SpvOp value) { case SpvOpUntypedInBoundsPtrAccessChainKHR: return "OpUntypedInBoundsPtrAccessChainKHR"; case SpvOpUntypedArrayLengthKHR: return "OpUntypedArrayLengthKHR"; case SpvOpUntypedPrefetchKHR: return "OpUntypedPrefetchKHR"; + case SpvOpFmaKHR: return "OpFmaKHR"; case SpvOpSubgroupAllKHR: return "OpSubgroupAllKHR"; case SpvOpSubgroupAnyKHR: return "OpSubgroupAnyKHR"; case SpvOpSubgroupAllEqualKHR: return "OpSubgroupAllEqualKHR"; case SpvOpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR"; case SpvOpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR"; case SpvOpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR"; + case SpvOpUntypedGroupAsyncCopyKHR: return "OpUntypedGroupAsyncCopyKHR"; case SpvOpTraceRayKHR: return "OpTraceRayKHR"; case SpvOpExecuteCallableKHR: return "OpExecuteCallableKHR"; case SpvOpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR"; @@ -4786,10 +4852,14 @@ inline const char* SpvOpToString(SpvOp value) { case SpvOpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM"; case SpvOpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM"; case SpvOpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM"; + case SpvOpBitCastArrayQCOM: return "OpBitCastArrayQCOM"; case SpvOpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM"; case SpvOpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM"; case SpvOpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM"; case SpvOpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM"; + case SpvOpCompositeConstructCoopMatQCOM: return "OpCompositeConstructCoopMatQCOM"; + case SpvOpCompositeExtractCoopMatQCOM: return "OpCompositeExtractCoopMatQCOM"; + case SpvOpExtractSubArrayQCOM: return "OpExtractSubArrayQCOM"; case SpvOpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD"; case SpvOpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD"; case SpvOpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD"; @@ -5175,6 +5245,14 @@ inline const char* SpvOpToString(SpvOp value) { case SpvOpSubgroup2DBlockStoreINTEL: return "OpSubgroup2DBlockStoreINTEL"; case SpvOpSubgroupMatrixMultiplyAccumulateINTEL: return "OpSubgroupMatrixMultiplyAccumulateINTEL"; case SpvOpBitwiseFunctionINTEL: return "OpBitwiseFunctionINTEL"; + case SpvOpUntypedVariableLengthArrayINTEL: return "OpUntypedVariableLengthArrayINTEL"; + case SpvOpConditionalExtensionINTEL: return "OpConditionalExtensionINTEL"; + case SpvOpConditionalEntryPointINTEL: return "OpConditionalEntryPointINTEL"; + case SpvOpConditionalCapabilityINTEL: return "OpConditionalCapabilityINTEL"; + case SpvOpSpecConstantTargetINTEL: return "OpSpecConstantTargetINTEL"; + case SpvOpSpecConstantArchitectureINTEL: return "OpSpecConstantArchitectureINTEL"; + case SpvOpSpecConstantCapabilitiesINTEL: return "OpSpecConstantCapabilitiesINTEL"; + case SpvOpConditionalCopyObjectINTEL: return "OpConditionalCopyObjectINTEL"; case SpvOpGroupIMulKHR: return "OpGroupIMulKHR"; case SpvOpGroupFMulKHR: return "OpGroupFMulKHR"; case SpvOpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR"; diff --git a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.hpp11 b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.hpp11 index f77374a..0a342aa 100644 --- a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.hpp11 +++ b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.hpp11 @@ -638,6 +638,7 @@ enum class Decoration : unsigned { HostAccessINTEL = 6188, InitModeINTEL = 6190, ImplementInRegisterMapINTEL = 6191, + ConditionalINTEL = 6247, CacheControlLoadINTEL = 6442, CacheControlStoreINTEL = 6443, Max = 0x7fffffff, @@ -1063,6 +1064,7 @@ enum class Capability : unsigned { TensorsARM = 4174, StorageTensorArrayDynamicIndexingARM = 4175, StorageTensorArrayNonUniformIndexingARM = 4176, + GraphARM = 4191, CooperativeMatrixLayoutsARM = 4201, Float8EXT = 4212, Float8CooperativeMatrixEXT = 4213, @@ -1102,6 +1104,7 @@ enum class Capability : unsigned { TextureBoxFilterQCOM = 4485, TextureBlockMatchQCOM = 4486, TileShadingQCOM = 4495, + CooperativeMatrixConversionQCOM = 4496, TextureBlockMatch2QCOM = 4498, Float16ImageAMD = 5008, ImageGatherBiasLodAMD = 5009, @@ -1253,6 +1256,7 @@ enum class Capability : unsigned { BitInstructions = 6025, GroupNonUniformRotateKHR = 6026, FloatControls2 = 6029, + FMAKHR = 6030, AtomicFloat32AddEXT = 6033, AtomicFloat64AddEXT = 6034, LongCompositesINTEL = 6089, @@ -1277,6 +1281,9 @@ enum class Capability : unsigned { Subgroup2DBlockTransposeINTEL = 6230, SubgroupMatrixMultiplyAccumulateINTEL = 6236, TernaryBitwiseFunctionINTEL = 6241, + UntypedVariableLengthArrayINTEL = 6243, + SpecConditionalINTEL = 6245, + FunctionVariantsINTEL = 6246, GroupUniformArithmeticKHR = 6400, TensorFloat32RoundingINTEL = 6425, MaskedGatherScatterINTEL = 6427, @@ -1947,6 +1954,13 @@ enum class Op : unsigned { OpTensorReadARM = 4164, OpTensorWriteARM = 4165, OpTensorQuerySizeARM = 4166, + OpGraphConstantARM = 4181, + OpGraphEntryPointARM = 4182, + OpGraphARM = 4183, + OpGraphInputARM = 4184, + OpGraphSetOutputARM = 4185, + OpGraphEndARM = 4186, + OpTypeGraphARM = 4190, OpTerminateInvocation = 4416, OpTypeUntypedPointerKHR = 4417, OpUntypedVariableKHR = 4418, @@ -1958,12 +1972,14 @@ enum class Op : unsigned { OpUntypedInBoundsPtrAccessChainKHR = 4424, OpUntypedArrayLengthKHR = 4425, OpUntypedPrefetchKHR = 4426, + OpFmaKHR = 4427, OpSubgroupAllKHR = 4428, OpSubgroupAnyKHR = 4429, OpSubgroupAllEqualKHR = 4430, OpGroupNonUniformRotateKHR = 4431, OpSubgroupReadInvocationKHR = 4432, OpExtInstWithForwardRefsKHR = 4433, + OpUntypedGroupAsyncCopyKHR = 4434, OpTraceRayKHR = 4445, OpExecuteCallableKHR = 4446, OpConvertUToAccelerationStructureKHR = 4447, @@ -2000,10 +2016,14 @@ enum class Op : unsigned { OpImageBoxFilterQCOM = 4481, OpImageBlockMatchSSDQCOM = 4482, OpImageBlockMatchSADQCOM = 4483, + OpBitCastArrayQCOM = 4497, OpImageBlockMatchWindowSSDQCOM = 4500, OpImageBlockMatchWindowSADQCOM = 4501, OpImageBlockMatchGatherSSDQCOM = 4502, OpImageBlockMatchGatherSADQCOM = 4503, + OpCompositeConstructCoopMatQCOM = 4540, + OpCompositeExtractCoopMatQCOM = 4541, + OpExtractSubArrayQCOM = 4542, OpGroupIAddNonUniformAMD = 5000, OpGroupFAddNonUniformAMD = 5001, OpGroupFMinNonUniformAMD = 5002, @@ -2085,6 +2105,7 @@ enum class Op : unsigned { OpTypeAccelerationStructureNV = 5341, OpExecuteCallableNV = 5344, OpRayQueryGetClusterIdNV = 5345, + OpRayQueryGetIntersectionClusterIdNV = 5345, OpHitObjectGetClusterIdNV = 5346, OpTypeCooperativeMatrixNV = 5358, OpCooperativeMatrixLoadNV = 5359, @@ -2394,6 +2415,14 @@ enum class Op : unsigned { OpSubgroup2DBlockStoreINTEL = 6235, OpSubgroupMatrixMultiplyAccumulateINTEL = 6237, OpBitwiseFunctionINTEL = 6242, + OpUntypedVariableLengthArrayINTEL = 6244, + OpConditionalExtensionINTEL = 6248, + OpConditionalEntryPointINTEL = 6249, + OpConditionalCapabilityINTEL = 6250, + OpSpecConstantTargetINTEL = 6251, + OpSpecConstantArchitectureINTEL = 6252, + OpSpecConstantCapabilitiesINTEL = 6253, + OpConditionalCopyObjectINTEL = 6254, OpGroupIMulKHR = 6401, OpGroupFMulKHR = 6402, OpGroupBitwiseAndKHR = 6403, @@ -2770,6 +2799,13 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case Op::OpTensorReadARM: *hasResult = true; *hasResultType = true; break; case Op::OpTensorWriteARM: *hasResult = false; *hasResultType = false; break; case Op::OpTensorQuerySizeARM: *hasResult = true; *hasResultType = true; break; + case Op::OpGraphConstantARM: *hasResult = true; *hasResultType = true; break; + case Op::OpGraphEntryPointARM: *hasResult = false; *hasResultType = false; break; + case Op::OpGraphARM: *hasResult = true; *hasResultType = true; break; + case Op::OpGraphInputARM: *hasResult = true; *hasResultType = true; break; + case Op::OpGraphSetOutputARM: *hasResult = false; *hasResultType = false; break; + case Op::OpGraphEndARM: *hasResult = false; *hasResultType = false; break; + case Op::OpTypeGraphARM: *hasResult = true; *hasResultType = false; break; case Op::OpTerminateInvocation: *hasResult = false; *hasResultType = false; break; case Op::OpTypeUntypedPointerKHR: *hasResult = true; *hasResultType = false; break; case Op::OpUntypedVariableKHR: *hasResult = true; *hasResultType = true; break; @@ -2781,12 +2817,14 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case Op::OpUntypedInBoundsPtrAccessChainKHR: *hasResult = true; *hasResultType = true; break; case Op::OpUntypedArrayLengthKHR: *hasResult = true; *hasResultType = true; break; case Op::OpUntypedPrefetchKHR: *hasResult = false; *hasResultType = false; break; + case Op::OpFmaKHR: *hasResult = true; *hasResultType = true; break; case Op::OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break; case Op::OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break; case Op::OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; case Op::OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break; case Op::OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; case Op::OpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break; + case Op::OpUntypedGroupAsyncCopyKHR: *hasResult = true; *hasResultType = true; break; case Op::OpTraceRayKHR: *hasResult = false; *hasResultType = false; break; case Op::OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break; case Op::OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break; @@ -2817,10 +2855,14 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case Op::OpImageBoxFilterQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpImageBlockMatchSSDQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpImageBlockMatchSADQCOM: *hasResult = true; *hasResultType = true; break; + case Op::OpBitCastArrayQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpImageBlockMatchWindowSSDQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpImageBlockMatchWindowSADQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpImageBlockMatchGatherSSDQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpImageBlockMatchGatherSADQCOM: *hasResult = true; *hasResultType = true; break; + case Op::OpCompositeConstructCoopMatQCOM: *hasResult = true; *hasResultType = true; break; + case Op::OpCompositeExtractCoopMatQCOM: *hasResult = true; *hasResultType = true; break; + case Op::OpExtractSubArrayQCOM: *hasResult = true; *hasResultType = true; break; case Op::OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; case Op::OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; case Op::OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; @@ -2899,7 +2941,7 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break; case Op::OpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break; case Op::OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; - case Op::OpRayQueryGetClusterIdNV: *hasResult = true; *hasResultType = true; break; + case Op::OpRayQueryGetIntersectionClusterIdNV: *hasResult = true; *hasResultType = true; break; case Op::OpHitObjectGetClusterIdNV: *hasResult = true; *hasResultType = true; break; case Op::OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; case Op::OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; @@ -3206,6 +3248,14 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { case Op::OpSubgroup2DBlockStoreINTEL: *hasResult = false; *hasResultType = false; break; case Op::OpSubgroupMatrixMultiplyAccumulateINTEL: *hasResult = true; *hasResultType = true; break; case Op::OpBitwiseFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case Op::OpUntypedVariableLengthArrayINTEL: *hasResult = true; *hasResultType = true; break; + case Op::OpConditionalExtensionINTEL: *hasResult = false; *hasResultType = false; break; + case Op::OpConditionalEntryPointINTEL: *hasResult = false; *hasResultType = false; break; + case Op::OpConditionalCapabilityINTEL: *hasResult = false; *hasResultType = false; break; + case Op::OpSpecConstantTargetINTEL: *hasResult = true; *hasResultType = true; break; + case Op::OpSpecConstantArchitectureINTEL: *hasResult = true; *hasResultType = true; break; + case Op::OpSpecConstantCapabilitiesINTEL: *hasResult = true; *hasResultType = true; break; + case Op::OpConditionalCopyObjectINTEL: *hasResult = true; *hasResultType = true; break; case Op::OpGroupIMulKHR: *hasResult = true; *hasResultType = true; break; case Op::OpGroupFMulKHR: *hasResult = true; *hasResultType = true; break; case Op::OpGroupBitwiseAndKHR: *hasResult = true; *hasResultType = true; break; @@ -3746,6 +3796,7 @@ inline const char* DecorationToString(Decoration value) { case Decoration::HostAccessINTEL: return "HostAccessINTEL"; case Decoration::InitModeINTEL: return "InitModeINTEL"; case Decoration::ImplementInRegisterMapINTEL: return "ImplementInRegisterMapINTEL"; + case Decoration::ConditionalINTEL: return "ConditionalINTEL"; case Decoration::CacheControlLoadINTEL: return "CacheControlLoadINTEL"; case Decoration::CacheControlStoreINTEL: return "CacheControlStoreINTEL"; default: return "Unknown"; @@ -3998,6 +4049,7 @@ inline const char* CapabilityToString(Capability value) { case Capability::TensorsARM: return "TensorsARM"; case Capability::StorageTensorArrayDynamicIndexingARM: return "StorageTensorArrayDynamicIndexingARM"; case Capability::StorageTensorArrayNonUniformIndexingARM: return "StorageTensorArrayNonUniformIndexingARM"; + case Capability::GraphARM: return "GraphARM"; case Capability::CooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM"; case Capability::Float8EXT: return "Float8EXT"; case Capability::Float8CooperativeMatrixEXT: return "Float8CooperativeMatrixEXT"; @@ -4035,6 +4087,7 @@ inline const char* CapabilityToString(Capability value) { case Capability::TextureBoxFilterQCOM: return "TextureBoxFilterQCOM"; case Capability::TextureBlockMatchQCOM: return "TextureBlockMatchQCOM"; case Capability::TileShadingQCOM: return "TileShadingQCOM"; + case Capability::CooperativeMatrixConversionQCOM: return "CooperativeMatrixConversionQCOM"; case Capability::TextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM"; case Capability::Float16ImageAMD: return "Float16ImageAMD"; case Capability::ImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; @@ -4161,6 +4214,7 @@ inline const char* CapabilityToString(Capability value) { case Capability::BitInstructions: return "BitInstructions"; case Capability::GroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR"; case Capability::FloatControls2: return "FloatControls2"; + case Capability::FMAKHR: return "FMAKHR"; case Capability::AtomicFloat32AddEXT: return "AtomicFloat32AddEXT"; case Capability::AtomicFloat64AddEXT: return "AtomicFloat64AddEXT"; case Capability::LongCompositesINTEL: return "LongCompositesINTEL"; @@ -4184,6 +4238,9 @@ inline const char* CapabilityToString(Capability value) { case Capability::Subgroup2DBlockTransposeINTEL: return "Subgroup2DBlockTransposeINTEL"; case Capability::SubgroupMatrixMultiplyAccumulateINTEL: return "SubgroupMatrixMultiplyAccumulateINTEL"; case Capability::TernaryBitwiseFunctionINTEL: return "TernaryBitwiseFunctionINTEL"; + case Capability::UntypedVariableLengthArrayINTEL: return "UntypedVariableLengthArrayINTEL"; + case Capability::SpecConditionalINTEL: return "SpecConditionalINTEL"; + case Capability::FunctionVariantsINTEL: return "FunctionVariantsINTEL"; case Capability::GroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR"; case Capability::TensorFloat32RoundingINTEL: return "TensorFloat32RoundingINTEL"; case Capability::MaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL"; @@ -4735,6 +4792,13 @@ inline const char* OpToString(Op value) { case Op::OpTensorReadARM: return "OpTensorReadARM"; case Op::OpTensorWriteARM: return "OpTensorWriteARM"; case Op::OpTensorQuerySizeARM: return "OpTensorQuerySizeARM"; + case Op::OpGraphConstantARM: return "OpGraphConstantARM"; + case Op::OpGraphEntryPointARM: return "OpGraphEntryPointARM"; + case Op::OpGraphARM: return "OpGraphARM"; + case Op::OpGraphInputARM: return "OpGraphInputARM"; + case Op::OpGraphSetOutputARM: return "OpGraphSetOutputARM"; + case Op::OpGraphEndARM: return "OpGraphEndARM"; + case Op::OpTypeGraphARM: return "OpTypeGraphARM"; case Op::OpTerminateInvocation: return "OpTerminateInvocation"; case Op::OpTypeUntypedPointerKHR: return "OpTypeUntypedPointerKHR"; case Op::OpUntypedVariableKHR: return "OpUntypedVariableKHR"; @@ -4746,12 +4810,14 @@ inline const char* OpToString(Op value) { case Op::OpUntypedInBoundsPtrAccessChainKHR: return "OpUntypedInBoundsPtrAccessChainKHR"; case Op::OpUntypedArrayLengthKHR: return "OpUntypedArrayLengthKHR"; case Op::OpUntypedPrefetchKHR: return "OpUntypedPrefetchKHR"; + case Op::OpFmaKHR: return "OpFmaKHR"; case Op::OpSubgroupAllKHR: return "OpSubgroupAllKHR"; case Op::OpSubgroupAnyKHR: return "OpSubgroupAnyKHR"; case Op::OpSubgroupAllEqualKHR: return "OpSubgroupAllEqualKHR"; case Op::OpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR"; case Op::OpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR"; case Op::OpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR"; + case Op::OpUntypedGroupAsyncCopyKHR: return "OpUntypedGroupAsyncCopyKHR"; case Op::OpTraceRayKHR: return "OpTraceRayKHR"; case Op::OpExecuteCallableKHR: return "OpExecuteCallableKHR"; case Op::OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR"; @@ -4782,10 +4848,14 @@ inline const char* OpToString(Op value) { case Op::OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM"; case Op::OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM"; case Op::OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM"; + case Op::OpBitCastArrayQCOM: return "OpBitCastArrayQCOM"; case Op::OpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM"; case Op::OpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM"; case Op::OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM"; case Op::OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM"; + case Op::OpCompositeConstructCoopMatQCOM: return "OpCompositeConstructCoopMatQCOM"; + case Op::OpCompositeExtractCoopMatQCOM: return "OpCompositeExtractCoopMatQCOM"; + case Op::OpExtractSubArrayQCOM: return "OpExtractSubArrayQCOM"; case Op::OpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD"; case Op::OpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD"; case Op::OpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD"; @@ -5171,6 +5241,14 @@ inline const char* OpToString(Op value) { case Op::OpSubgroup2DBlockStoreINTEL: return "OpSubgroup2DBlockStoreINTEL"; case Op::OpSubgroupMatrixMultiplyAccumulateINTEL: return "OpSubgroupMatrixMultiplyAccumulateINTEL"; case Op::OpBitwiseFunctionINTEL: return "OpBitwiseFunctionINTEL"; + case Op::OpUntypedVariableLengthArrayINTEL: return "OpUntypedVariableLengthArrayINTEL"; + case Op::OpConditionalExtensionINTEL: return "OpConditionalExtensionINTEL"; + case Op::OpConditionalEntryPointINTEL: return "OpConditionalEntryPointINTEL"; + case Op::OpConditionalCapabilityINTEL: return "OpConditionalCapabilityINTEL"; + case Op::OpSpecConstantTargetINTEL: return "OpSpecConstantTargetINTEL"; + case Op::OpSpecConstantArchitectureINTEL: return "OpSpecConstantArchitectureINTEL"; + case Op::OpSpecConstantCapabilitiesINTEL: return "OpSpecConstantCapabilitiesINTEL"; + case Op::OpConditionalCopyObjectINTEL: return "OpConditionalCopyObjectINTEL"; case Op::OpGroupIMulKHR: return "OpGroupIMulKHR"; case Op::OpGroupFMulKHR: return "OpGroupFMulKHR"; case Op::OpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR"; diff --git a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.json b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.json index db7ae25..4d53a16 100644 --- a/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.json +++ b/libs/bgfx/3rdparty/spirv-headers/include/spirv/unified1/spirv.json @@ -661,6 +661,7 @@ "HostAccessINTEL": 6188, "InitModeINTEL": 6190, "ImplementInRegisterMapINTEL": 6191, + "ConditionalINTEL": 6247, "CacheControlLoadINTEL": 6442, "CacheControlStoreINTEL": 6443 } @@ -1039,6 +1040,7 @@ "TensorsARM": 4174, "StorageTensorArrayDynamicIndexingARM": 4175, "StorageTensorArrayNonUniformIndexingARM": 4176, + "GraphARM": 4191, "CooperativeMatrixLayoutsARM": 4201, "Float8EXT": 4212, "Float8CooperativeMatrixEXT": 4213, @@ -1078,6 +1080,7 @@ "TextureBoxFilterQCOM": 4485, "TextureBlockMatchQCOM": 4486, "TileShadingQCOM": 4495, + "CooperativeMatrixConversionQCOM": 4496, "TextureBlockMatch2QCOM": 4498, "Float16ImageAMD": 5008, "ImageGatherBiasLodAMD": 5009, @@ -1229,6 +1232,7 @@ "BitInstructions": 6025, "GroupNonUniformRotateKHR": 6026, "FloatControls2": 6029, + "FMAKHR": 6030, "AtomicFloat32AddEXT": 6033, "AtomicFloat64AddEXT": 6034, "LongCompositesINTEL": 6089, @@ -1253,6 +1257,9 @@ "Subgroup2DBlockTransposeINTEL": 6230, "SubgroupMatrixMultiplyAccumulateINTEL": 6236, "TernaryBitwiseFunctionINTEL": 6241, + "UntypedVariableLengthArrayINTEL": 6243, + "SpecConditionalINTEL": 6245, + "FunctionVariantsINTEL": 6246, "GroupUniformArithmeticKHR": 6400, "TensorFloat32RoundingINTEL": 6425, "MaskedGatherScatterINTEL": 6427, @@ -1928,6 +1935,13 @@ "OpTensorReadARM": 4164, "OpTensorWriteARM": 4165, "OpTensorQuerySizeARM": 4166, + "OpGraphConstantARM": 4181, + "OpGraphEntryPointARM": 4182, + "OpGraphARM": 4183, + "OpGraphInputARM": 4184, + "OpGraphSetOutputARM": 4185, + "OpGraphEndARM": 4186, + "OpTypeGraphARM": 4190, "OpTerminateInvocation": 4416, "OpTypeUntypedPointerKHR": 4417, "OpUntypedVariableKHR": 4418, @@ -1939,12 +1953,14 @@ "OpUntypedInBoundsPtrAccessChainKHR": 4424, "OpUntypedArrayLengthKHR": 4425, "OpUntypedPrefetchKHR": 4426, + "OpFmaKHR": 4427, "OpSubgroupAllKHR": 4428, "OpSubgroupAnyKHR": 4429, "OpSubgroupAllEqualKHR": 4430, "OpGroupNonUniformRotateKHR": 4431, "OpSubgroupReadInvocationKHR": 4432, "OpExtInstWithForwardRefsKHR": 4433, + "OpUntypedGroupAsyncCopyKHR": 4434, "OpTraceRayKHR": 4445, "OpExecuteCallableKHR": 4446, "OpConvertUToAccelerationStructureKHR": 4447, @@ -1981,10 +1997,14 @@ "OpImageBoxFilterQCOM": 4481, "OpImageBlockMatchSSDQCOM": 4482, "OpImageBlockMatchSADQCOM": 4483, + "OpBitCastArrayQCOM": 4497, "OpImageBlockMatchWindowSSDQCOM": 4500, "OpImageBlockMatchWindowSADQCOM": 4501, "OpImageBlockMatchGatherSSDQCOM": 4502, "OpImageBlockMatchGatherSADQCOM": 4503, + "OpCompositeConstructCoopMatQCOM": 4540, + "OpCompositeExtractCoopMatQCOM": 4541, + "OpExtractSubArrayQCOM": 4542, "OpGroupIAddNonUniformAMD": 5000, "OpGroupFAddNonUniformAMD": 5001, "OpGroupFMinNonUniformAMD": 5002, @@ -2066,6 +2086,7 @@ "OpTypeAccelerationStructureNV": 5341, "OpExecuteCallableNV": 5344, "OpRayQueryGetClusterIdNV": 5345, + "OpRayQueryGetIntersectionClusterIdNV": 5345, "OpHitObjectGetClusterIdNV": 5346, "OpTypeCooperativeMatrixNV": 5358, "OpCooperativeMatrixLoadNV": 5359, @@ -2375,6 +2396,14 @@ "OpSubgroup2DBlockStoreINTEL": 6235, "OpSubgroupMatrixMultiplyAccumulateINTEL": 6237, "OpBitwiseFunctionINTEL": 6242, + "OpUntypedVariableLengthArrayINTEL": 6244, + "OpConditionalExtensionINTEL": 6248, + "OpConditionalEntryPointINTEL": 6249, + "OpConditionalCapabilityINTEL": 6250, + "OpSpecConstantTargetINTEL": 6251, + "OpSpecConstantArchitectureINTEL": 6252, + "OpSpecConstantCapabilitiesINTEL": 6253, + "OpConditionalCopyObjectINTEL": 6254, "OpGroupIMulKHR": 6401, "OpGroupFMulKHR": 6402, "OpGroupBitwiseAndKHR": 6403, diff --git a/libs/bgfx/3rdparty/spirv-tools/include/generated/build-version.inc b/libs/bgfx/3rdparty/spirv-tools/include/generated/build-version.inc index acbd6d5..4dbb088 100644 --- a/libs/bgfx/3rdparty/spirv-tools/include/generated/build-version.inc +++ b/libs/bgfx/3rdparty/spirv-tools/include/generated/build-version.inc @@ -1 +1 @@ -"v2025.2", "SPIRV-Tools v2025.2 v2025.2.rc2-58-g007a1f89" +"v2025.4", "SPIRV-Tools v2025.4 v2025.4-28-g8b4ee452" diff --git a/libs/bgfx/3rdparty/spirv-tools/include/generated/core_tables_body.inc b/libs/bgfx/3rdparty/spirv-tools/include/generated/core_tables_body.inc index 7de02d5..d19d225 100644 --- a/libs/bgfx/3rdparty/spirv-tools/include/generated/core_tables_body.inc +++ b/libs/bgfx/3rdparty/spirv-tools/include/generated/core_tables_body.inc @@ -15,149 +15,153 @@ IndexRange ExtensionToIndexRange(Extension extension) { case Extension::kSPV_AMD_texture_gather_bias_lod: return IR(337, 32); case Extension::kSPV_ARM_cooperative_matrix_layouts: return IR(369, 35); case Extension::kSPV_ARM_core_builtins: return IR(404, 22); - case Extension::kSPV_ARM_tensors: return IR(426, 16); - case Extension::kSPV_EXT_arithmetic_fence: return IR(442, 25); - case Extension::kSPV_EXT_demote_to_helper_invocation: return IR(467, 36); - case Extension::kSPV_EXT_descriptor_indexing: return IR(503, 28); - case Extension::kSPV_EXT_float8: return IR(531, 15); - case Extension::kSPV_EXT_fragment_fully_covered: return IR(546, 31); - case Extension::kSPV_EXT_fragment_invocation_density: return IR(577, 36); - case Extension::kSPV_EXT_fragment_shader_interlock: return IR(613, 34); - case Extension::kSPV_EXT_mesh_shader: return IR(647, 20); - case Extension::kSPV_EXT_opacity_micromap: return IR(667, 25); - case Extension::kSPV_EXT_optnone: return IR(692, 16); - case Extension::kSPV_EXT_physical_storage_buffer: return IR(708, 32); - case Extension::kSPV_EXT_relaxed_printf_string_address_space: return IR(740, 44); - case Extension::kSPV_EXT_replicated_composites: return IR(784, 30); - case Extension::kSPV_EXT_shader_atomic_float16_add: return IR(814, 34); - case Extension::kSPV_EXT_shader_atomic_float_add: return IR(848, 32); - case Extension::kSPV_EXT_shader_atomic_float_min_max: return IR(880, 36); - case Extension::kSPV_EXT_shader_image_int64: return IR(916, 27); - case Extension::kSPV_EXT_shader_stencil_export: return IR(943, 30); - case Extension::kSPV_EXT_shader_tile_image: return IR(973, 26); - case Extension::kSPV_EXT_shader_viewport_index_layer: return IR(999, 36); - case Extension::kSPV_GOOGLE_decorate_string: return IR(1035, 27); - case Extension::kSPV_GOOGLE_hlsl_functionality1: return IR(1062, 31); - case Extension::kSPV_GOOGLE_user_type: return IR(1093, 21); - case Extension::kSPV_INTEL_2d_block_io: return IR(1114, 22); - case Extension::kSPV_INTEL_arbitrary_precision_fixed_point: return IR(1136, 42); - case Extension::kSPV_INTEL_arbitrary_precision_floating_point: return IR(1178, 45); - case Extension::kSPV_INTEL_arbitrary_precision_integers: return IR(1223, 39); - case Extension::kSPV_INTEL_bfloat16_conversion: return IR(1262, 30); - case Extension::kSPV_INTEL_bindless_images: return IR(1292, 26); - case Extension::kSPV_INTEL_blocking_pipes: return IR(1318, 25); - case Extension::kSPV_INTEL_cache_controls: return IR(1343, 25); - case Extension::kSPV_INTEL_debug_module: return IR(1368, 23); - case Extension::kSPV_INTEL_device_side_avc_motion_estimation: return IR(1391, 44); - case Extension::kSPV_INTEL_float_controls2: return IR(1435, 26); - case Extension::kSPV_INTEL_fp_fast_math_mode: return IR(1461, 28); - case Extension::kSPV_INTEL_fp_max_error: return IR(1489, 23); - case Extension::kSPV_INTEL_fpga_argument_interfaces: return IR(1512, 35); - case Extension::kSPV_INTEL_fpga_buffer_location: return IR(1547, 31); - case Extension::kSPV_INTEL_fpga_cluster_attributes: return IR(1578, 34); - case Extension::kSPV_INTEL_fpga_dsp_control: return IR(1612, 27); - case Extension::kSPV_INTEL_fpga_invocation_pipelining_attributes: return IR(1639, 48); - case Extension::kSPV_INTEL_fpga_latency_control: return IR(1687, 31); - case Extension::kSPV_INTEL_fpga_loop_controls: return IR(1718, 29); - case Extension::kSPV_INTEL_fpga_memory_accesses: return IR(1747, 31); - case Extension::kSPV_INTEL_fpga_memory_attributes: return IR(1778, 33); - case Extension::kSPV_INTEL_fpga_reg: return IR(1811, 19); - case Extension::kSPV_INTEL_function_pointers: return IR(1830, 28); - case Extension::kSPV_INTEL_global_variable_fpga_decorations: return IR(1858, 43); - case Extension::kSPV_INTEL_global_variable_host_access: return IR(1901, 38); - case Extension::kSPV_INTEL_inline_assembly: return IR(1939, 26); - case Extension::kSPV_INTEL_int4: return IR(1965, 15); - case Extension::kSPV_INTEL_io_pipes: return IR(1980, 19); - case Extension::kSPV_INTEL_kernel_attributes: return IR(1999, 28); - case Extension::kSPV_INTEL_long_composites: return IR(2027, 26); - case Extension::kSPV_INTEL_loop_fuse: return IR(2053, 20); - case Extension::kSPV_INTEL_masked_gather_scatter: return IR(2073, 32); - case Extension::kSPV_INTEL_maximum_registers: return IR(2105, 28); - case Extension::kSPV_INTEL_media_block_io: return IR(2133, 25); - case Extension::kSPV_INTEL_memory_access_aliasing: return IR(2158, 33); - case Extension::kSPV_INTEL_optnone: return IR(2191, 18); - case Extension::kSPV_INTEL_runtime_aligned: return IR(2209, 26); - case Extension::kSPV_INTEL_shader_integer_functions2: return IR(2235, 36); - case Extension::kSPV_INTEL_split_barrier: return IR(2271, 24); - case Extension::kSPV_INTEL_subgroup_buffer_prefetch: return IR(2295, 35); - case Extension::kSPV_INTEL_subgroup_matrix_multiply_accumulate: return IR(2330, 46); - case Extension::kSPV_INTEL_subgroups: return IR(2376, 20); - case Extension::kSPV_INTEL_task_sequence: return IR(2396, 24); - case Extension::kSPV_INTEL_tensor_float32_conversion: return IR(2420, 36); - case Extension::kSPV_INTEL_ternary_bitwise_function: return IR(2456, 35); - case Extension::kSPV_INTEL_unstructured_loop_controls: return IR(2491, 37); - case Extension::kSPV_INTEL_usm_storage_classes: return IR(2528, 30); - case Extension::kSPV_INTEL_variable_length_array: return IR(2558, 32); - case Extension::kSPV_INTEL_vector_compute: return IR(2590, 25); - case Extension::kSPV_KHR_16bit_storage: return IR(2615, 22); - case Extension::kSPV_KHR_8bit_storage: return IR(2637, 21); - case Extension::kSPV_KHR_bfloat16: return IR(2658, 17); - case Extension::kSPV_KHR_bit_instructions: return IR(2675, 25); - case Extension::kSPV_KHR_compute_shader_derivatives: return IR(2700, 35); - case Extension::kSPV_KHR_cooperative_matrix: return IR(2735, 27); - case Extension::kSPV_KHR_device_group: return IR(2762, 21); - case Extension::kSPV_KHR_expect_assume: return IR(2783, 22); - case Extension::kSPV_KHR_float_controls: return IR(2805, 23); - case Extension::kSPV_KHR_float_controls2: return IR(2828, 24); - case Extension::kSPV_KHR_fragment_shader_barycentric: return IR(2852, 36); - case Extension::kSPV_KHR_fragment_shading_rate: return IR(2888, 30); - case Extension::kSPV_KHR_integer_dot_product: return IR(2918, 28); - case Extension::kSPV_KHR_linkonce_odr: return IR(2946, 21); - case Extension::kSPV_KHR_maximal_reconvergence: return IR(2967, 30); - case Extension::kSPV_KHR_multiview: return IR(2997, 18); - case Extension::kSPV_KHR_no_integer_wrap_decoration: return IR(3015, 35); - case Extension::kSPV_KHR_non_semantic_info: return IR(3050, 26); - case Extension::kSPV_KHR_physical_storage_buffer: return IR(3076, 32); - case Extension::kSPV_KHR_post_depth_coverage: return IR(3108, 28); - case Extension::kSPV_KHR_quad_control: return IR(3136, 21); - case Extension::kSPV_KHR_ray_cull_mask: return IR(3157, 22); - case Extension::kSPV_KHR_ray_query: return IR(3179, 18); - case Extension::kSPV_KHR_ray_tracing: return IR(3197, 20); - case Extension::kSPV_KHR_ray_tracing_position_fetch: return IR(3217, 35); - case Extension::kSPV_KHR_relaxed_extended_instruction: return IR(3252, 37); - case Extension::kSPV_KHR_shader_atomic_counter_ops: return IR(3289, 34); - case Extension::kSPV_KHR_shader_ballot: return IR(3323, 22); - case Extension::kSPV_KHR_shader_clock: return IR(3345, 21); - case Extension::kSPV_KHR_shader_draw_parameters: return IR(3366, 31); - case Extension::kSPV_KHR_storage_buffer_storage_class: return IR(3397, 37); - case Extension::kSPV_KHR_subgroup_rotate: return IR(3434, 24); - case Extension::kSPV_KHR_subgroup_uniform_control_flow: return IR(3458, 38); - case Extension::kSPV_KHR_subgroup_vote: return IR(3496, 22); - case Extension::kSPV_KHR_terminate_invocation: return IR(3518, 29); - case Extension::kSPV_KHR_uniform_group_instructions: return IR(3547, 35); - case Extension::kSPV_KHR_untyped_pointers: return IR(3582, 25); - case Extension::kSPV_KHR_variable_pointers: return IR(3607, 26); - case Extension::kSPV_KHR_vulkan_memory_model: return IR(3633, 28); - case Extension::kSPV_KHR_workgroup_memory_explicit_layout: return IR(3661, 41); - case Extension::kSPV_NVX_multiview_per_view_attributes: return IR(3702, 38); - case Extension::kSPV_NV_bindless_texture: return IR(3740, 24); - case Extension::kSPV_NV_cluster_acceleration_structure: return IR(3764, 38); - case Extension::kSPV_NV_compute_shader_derivatives: return IR(3802, 34); - case Extension::kSPV_NV_cooperative_matrix: return IR(3836, 26); - case Extension::kSPV_NV_cooperative_matrix2: return IR(3862, 27); - case Extension::kSPV_NV_cooperative_vector: return IR(3889, 26); - case Extension::kSPV_NV_displacement_micromap: return IR(3915, 29); - case Extension::kSPV_NV_fragment_shader_barycentric: return IR(3944, 35); - case Extension::kSPV_NV_geometry_shader_passthrough: return IR(3979, 35); - case Extension::kSPV_NV_linear_swept_spheres: return IR(4014, 28); - case Extension::kSPV_NV_mesh_shader: return IR(4042, 19); - case Extension::kSPV_NV_raw_access_chains: return IR(4061, 25); - case Extension::kSPV_NV_ray_tracing: return IR(4086, 19); - case Extension::kSPV_NV_ray_tracing_motion_blur: return IR(4105, 31); - case Extension::kSPV_NV_sample_mask_override_coverage: return IR(4136, 37); - case Extension::kSPV_NV_shader_atomic_fp16_vector: return IR(4173, 33); - case Extension::kSPV_NV_shader_image_footprint: return IR(4206, 30); - case Extension::kSPV_NV_shader_invocation_reorder: return IR(4236, 33); - case Extension::kSPV_NV_shader_sm_builtins: return IR(4269, 26); - case Extension::kSPV_NV_shader_subgroup_partitioned: return IR(4295, 35); - case Extension::kSPV_NV_shading_rate: return IR(4330, 20); - case Extension::kSPV_NV_stereo_view_rendering: return IR(4350, 29); - case Extension::kSPV_NV_tensor_addressing: return IR(4379, 25); - case Extension::kSPV_NV_viewport_array2: return IR(4404, 23); - case Extension::kSPV_QCOM_image_processing: return IR(4427, 26); - case Extension::kSPV_QCOM_image_processing2: return IR(4453, 27); - case Extension::kSPV_QCOM_tile_shading: return IR(4480, 22); - case Extension::kSPV_VALIDATOR_ignore_type_decl_unique: return IR(4502, 38); + case Extension::kSPV_ARM_graph: return IR(426, 14); + case Extension::kSPV_ARM_tensors: return IR(440, 16); + case Extension::kSPV_EXT_arithmetic_fence: return IR(456, 25); + case Extension::kSPV_EXT_demote_to_helper_invocation: return IR(481, 36); + case Extension::kSPV_EXT_descriptor_indexing: return IR(517, 28); + case Extension::kSPV_EXT_float8: return IR(545, 15); + case Extension::kSPV_EXT_fragment_fully_covered: return IR(560, 31); + case Extension::kSPV_EXT_fragment_invocation_density: return IR(591, 36); + case Extension::kSPV_EXT_fragment_shader_interlock: return IR(627, 34); + case Extension::kSPV_EXT_mesh_shader: return IR(661, 20); + case Extension::kSPV_EXT_opacity_micromap: return IR(681, 25); + case Extension::kSPV_EXT_optnone: return IR(706, 16); + case Extension::kSPV_EXT_physical_storage_buffer: return IR(722, 32); + case Extension::kSPV_EXT_relaxed_printf_string_address_space: return IR(754, 44); + case Extension::kSPV_EXT_replicated_composites: return IR(798, 30); + case Extension::kSPV_EXT_shader_atomic_float16_add: return IR(828, 34); + case Extension::kSPV_EXT_shader_atomic_float_add: return IR(862, 32); + case Extension::kSPV_EXT_shader_atomic_float_min_max: return IR(894, 36); + case Extension::kSPV_EXT_shader_image_int64: return IR(930, 27); + case Extension::kSPV_EXT_shader_stencil_export: return IR(957, 30); + case Extension::kSPV_EXT_shader_tile_image: return IR(987, 26); + case Extension::kSPV_EXT_shader_viewport_index_layer: return IR(1013, 36); + case Extension::kSPV_GOOGLE_decorate_string: return IR(1049, 27); + case Extension::kSPV_GOOGLE_hlsl_functionality1: return IR(1076, 31); + case Extension::kSPV_GOOGLE_user_type: return IR(1107, 21); + case Extension::kSPV_INTEL_2d_block_io: return IR(1128, 22); + case Extension::kSPV_INTEL_arbitrary_precision_fixed_point: return IR(1150, 42); + case Extension::kSPV_INTEL_arbitrary_precision_floating_point: return IR(1192, 45); + case Extension::kSPV_INTEL_arbitrary_precision_integers: return IR(1237, 39); + case Extension::kSPV_INTEL_bfloat16_conversion: return IR(1276, 30); + case Extension::kSPV_INTEL_bindless_images: return IR(1306, 26); + case Extension::kSPV_INTEL_blocking_pipes: return IR(1332, 25); + case Extension::kSPV_INTEL_cache_controls: return IR(1357, 25); + case Extension::kSPV_INTEL_debug_module: return IR(1382, 23); + case Extension::kSPV_INTEL_device_side_avc_motion_estimation: return IR(1405, 44); + case Extension::kSPV_INTEL_float_controls2: return IR(1449, 26); + case Extension::kSPV_INTEL_fp_fast_math_mode: return IR(1475, 28); + case Extension::kSPV_INTEL_fp_max_error: return IR(1503, 23); + case Extension::kSPV_INTEL_fpga_argument_interfaces: return IR(1526, 35); + case Extension::kSPV_INTEL_fpga_buffer_location: return IR(1561, 31); + case Extension::kSPV_INTEL_fpga_cluster_attributes: return IR(1592, 34); + case Extension::kSPV_INTEL_fpga_dsp_control: return IR(1626, 27); + case Extension::kSPV_INTEL_fpga_invocation_pipelining_attributes: return IR(1653, 48); + case Extension::kSPV_INTEL_fpga_latency_control: return IR(1701, 31); + case Extension::kSPV_INTEL_fpga_loop_controls: return IR(1732, 29); + case Extension::kSPV_INTEL_fpga_memory_accesses: return IR(1761, 31); + case Extension::kSPV_INTEL_fpga_memory_attributes: return IR(1792, 33); + case Extension::kSPV_INTEL_fpga_reg: return IR(1825, 19); + case Extension::kSPV_INTEL_function_pointers: return IR(1844, 28); + case Extension::kSPV_INTEL_function_variants: return IR(1872, 28); + case Extension::kSPV_INTEL_global_variable_fpga_decorations: return IR(1900, 43); + case Extension::kSPV_INTEL_global_variable_host_access: return IR(1943, 38); + case Extension::kSPV_INTEL_inline_assembly: return IR(1981, 26); + case Extension::kSPV_INTEL_int4: return IR(2007, 15); + case Extension::kSPV_INTEL_io_pipes: return IR(2022, 19); + case Extension::kSPV_INTEL_kernel_attributes: return IR(2041, 28); + case Extension::kSPV_INTEL_long_composites: return IR(2069, 26); + case Extension::kSPV_INTEL_loop_fuse: return IR(2095, 20); + case Extension::kSPV_INTEL_masked_gather_scatter: return IR(2115, 32); + case Extension::kSPV_INTEL_maximum_registers: return IR(2147, 28); + case Extension::kSPV_INTEL_media_block_io: return IR(2175, 25); + case Extension::kSPV_INTEL_memory_access_aliasing: return IR(2200, 33); + case Extension::kSPV_INTEL_optnone: return IR(2233, 18); + case Extension::kSPV_INTEL_runtime_aligned: return IR(2251, 26); + case Extension::kSPV_INTEL_shader_integer_functions2: return IR(2277, 36); + case Extension::kSPV_INTEL_split_barrier: return IR(2313, 24); + case Extension::kSPV_INTEL_subgroup_buffer_prefetch: return IR(2337, 35); + case Extension::kSPV_INTEL_subgroup_matrix_multiply_accumulate: return IR(2372, 46); + case Extension::kSPV_INTEL_subgroups: return IR(2418, 20); + case Extension::kSPV_INTEL_task_sequence: return IR(2438, 24); + case Extension::kSPV_INTEL_tensor_float32_conversion: return IR(2462, 36); + case Extension::kSPV_INTEL_ternary_bitwise_function: return IR(2498, 35); + case Extension::kSPV_INTEL_unstructured_loop_controls: return IR(2533, 37); + case Extension::kSPV_INTEL_usm_storage_classes: return IR(2570, 30); + case Extension::kSPV_INTEL_variable_length_array: return IR(2600, 32); + case Extension::kSPV_INTEL_vector_compute: return IR(2632, 25); + case Extension::kSPV_KHR_16bit_storage: return IR(2657, 22); + case Extension::kSPV_KHR_8bit_storage: return IR(2679, 21); + case Extension::kSPV_KHR_bfloat16: return IR(2700, 17); + case Extension::kSPV_KHR_bit_instructions: return IR(2717, 25); + case Extension::kSPV_KHR_compute_shader_derivatives: return IR(2742, 35); + case Extension::kSPV_KHR_cooperative_matrix: return IR(2777, 27); + case Extension::kSPV_KHR_device_group: return IR(2804, 21); + case Extension::kSPV_KHR_expect_assume: return IR(2825, 22); + case Extension::kSPV_KHR_float_controls: return IR(2847, 23); + case Extension::kSPV_KHR_float_controls2: return IR(2870, 24); + case Extension::kSPV_KHR_fma: return IR(2894, 12); + case Extension::kSPV_KHR_fragment_shader_barycentric: return IR(2906, 36); + case Extension::kSPV_KHR_fragment_shading_rate: return IR(2942, 30); + case Extension::kSPV_KHR_integer_dot_product: return IR(2972, 28); + case Extension::kSPV_KHR_linkonce_odr: return IR(3000, 21); + case Extension::kSPV_KHR_maximal_reconvergence: return IR(3021, 30); + case Extension::kSPV_KHR_multiview: return IR(3051, 18); + case Extension::kSPV_KHR_no_integer_wrap_decoration: return IR(3069, 35); + case Extension::kSPV_KHR_non_semantic_info: return IR(3104, 26); + case Extension::kSPV_KHR_physical_storage_buffer: return IR(3130, 32); + case Extension::kSPV_KHR_post_depth_coverage: return IR(3162, 28); + case Extension::kSPV_KHR_quad_control: return IR(3190, 21); + case Extension::kSPV_KHR_ray_cull_mask: return IR(3211, 22); + case Extension::kSPV_KHR_ray_query: return IR(3233, 18); + case Extension::kSPV_KHR_ray_tracing: return IR(3251, 20); + case Extension::kSPV_KHR_ray_tracing_position_fetch: return IR(3271, 35); + case Extension::kSPV_KHR_relaxed_extended_instruction: return IR(3306, 37); + case Extension::kSPV_KHR_shader_atomic_counter_ops: return IR(3343, 34); + case Extension::kSPV_KHR_shader_ballot: return IR(3377, 22); + case Extension::kSPV_KHR_shader_clock: return IR(3399, 21); + case Extension::kSPV_KHR_shader_draw_parameters: return IR(3420, 31); + case Extension::kSPV_KHR_storage_buffer_storage_class: return IR(3451, 37); + case Extension::kSPV_KHR_subgroup_rotate: return IR(3488, 24); + case Extension::kSPV_KHR_subgroup_uniform_control_flow: return IR(3512, 38); + case Extension::kSPV_KHR_subgroup_vote: return IR(3550, 22); + case Extension::kSPV_KHR_terminate_invocation: return IR(3572, 29); + case Extension::kSPV_KHR_uniform_group_instructions: return IR(3601, 35); + case Extension::kSPV_KHR_untyped_pointers: return IR(3636, 25); + case Extension::kSPV_KHR_variable_pointers: return IR(3661, 26); + case Extension::kSPV_KHR_vulkan_memory_model: return IR(3687, 28); + case Extension::kSPV_KHR_workgroup_memory_explicit_layout: return IR(3715, 41); + case Extension::kSPV_NVX_multiview_per_view_attributes: return IR(3756, 38); + case Extension::kSPV_NV_bindless_texture: return IR(3794, 24); + case Extension::kSPV_NV_cluster_acceleration_structure: return IR(3818, 38); + case Extension::kSPV_NV_compute_shader_derivatives: return IR(3856, 34); + case Extension::kSPV_NV_cooperative_matrix: return IR(3890, 26); + case Extension::kSPV_NV_cooperative_matrix2: return IR(3916, 27); + case Extension::kSPV_NV_cooperative_vector: return IR(3943, 26); + case Extension::kSPV_NV_displacement_micromap: return IR(3969, 29); + case Extension::kSPV_NV_fragment_shader_barycentric: return IR(3998, 35); + case Extension::kSPV_NV_geometry_shader_passthrough: return IR(4033, 35); + case Extension::kSPV_NV_linear_swept_spheres: return IR(4068, 28); + case Extension::kSPV_NV_mesh_shader: return IR(4096, 19); + case Extension::kSPV_NV_raw_access_chains: return IR(4115, 25); + case Extension::kSPV_NV_ray_tracing: return IR(4140, 19); + case Extension::kSPV_NV_ray_tracing_motion_blur: return IR(4159, 31); + case Extension::kSPV_NV_sample_mask_override_coverage: return IR(4190, 37); + case Extension::kSPV_NV_shader_atomic_fp16_vector: return IR(4227, 33); + case Extension::kSPV_NV_shader_image_footprint: return IR(4260, 30); + case Extension::kSPV_NV_shader_invocation_reorder: return IR(4290, 33); + case Extension::kSPV_NV_shader_sm_builtins: return IR(4323, 26); + case Extension::kSPV_NV_shader_subgroup_partitioned: return IR(4349, 35); + case Extension::kSPV_NV_shading_rate: return IR(4384, 20); + case Extension::kSPV_NV_stereo_view_rendering: return IR(4404, 29); + case Extension::kSPV_NV_tensor_addressing: return IR(4433, 25); + case Extension::kSPV_NV_viewport_array2: return IR(4458, 23); + case Extension::kSPV_QCOM_cooperative_matrix_conversion: return IR(4481, 39); + case Extension::kSPV_QCOM_image_processing: return IR(4520, 26); + case Extension::kSPV_QCOM_image_processing2: return IR(4546, 27); + case Extension::kSPV_QCOM_tile_shading: return IR(4573, 22); + case Extension::kSPV_VALIDATOR_ignore_type_decl_unique: return IR(4595, 38); default: break; } return {}; @@ -167,7 +171,7 @@ IndexRange ExtensionToIndexRange(Extension extension) { // The fields in order are: // name, indexing into kStrings // enum value -static const std::array kExtensionNames{{ +static const std::array kExtensionNames{{ {IR(0, 24), static_cast(kSPV_AMDX_shader_enqueue)}, {IR(24, 19), static_cast(kSPV_AMD_gcn_shader)}, {IR(43, 30), static_cast(kSPV_AMD_gpu_shader_half_float)}, @@ -182,149 +186,153 @@ static const std::array kExtensionNames{{ {IR(337, 32), static_cast(kSPV_AMD_texture_gather_bias_lod)}, {IR(369, 35), static_cast(kSPV_ARM_cooperative_matrix_layouts)}, {IR(404, 22), static_cast(kSPV_ARM_core_builtins)}, - {IR(426, 16), static_cast(kSPV_ARM_tensors)}, - {IR(442, 25), static_cast(kSPV_EXT_arithmetic_fence)}, - {IR(467, 36), static_cast(kSPV_EXT_demote_to_helper_invocation)}, - {IR(503, 28), static_cast(kSPV_EXT_descriptor_indexing)}, - {IR(531, 15), static_cast(kSPV_EXT_float8)}, - {IR(546, 31), static_cast(kSPV_EXT_fragment_fully_covered)}, - {IR(577, 36), static_cast(kSPV_EXT_fragment_invocation_density)}, - {IR(613, 34), static_cast(kSPV_EXT_fragment_shader_interlock)}, - {IR(647, 20), static_cast(kSPV_EXT_mesh_shader)}, - {IR(667, 25), static_cast(kSPV_EXT_opacity_micromap)}, - {IR(692, 16), static_cast(kSPV_EXT_optnone)}, - {IR(708, 32), static_cast(kSPV_EXT_physical_storage_buffer)}, - {IR(740, 44), static_cast(kSPV_EXT_relaxed_printf_string_address_space)}, - {IR(784, 30), static_cast(kSPV_EXT_replicated_composites)}, - {IR(814, 34), static_cast(kSPV_EXT_shader_atomic_float16_add)}, - {IR(848, 32), static_cast(kSPV_EXT_shader_atomic_float_add)}, - {IR(880, 36), static_cast(kSPV_EXT_shader_atomic_float_min_max)}, - {IR(916, 27), static_cast(kSPV_EXT_shader_image_int64)}, - {IR(943, 30), static_cast(kSPV_EXT_shader_stencil_export)}, - {IR(973, 26), static_cast(kSPV_EXT_shader_tile_image)}, - {IR(999, 36), static_cast(kSPV_EXT_shader_viewport_index_layer)}, - {IR(1035, 27), static_cast(kSPV_GOOGLE_decorate_string)}, - {IR(1062, 31), static_cast(kSPV_GOOGLE_hlsl_functionality1)}, - {IR(1093, 21), static_cast(kSPV_GOOGLE_user_type)}, - {IR(1114, 22), static_cast(kSPV_INTEL_2d_block_io)}, - {IR(1136, 42), static_cast(kSPV_INTEL_arbitrary_precision_fixed_point)}, - {IR(1178, 45), static_cast(kSPV_INTEL_arbitrary_precision_floating_point)}, - {IR(1223, 39), static_cast(kSPV_INTEL_arbitrary_precision_integers)}, - {IR(1262, 30), static_cast(kSPV_INTEL_bfloat16_conversion)}, - {IR(1292, 26), static_cast(kSPV_INTEL_bindless_images)}, - {IR(1318, 25), static_cast(kSPV_INTEL_blocking_pipes)}, - {IR(1343, 25), static_cast(kSPV_INTEL_cache_controls)}, - {IR(1368, 23), static_cast(kSPV_INTEL_debug_module)}, - {IR(1391, 44), static_cast(kSPV_INTEL_device_side_avc_motion_estimation)}, - {IR(1435, 26), static_cast(kSPV_INTEL_float_controls2)}, - {IR(1461, 28), static_cast(kSPV_INTEL_fp_fast_math_mode)}, - {IR(1489, 23), static_cast(kSPV_INTEL_fp_max_error)}, - {IR(1512, 35), static_cast(kSPV_INTEL_fpga_argument_interfaces)}, - {IR(1547, 31), static_cast(kSPV_INTEL_fpga_buffer_location)}, - {IR(1578, 34), static_cast(kSPV_INTEL_fpga_cluster_attributes)}, - {IR(1612, 27), static_cast(kSPV_INTEL_fpga_dsp_control)}, - {IR(1639, 48), static_cast(kSPV_INTEL_fpga_invocation_pipelining_attributes)}, - {IR(1687, 31), static_cast(kSPV_INTEL_fpga_latency_control)}, - {IR(1718, 29), static_cast(kSPV_INTEL_fpga_loop_controls)}, - {IR(1747, 31), static_cast(kSPV_INTEL_fpga_memory_accesses)}, - {IR(1778, 33), static_cast(kSPV_INTEL_fpga_memory_attributes)}, - {IR(1811, 19), static_cast(kSPV_INTEL_fpga_reg)}, - {IR(1830, 28), static_cast(kSPV_INTEL_function_pointers)}, - {IR(1858, 43), static_cast(kSPV_INTEL_global_variable_fpga_decorations)}, - {IR(1901, 38), static_cast(kSPV_INTEL_global_variable_host_access)}, - {IR(1939, 26), static_cast(kSPV_INTEL_inline_assembly)}, - {IR(1965, 15), static_cast(kSPV_INTEL_int4)}, - {IR(1980, 19), static_cast(kSPV_INTEL_io_pipes)}, - {IR(1999, 28), static_cast(kSPV_INTEL_kernel_attributes)}, - {IR(2027, 26), static_cast(kSPV_INTEL_long_composites)}, - {IR(2053, 20), static_cast(kSPV_INTEL_loop_fuse)}, - {IR(2073, 32), static_cast(kSPV_INTEL_masked_gather_scatter)}, - {IR(2105, 28), static_cast(kSPV_INTEL_maximum_registers)}, - {IR(2133, 25), static_cast(kSPV_INTEL_media_block_io)}, - {IR(2158, 33), static_cast(kSPV_INTEL_memory_access_aliasing)}, - {IR(2191, 18), static_cast(kSPV_INTEL_optnone)}, - {IR(2209, 26), static_cast(kSPV_INTEL_runtime_aligned)}, - {IR(2235, 36), static_cast(kSPV_INTEL_shader_integer_functions2)}, - {IR(2271, 24), static_cast(kSPV_INTEL_split_barrier)}, - {IR(2295, 35), static_cast(kSPV_INTEL_subgroup_buffer_prefetch)}, - {IR(2330, 46), static_cast(kSPV_INTEL_subgroup_matrix_multiply_accumulate)}, - {IR(2376, 20), static_cast(kSPV_INTEL_subgroups)}, - {IR(2396, 24), static_cast(kSPV_INTEL_task_sequence)}, - {IR(2420, 36), static_cast(kSPV_INTEL_tensor_float32_conversion)}, - {IR(2456, 35), static_cast(kSPV_INTEL_ternary_bitwise_function)}, - {IR(2491, 37), static_cast(kSPV_INTEL_unstructured_loop_controls)}, - {IR(2528, 30), static_cast(kSPV_INTEL_usm_storage_classes)}, - {IR(2558, 32), static_cast(kSPV_INTEL_variable_length_array)}, - {IR(2590, 25), static_cast(kSPV_INTEL_vector_compute)}, - {IR(2615, 22), static_cast(kSPV_KHR_16bit_storage)}, - {IR(2637, 21), static_cast(kSPV_KHR_8bit_storage)}, - {IR(2658, 17), static_cast(kSPV_KHR_bfloat16)}, - {IR(2675, 25), static_cast(kSPV_KHR_bit_instructions)}, - {IR(2700, 35), static_cast(kSPV_KHR_compute_shader_derivatives)}, - {IR(2735, 27), static_cast(kSPV_KHR_cooperative_matrix)}, - {IR(2762, 21), static_cast(kSPV_KHR_device_group)}, - {IR(2783, 22), static_cast(kSPV_KHR_expect_assume)}, - {IR(2805, 23), static_cast(kSPV_KHR_float_controls)}, - {IR(2828, 24), static_cast(kSPV_KHR_float_controls2)}, - {IR(2852, 36), static_cast(kSPV_KHR_fragment_shader_barycentric)}, - {IR(2888, 30), static_cast(kSPV_KHR_fragment_shading_rate)}, - {IR(2918, 28), static_cast(kSPV_KHR_integer_dot_product)}, - {IR(2946, 21), static_cast(kSPV_KHR_linkonce_odr)}, - {IR(2967, 30), static_cast(kSPV_KHR_maximal_reconvergence)}, - {IR(2997, 18), static_cast(kSPV_KHR_multiview)}, - {IR(3015, 35), static_cast(kSPV_KHR_no_integer_wrap_decoration)}, - {IR(3050, 26), static_cast(kSPV_KHR_non_semantic_info)}, - {IR(3076, 32), static_cast(kSPV_KHR_physical_storage_buffer)}, - {IR(3108, 28), static_cast(kSPV_KHR_post_depth_coverage)}, - {IR(3136, 21), static_cast(kSPV_KHR_quad_control)}, - {IR(3157, 22), static_cast(kSPV_KHR_ray_cull_mask)}, - {IR(3179, 18), static_cast(kSPV_KHR_ray_query)}, - {IR(3197, 20), static_cast(kSPV_KHR_ray_tracing)}, - {IR(3217, 35), static_cast(kSPV_KHR_ray_tracing_position_fetch)}, - {IR(3252, 37), static_cast(kSPV_KHR_relaxed_extended_instruction)}, - {IR(3289, 34), static_cast(kSPV_KHR_shader_atomic_counter_ops)}, - {IR(3323, 22), static_cast(kSPV_KHR_shader_ballot)}, - {IR(3345, 21), static_cast(kSPV_KHR_shader_clock)}, - {IR(3366, 31), static_cast(kSPV_KHR_shader_draw_parameters)}, - {IR(3397, 37), static_cast(kSPV_KHR_storage_buffer_storage_class)}, - {IR(3434, 24), static_cast(kSPV_KHR_subgroup_rotate)}, - {IR(3458, 38), static_cast(kSPV_KHR_subgroup_uniform_control_flow)}, - {IR(3496, 22), static_cast(kSPV_KHR_subgroup_vote)}, - {IR(3518, 29), static_cast(kSPV_KHR_terminate_invocation)}, - {IR(3547, 35), static_cast(kSPV_KHR_uniform_group_instructions)}, - {IR(3582, 25), static_cast(kSPV_KHR_untyped_pointers)}, - {IR(3607, 26), static_cast(kSPV_KHR_variable_pointers)}, - {IR(3633, 28), static_cast(kSPV_KHR_vulkan_memory_model)}, - {IR(3661, 41), static_cast(kSPV_KHR_workgroup_memory_explicit_layout)}, - {IR(3702, 38), static_cast(kSPV_NVX_multiview_per_view_attributes)}, - {IR(3740, 24), static_cast(kSPV_NV_bindless_texture)}, - {IR(3764, 38), static_cast(kSPV_NV_cluster_acceleration_structure)}, - {IR(3802, 34), static_cast(kSPV_NV_compute_shader_derivatives)}, - {IR(3836, 26), static_cast(kSPV_NV_cooperative_matrix)}, - {IR(3862, 27), static_cast(kSPV_NV_cooperative_matrix2)}, - {IR(3889, 26), static_cast(kSPV_NV_cooperative_vector)}, - {IR(3915, 29), static_cast(kSPV_NV_displacement_micromap)}, - {IR(3944, 35), static_cast(kSPV_NV_fragment_shader_barycentric)}, - {IR(3979, 35), static_cast(kSPV_NV_geometry_shader_passthrough)}, - {IR(4014, 28), static_cast(kSPV_NV_linear_swept_spheres)}, - {IR(4042, 19), static_cast(kSPV_NV_mesh_shader)}, - {IR(4061, 25), static_cast(kSPV_NV_raw_access_chains)}, - {IR(4086, 19), static_cast(kSPV_NV_ray_tracing)}, - {IR(4105, 31), static_cast(kSPV_NV_ray_tracing_motion_blur)}, - {IR(4136, 37), static_cast(kSPV_NV_sample_mask_override_coverage)}, - {IR(4173, 33), static_cast(kSPV_NV_shader_atomic_fp16_vector)}, - {IR(4206, 30), static_cast(kSPV_NV_shader_image_footprint)}, - {IR(4236, 33), static_cast(kSPV_NV_shader_invocation_reorder)}, - {IR(4269, 26), static_cast(kSPV_NV_shader_sm_builtins)}, - {IR(4295, 35), static_cast(kSPV_NV_shader_subgroup_partitioned)}, - {IR(4330, 20), static_cast(kSPV_NV_shading_rate)}, - {IR(4350, 29), static_cast(kSPV_NV_stereo_view_rendering)}, - {IR(4379, 25), static_cast(kSPV_NV_tensor_addressing)}, - {IR(4404, 23), static_cast(kSPV_NV_viewport_array2)}, - {IR(4427, 26), static_cast(kSPV_QCOM_image_processing)}, - {IR(4453, 27), static_cast(kSPV_QCOM_image_processing2)}, - {IR(4480, 22), static_cast(kSPV_QCOM_tile_shading)}, - {IR(4502, 38), static_cast(kSPV_VALIDATOR_ignore_type_decl_unique)}, + {IR(426, 14), static_cast(kSPV_ARM_graph)}, + {IR(440, 16), static_cast(kSPV_ARM_tensors)}, + {IR(456, 25), static_cast(kSPV_EXT_arithmetic_fence)}, + {IR(481, 36), static_cast(kSPV_EXT_demote_to_helper_invocation)}, + {IR(517, 28), static_cast(kSPV_EXT_descriptor_indexing)}, + {IR(545, 15), static_cast(kSPV_EXT_float8)}, + {IR(560, 31), static_cast(kSPV_EXT_fragment_fully_covered)}, + {IR(591, 36), static_cast(kSPV_EXT_fragment_invocation_density)}, + {IR(627, 34), static_cast(kSPV_EXT_fragment_shader_interlock)}, + {IR(661, 20), static_cast(kSPV_EXT_mesh_shader)}, + {IR(681, 25), static_cast(kSPV_EXT_opacity_micromap)}, + {IR(706, 16), static_cast(kSPV_EXT_optnone)}, + {IR(722, 32), static_cast(kSPV_EXT_physical_storage_buffer)}, + {IR(754, 44), static_cast(kSPV_EXT_relaxed_printf_string_address_space)}, + {IR(798, 30), static_cast(kSPV_EXT_replicated_composites)}, + {IR(828, 34), static_cast(kSPV_EXT_shader_atomic_float16_add)}, + {IR(862, 32), static_cast(kSPV_EXT_shader_atomic_float_add)}, + {IR(894, 36), static_cast(kSPV_EXT_shader_atomic_float_min_max)}, + {IR(930, 27), static_cast(kSPV_EXT_shader_image_int64)}, + {IR(957, 30), static_cast(kSPV_EXT_shader_stencil_export)}, + {IR(987, 26), static_cast(kSPV_EXT_shader_tile_image)}, + {IR(1013, 36), static_cast(kSPV_EXT_shader_viewport_index_layer)}, + {IR(1049, 27), static_cast(kSPV_GOOGLE_decorate_string)}, + {IR(1076, 31), static_cast(kSPV_GOOGLE_hlsl_functionality1)}, + {IR(1107, 21), static_cast(kSPV_GOOGLE_user_type)}, + {IR(1128, 22), static_cast(kSPV_INTEL_2d_block_io)}, + {IR(1150, 42), static_cast(kSPV_INTEL_arbitrary_precision_fixed_point)}, + {IR(1192, 45), static_cast(kSPV_INTEL_arbitrary_precision_floating_point)}, + {IR(1237, 39), static_cast(kSPV_INTEL_arbitrary_precision_integers)}, + {IR(1276, 30), static_cast(kSPV_INTEL_bfloat16_conversion)}, + {IR(1306, 26), static_cast(kSPV_INTEL_bindless_images)}, + {IR(1332, 25), static_cast(kSPV_INTEL_blocking_pipes)}, + {IR(1357, 25), static_cast(kSPV_INTEL_cache_controls)}, + {IR(1382, 23), static_cast(kSPV_INTEL_debug_module)}, + {IR(1405, 44), static_cast(kSPV_INTEL_device_side_avc_motion_estimation)}, + {IR(1449, 26), static_cast(kSPV_INTEL_float_controls2)}, + {IR(1475, 28), static_cast(kSPV_INTEL_fp_fast_math_mode)}, + {IR(1503, 23), static_cast(kSPV_INTEL_fp_max_error)}, + {IR(1526, 35), static_cast(kSPV_INTEL_fpga_argument_interfaces)}, + {IR(1561, 31), static_cast(kSPV_INTEL_fpga_buffer_location)}, + {IR(1592, 34), static_cast(kSPV_INTEL_fpga_cluster_attributes)}, + {IR(1626, 27), static_cast(kSPV_INTEL_fpga_dsp_control)}, + {IR(1653, 48), static_cast(kSPV_INTEL_fpga_invocation_pipelining_attributes)}, + {IR(1701, 31), static_cast(kSPV_INTEL_fpga_latency_control)}, + {IR(1732, 29), static_cast(kSPV_INTEL_fpga_loop_controls)}, + {IR(1761, 31), static_cast(kSPV_INTEL_fpga_memory_accesses)}, + {IR(1792, 33), static_cast(kSPV_INTEL_fpga_memory_attributes)}, + {IR(1825, 19), static_cast(kSPV_INTEL_fpga_reg)}, + {IR(1844, 28), static_cast(kSPV_INTEL_function_pointers)}, + {IR(1872, 28), static_cast(kSPV_INTEL_function_variants)}, + {IR(1900, 43), static_cast(kSPV_INTEL_global_variable_fpga_decorations)}, + {IR(1943, 38), static_cast(kSPV_INTEL_global_variable_host_access)}, + {IR(1981, 26), static_cast(kSPV_INTEL_inline_assembly)}, + {IR(2007, 15), static_cast(kSPV_INTEL_int4)}, + {IR(2022, 19), static_cast(kSPV_INTEL_io_pipes)}, + {IR(2041, 28), static_cast(kSPV_INTEL_kernel_attributes)}, + {IR(2069, 26), static_cast(kSPV_INTEL_long_composites)}, + {IR(2095, 20), static_cast(kSPV_INTEL_loop_fuse)}, + {IR(2115, 32), static_cast(kSPV_INTEL_masked_gather_scatter)}, + {IR(2147, 28), static_cast(kSPV_INTEL_maximum_registers)}, + {IR(2175, 25), static_cast(kSPV_INTEL_media_block_io)}, + {IR(2200, 33), static_cast(kSPV_INTEL_memory_access_aliasing)}, + {IR(2233, 18), static_cast(kSPV_INTEL_optnone)}, + {IR(2251, 26), static_cast(kSPV_INTEL_runtime_aligned)}, + {IR(2277, 36), static_cast(kSPV_INTEL_shader_integer_functions2)}, + {IR(2313, 24), static_cast(kSPV_INTEL_split_barrier)}, + {IR(2337, 35), static_cast(kSPV_INTEL_subgroup_buffer_prefetch)}, + {IR(2372, 46), static_cast(kSPV_INTEL_subgroup_matrix_multiply_accumulate)}, + {IR(2418, 20), static_cast(kSPV_INTEL_subgroups)}, + {IR(2438, 24), static_cast(kSPV_INTEL_task_sequence)}, + {IR(2462, 36), static_cast(kSPV_INTEL_tensor_float32_conversion)}, + {IR(2498, 35), static_cast(kSPV_INTEL_ternary_bitwise_function)}, + {IR(2533, 37), static_cast(kSPV_INTEL_unstructured_loop_controls)}, + {IR(2570, 30), static_cast(kSPV_INTEL_usm_storage_classes)}, + {IR(2600, 32), static_cast(kSPV_INTEL_variable_length_array)}, + {IR(2632, 25), static_cast(kSPV_INTEL_vector_compute)}, + {IR(2657, 22), static_cast(kSPV_KHR_16bit_storage)}, + {IR(2679, 21), static_cast(kSPV_KHR_8bit_storage)}, + {IR(2700, 17), static_cast(kSPV_KHR_bfloat16)}, + {IR(2717, 25), static_cast(kSPV_KHR_bit_instructions)}, + {IR(2742, 35), static_cast(kSPV_KHR_compute_shader_derivatives)}, + {IR(2777, 27), static_cast(kSPV_KHR_cooperative_matrix)}, + {IR(2804, 21), static_cast(kSPV_KHR_device_group)}, + {IR(2825, 22), static_cast(kSPV_KHR_expect_assume)}, + {IR(2847, 23), static_cast(kSPV_KHR_float_controls)}, + {IR(2870, 24), static_cast(kSPV_KHR_float_controls2)}, + {IR(2894, 12), static_cast(kSPV_KHR_fma)}, + {IR(2906, 36), static_cast(kSPV_KHR_fragment_shader_barycentric)}, + {IR(2942, 30), static_cast(kSPV_KHR_fragment_shading_rate)}, + {IR(2972, 28), static_cast(kSPV_KHR_integer_dot_product)}, + {IR(3000, 21), static_cast(kSPV_KHR_linkonce_odr)}, + {IR(3021, 30), static_cast(kSPV_KHR_maximal_reconvergence)}, + {IR(3051, 18), static_cast(kSPV_KHR_multiview)}, + {IR(3069, 35), static_cast(kSPV_KHR_no_integer_wrap_decoration)}, + {IR(3104, 26), static_cast(kSPV_KHR_non_semantic_info)}, + {IR(3130, 32), static_cast(kSPV_KHR_physical_storage_buffer)}, + {IR(3162, 28), static_cast(kSPV_KHR_post_depth_coverage)}, + {IR(3190, 21), static_cast(kSPV_KHR_quad_control)}, + {IR(3211, 22), static_cast(kSPV_KHR_ray_cull_mask)}, + {IR(3233, 18), static_cast(kSPV_KHR_ray_query)}, + {IR(3251, 20), static_cast(kSPV_KHR_ray_tracing)}, + {IR(3271, 35), static_cast(kSPV_KHR_ray_tracing_position_fetch)}, + {IR(3306, 37), static_cast(kSPV_KHR_relaxed_extended_instruction)}, + {IR(3343, 34), static_cast(kSPV_KHR_shader_atomic_counter_ops)}, + {IR(3377, 22), static_cast(kSPV_KHR_shader_ballot)}, + {IR(3399, 21), static_cast(kSPV_KHR_shader_clock)}, + {IR(3420, 31), static_cast(kSPV_KHR_shader_draw_parameters)}, + {IR(3451, 37), static_cast(kSPV_KHR_storage_buffer_storage_class)}, + {IR(3488, 24), static_cast(kSPV_KHR_subgroup_rotate)}, + {IR(3512, 38), static_cast(kSPV_KHR_subgroup_uniform_control_flow)}, + {IR(3550, 22), static_cast(kSPV_KHR_subgroup_vote)}, + {IR(3572, 29), static_cast(kSPV_KHR_terminate_invocation)}, + {IR(3601, 35), static_cast(kSPV_KHR_uniform_group_instructions)}, + {IR(3636, 25), static_cast(kSPV_KHR_untyped_pointers)}, + {IR(3661, 26), static_cast(kSPV_KHR_variable_pointers)}, + {IR(3687, 28), static_cast(kSPV_KHR_vulkan_memory_model)}, + {IR(3715, 41), static_cast(kSPV_KHR_workgroup_memory_explicit_layout)}, + {IR(3756, 38), static_cast(kSPV_NVX_multiview_per_view_attributes)}, + {IR(3794, 24), static_cast(kSPV_NV_bindless_texture)}, + {IR(3818, 38), static_cast(kSPV_NV_cluster_acceleration_structure)}, + {IR(3856, 34), static_cast(kSPV_NV_compute_shader_derivatives)}, + {IR(3890, 26), static_cast(kSPV_NV_cooperative_matrix)}, + {IR(3916, 27), static_cast(kSPV_NV_cooperative_matrix2)}, + {IR(3943, 26), static_cast(kSPV_NV_cooperative_vector)}, + {IR(3969, 29), static_cast(kSPV_NV_displacement_micromap)}, + {IR(3998, 35), static_cast(kSPV_NV_fragment_shader_barycentric)}, + {IR(4033, 35), static_cast(kSPV_NV_geometry_shader_passthrough)}, + {IR(4068, 28), static_cast(kSPV_NV_linear_swept_spheres)}, + {IR(4096, 19), static_cast(kSPV_NV_mesh_shader)}, + {IR(4115, 25), static_cast(kSPV_NV_raw_access_chains)}, + {IR(4140, 19), static_cast(kSPV_NV_ray_tracing)}, + {IR(4159, 31), static_cast(kSPV_NV_ray_tracing_motion_blur)}, + {IR(4190, 37), static_cast(kSPV_NV_sample_mask_override_coverage)}, + {IR(4227, 33), static_cast(kSPV_NV_shader_atomic_fp16_vector)}, + {IR(4260, 30), static_cast(kSPV_NV_shader_image_footprint)}, + {IR(4290, 33), static_cast(kSPV_NV_shader_invocation_reorder)}, + {IR(4323, 26), static_cast(kSPV_NV_shader_sm_builtins)}, + {IR(4349, 35), static_cast(kSPV_NV_shader_subgroup_partitioned)}, + {IR(4384, 20), static_cast(kSPV_NV_shading_rate)}, + {IR(4404, 29), static_cast(kSPV_NV_stereo_view_rendering)}, + {IR(4433, 25), static_cast(kSPV_NV_tensor_addressing)}, + {IR(4458, 23), static_cast(kSPV_NV_viewport_array2)}, + {IR(4481, 39), static_cast(kSPV_QCOM_cooperative_matrix_conversion)}, + {IR(4520, 26), static_cast(kSPV_QCOM_image_processing)}, + {IR(4546, 27), static_cast(kSPV_QCOM_image_processing2)}, + {IR(4573, 22), static_cast(kSPV_QCOM_tile_shading)}, + {IR(4595, 38), static_cast(kSPV_VALIDATOR_ignore_type_decl_unique)}, }}; // Operand descriptions, ordered by (operand kind, operand enum value). @@ -337,1189 +345,1196 @@ static const std::array kExtensionNames{{ // extensions, as an IndexRange into kExtensionSpans // version, first version of SPIR-V that has it // lastVersion, last version of SPIR-V that has it -static const std::array kOperandsByValue{{ - {0,IR(0, 0),IR(4540, 9)/* ReadOnly */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_ACCESS_QUALIFIER - {1,IR(0, 0),IR(4556, 10)/* WriteOnly */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_ACCESS_QUALIFIER - {2,IR(0, 0),IR(4566, 10)/* ReadWrite */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_ACCESS_QUALIFIER - {0,IR(0, 0),IR(4576, 8)/* Logical */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_ADDRESSING_MODEL - {1,IR(0, 0),IR(4584, 11)/* Physical32 */,IR(0, 0),IR(1, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_ADDRESSING_MODEL - {2,IR(0, 0),IR(4605, 11)/* Physical64 */,IR(0, 0),IR(1, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_ADDRESSING_MODEL - {5348,IR(0, 0),IR(4616, 24)/* PhysicalStorageBuffer64 */,IR(0, 1),IR(2, 1),IR(0, 2),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_ADDRESSING_MODEL - {0,IR(0, 0),IR(4698, 9)/* Position */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {1,IR(0, 0),IR(4714, 10)/* PointSize */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {3,IR(0, 0),IR(4724, 13)/* ClipDistance */,IR(0, 0),IR(4, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4,IR(0, 0),IR(4737, 13)/* CullDistance */,IR(0, 0),IR(5, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5,IR(0, 0),IR(4750, 9)/* VertexId */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {6,IR(0, 0),IR(4759, 11)/* InstanceId */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {7,IR(0, 0),IR(4770, 12)/* PrimitiveId */,IR(0, 0),IR(6, 6),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {8,IR(0, 0),IR(4860, 13)/* InvocationId */,IR(0, 0),IR(12, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {9,IR(0, 0),IR(4873, 6)/* Layer */,IR(0, 0),IR(14, 5),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {10,IR(0, 0),IR(4919, 14)/* ViewportIndex */,IR(0, 0),IR(19, 5),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {11,IR(0, 0),IR(4967, 15)/* TessLevelOuter */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {12,IR(0, 0),IR(4982, 15)/* TessLevelInner */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {13,IR(0, 0),IR(4997, 10)/* TessCoord */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {14,IR(0, 0),IR(5007, 14)/* PatchVertices */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {15,IR(0, 0),IR(5021, 10)/* FragCoord */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {16,IR(0, 0),IR(5031, 11)/* PointCoord */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {17,IR(0, 0),IR(5042, 12)/* FrontFacing */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {18,IR(0, 0),IR(5054, 9)/* SampleId */,IR(0, 0),IR(25, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {19,IR(0, 0),IR(5081, 15)/* SamplePosition */,IR(0, 0),IR(25, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {20,IR(0, 0),IR(5096, 11)/* SampleMask */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {22,IR(0, 0),IR(5107, 10)/* FragDepth */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {23,IR(0, 0),IR(5117, 17)/* HelperInvocation */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {24,IR(0, 0),IR(5134, 14)/* NumWorkgroups */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {25,IR(0, 0),IR(5148, 14)/* WorkgroupSize */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {26,IR(0, 0),IR(5162, 12)/* WorkgroupId */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {27,IR(0, 0),IR(5174, 18)/* LocalInvocationId */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {28,IR(0, 0),IR(5192, 19)/* GlobalInvocationId */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {29,IR(0, 0),IR(5211, 21)/* LocalInvocationIndex */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {30,IR(0, 0),IR(5232, 8)/* WorkDim */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {31,IR(0, 0),IR(5240, 11)/* GlobalSize */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {32,IR(0, 0),IR(5251, 22)/* EnqueuedWorkgroupSize */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {33,IR(0, 0),IR(5273, 13)/* GlobalOffset */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {34,IR(0, 0),IR(5286, 15)/* GlobalLinearId */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {36,IR(0, 0),IR(5301, 13)/* SubgroupSize */,IR(0, 0),IR(26, 3),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {37,IR(0, 0),IR(5348, 16)/* SubgroupMaxSize */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {38,IR(0, 0),IR(5364, 13)/* NumSubgroups */,IR(0, 0),IR(29, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {39,IR(0, 0),IR(5377, 21)/* NumEnqueuedSubgroups */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {40,IR(0, 0),IR(5398, 11)/* SubgroupId */,IR(0, 0),IR(29, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {41,IR(0, 0),IR(5409, 26)/* SubgroupLocalInvocationId */,IR(0, 0),IR(26, 3),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {42,IR(0, 0),IR(5435, 12)/* VertexIndex */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {43,IR(0, 0),IR(5447, 14)/* InstanceIndex */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4160,IR(0, 0),IR(5461, 10)/* CoreIDARM */,IR(0, 0),IR(31, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4161,IR(0, 0),IR(5487, 13)/* CoreCountARM */,IR(0, 0),IR(31, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4162,IR(0, 0),IR(5500, 13)/* CoreMaxIDARM */,IR(0, 0),IR(31, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4163,IR(0, 0),IR(5513, 10)/* WarpIDARM */,IR(0, 0),IR(31, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4164,IR(0, 0),IR(5523, 13)/* WarpMaxIDARM */,IR(0, 0),IR(31, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4416,IR(0, 0),IR(5536, 15)/* SubgroupEqMask */,IR(1, 1),IR(32, 2),IR(2, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4417,IR(0, 0),IR(5591, 15)/* SubgroupGeMask */,IR(2, 1),IR(32, 2),IR(2, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4418,IR(0, 0),IR(5624, 15)/* SubgroupGtMask */,IR(3, 1),IR(32, 2),IR(2, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4419,IR(0, 0),IR(5657, 15)/* SubgroupLeMask */,IR(4, 1),IR(32, 2),IR(2, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4420,IR(0, 0),IR(5690, 15)/* SubgroupLtMask */,IR(5, 1),IR(32, 2),IR(2, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4424,IR(0, 0),IR(5723, 11)/* BaseVertex */,IR(0, 0),IR(34, 1),IR(3, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4425,IR(0, 0),IR(5749, 13)/* BaseInstance */,IR(0, 0),IR(34, 1),IR(3, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4426,IR(0, 0),IR(5762, 10)/* DrawIndex */,IR(0, 0),IR(35, 3),IR(4, 3),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4432,IR(0, 0),IR(5772, 24)/* PrimitiveShadingRateKHR */,IR(0, 0),IR(38, 1),IR(7, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4438,IR(0, 0),IR(5819, 12)/* DeviceIndex */,IR(0, 0),IR(39, 1),IR(8, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4440,IR(0, 0),IR(5843, 10)/* ViewIndex */,IR(0, 0),IR(40, 1),IR(9, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4444,IR(0, 0),IR(5863, 15)/* ShadingRateKHR */,IR(0, 0),IR(38, 1),IR(7, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4492,IR(0, 0),IR(5878, 15)/* TileOffsetQCOM */,IR(0, 0),IR(41, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4493,IR(0, 0),IR(5909, 18)/* TileDimensionQCOM */,IR(0, 0),IR(41, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4494,IR(0, 0),IR(5927, 18)/* TileApronSizeQCOM */,IR(0, 0),IR(41, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4992,IR(0, 0),IR(5945, 20)/* BaryCoordNoPerspAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4993,IR(0, 0),IR(5965, 28)/* BaryCoordNoPerspCentroidAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4994,IR(0, 0),IR(5993, 26)/* BaryCoordNoPerspSampleAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4995,IR(0, 0),IR(6019, 19)/* BaryCoordSmoothAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4996,IR(0, 0),IR(6038, 27)/* BaryCoordSmoothCentroidAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4997,IR(0, 0),IR(6065, 25)/* BaryCoordSmoothSampleAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {4998,IR(0, 0),IR(6090, 22)/* BaryCoordPullModelAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5014,IR(0, 0),IR(6112, 18)/* FragStencilRefEXT */,IR(0, 0),IR(42, 1),IR(11, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5021,IR(0, 0),IR(6147, 29)/* RemainingRecursionLevelsAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5073,IR(0, 0),IR(6194, 16)/* ShaderIndexAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5253,IR(0, 0),IR(6210, 15)/* ViewportMaskNV */,IR(0, 0),IR(44, 2),IR(12, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5257,IR(0, 0),IR(6246, 20)/* SecondaryPositionNV */,IR(0, 0),IR(46, 1),IR(14, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5258,IR(0, 0),IR(6285, 24)/* SecondaryViewportMaskNV */,IR(0, 0),IR(46, 1),IR(14, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5261,IR(0, 0),IR(6309, 18)/* PositionPerViewNV */,IR(0, 0),IR(47, 2),IR(15, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5262,IR(0, 0),IR(6347, 22)/* ViewportMaskPerViewNV */,IR(0, 0),IR(47, 2),IR(15, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5264,IR(0, 0),IR(6369, 16)/* FullyCoveredEXT */,IR(0, 0),IR(49, 1),IR(17, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5274,IR(0, 0),IR(6409, 12)/* TaskCountNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5275,IR(0, 0),IR(6421, 17)/* PrimitiveCountNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5276,IR(0, 0),IR(6438, 19)/* PrimitiveIndicesNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5277,IR(0, 0),IR(6457, 22)/* ClipDistancePerViewNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5278,IR(0, 0),IR(6479, 22)/* CullDistancePerViewNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5279,IR(0, 0),IR(6501, 15)/* LayerPerViewNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5280,IR(0, 0),IR(6516, 16)/* MeshViewCountNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5281,IR(0, 0),IR(6532, 18)/* MeshViewIndicesNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5286,IR(0, 0),IR(6550, 13)/* BaryCoordKHR */,IR(6, 1),IR(51, 1),IR(19, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5287,IR(0, 0),IR(6598, 20)/* BaryCoordNoPerspKHR */,IR(7, 1),IR(51, 1),IR(19, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5292,IR(0, 0),IR(6637, 12)/* FragSizeEXT */,IR(8, 1),IR(52, 1),IR(21, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5293,IR(0, 0),IR(6683, 23)/* FragInvocationCountEXT */,IR(9, 1),IR(52, 1),IR(21, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5294,IR(0, 0),IR(6728, 25)/* PrimitivePointIndicesEXT */,IR(0, 0),IR(53, 1),IR(23, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5295,IR(0, 0),IR(6753, 24)/* PrimitiveLineIndicesEXT */,IR(0, 0),IR(53, 1),IR(23, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5296,IR(0, 0),IR(6777, 28)/* PrimitiveTriangleIndicesEXT */,IR(0, 0),IR(53, 1),IR(23, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5299,IR(0, 0),IR(6805, 17)/* CullPrimitiveEXT */,IR(0, 0),IR(53, 1),IR(23, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5319,IR(0, 0),IR(6822, 12)/* LaunchIdKHR */,IR(10, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5320,IR(0, 0),IR(6845, 14)/* LaunchSizeKHR */,IR(11, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5321,IR(0, 0),IR(6872, 18)/* WorldRayOriginKHR */,IR(12, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5322,IR(0, 0),IR(6907, 21)/* WorldRayDirectionKHR */,IR(13, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5323,IR(0, 0),IR(6948, 19)/* ObjectRayOriginKHR */,IR(14, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5324,IR(0, 0),IR(6985, 22)/* ObjectRayDirectionKHR */,IR(15, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5325,IR(0, 0),IR(7028, 11)/* RayTminKHR */,IR(16, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5326,IR(0, 0),IR(7049, 11)/* RayTmaxKHR */,IR(17, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5327,IR(0, 0),IR(7070, 23)/* InstanceCustomIndexKHR */,IR(18, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5330,IR(0, 0),IR(7115, 17)/* ObjectToWorldKHR */,IR(19, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5331,IR(0, 0),IR(7148, 17)/* WorldToObjectKHR */,IR(20, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5332,IR(0, 0),IR(7181, 7)/* HitTNV */,IR(0, 0),IR(56, 1),IR(26, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5333,IR(0, 0),IR(7188, 11)/* HitKindKHR */,IR(21, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5334,IR(0, 0),IR(7209, 17)/* CurrentRayTimeNV */,IR(0, 0),IR(57, 1),IR(27, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5335,IR(0, 0),IR(7249, 30)/* HitTriangleVertexPositionsKHR */,IR(0, 0),IR(58, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5337,IR(0, 0),IR(7306, 34)/* HitMicroTriangleVertexPositionsNV */,IR(0, 0),IR(59, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5344,IR(0, 0),IR(7373, 37)/* HitMicroTriangleVertexBarycentricsNV */,IR(0, 0),IR(59, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5351,IR(0, 0),IR(7410, 20)/* IncomingRayFlagsKHR */,IR(22, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5352,IR(0, 0),IR(7449, 20)/* RayGeometryIndexKHR */,IR(0, 0),IR(60, 1),IR(28, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5359,IR(0, 0),IR(7469, 14)/* HitIsSphereNV */,IR(0, 0),IR(61, 1),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5360,IR(0, 0),IR(7511, 11)/* HitIsLSSNV */,IR(0, 0),IR(62, 1),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5361,IR(0, 0),IR(7561, 20)/* HitSpherePositionNV */,IR(0, 0),IR(61, 1),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5374,IR(0, 0),IR(7581, 13)/* WarpsPerSMNV */,IR(0, 0),IR(63, 1),IR(30, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5375,IR(0, 0),IR(7613, 10)/* SMCountNV */,IR(0, 0),IR(63, 1),IR(30, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5376,IR(0, 0),IR(7623, 9)/* WarpIDNV */,IR(0, 0),IR(63, 1),IR(30, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5377,IR(0, 0),IR(7632, 7)/* SMIDNV */,IR(0, 0),IR(63, 1),IR(30, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5396,IR(0, 0),IR(7639, 18)/* HitLSSPositionsNV */,IR(0, 0),IR(62, 1),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5405,IR(0, 0),IR(7657, 34)/* HitKindFrontFacingMicroTriangleNV */,IR(0, 0),IR(59, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5406,IR(0, 0),IR(7691, 33)/* HitKindBackFacingMicroTriangleNV */,IR(0, 0),IR(59, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5420,IR(0, 0),IR(7724, 18)/* HitSphereRadiusNV */,IR(0, 0),IR(61, 1),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5421,IR(0, 0),IR(7742, 14)/* HitLSSRadiiNV */,IR(0, 0),IR(62, 1),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {5436,IR(0, 0),IR(7756, 12)/* ClusterIDNV */,IR(0, 0),IR(64, 1),IR(31, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {6021,IR(0, 0),IR(7809, 12)/* CullMaskKHR */,IR(0, 0),IR(65, 1),IR(32, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN - {0,IR(0, 0),IR(7836, 7)/* Matrix */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {1,IR(0, 0),IR(4707, 7)/* Shader */,IR(0, 0),IR(66, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {2,IR(0, 0),IR(4782, 9)/* Geometry */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {3,IR(0, 0),IR(4791, 13)/* Tessellation */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4,IR(0, 0),IR(4595, 10)/* Addresses */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5,IR(0, 0),IR(7843, 8)/* Linkage */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6,IR(0, 0),IR(4549, 7)/* Kernel */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {7,IR(0, 0),IR(7851, 9)/* Vector16 */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {8,IR(0, 0),IR(7860, 14)/* Float16Buffer */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {9,IR(0, 0),IR(7874, 8)/* Float16 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {10,IR(0, 0),IR(7882, 8)/* Float64 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {11,IR(0, 0),IR(7890, 6)/* Int64 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {12,IR(0, 0),IR(7896, 13)/* Int64Atomics */,IR(0, 0),IR(67, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {13,IR(0, 0),IR(7909, 11)/* ImageBasic */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {14,IR(0, 0),IR(7920, 15)/* ImageReadWrite */,IR(0, 0),IR(68, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {15,IR(0, 0),IR(7935, 12)/* ImageMipmap */,IR(0, 0),IR(68, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {17,IR(0, 0),IR(7947, 6)/* Pipes */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {18,IR(0, 0),IR(7953, 7)/* Groups */,IR(0, 0),IR(1, 0),IR(33, 1),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {19,IR(0, 0),IR(7960, 14)/* DeviceEnqueue */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {20,IR(0, 0),IR(7974, 15)/* LiteralSampler */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {21,IR(0, 0),IR(7989, 14)/* AtomicStorage */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {22,IR(0, 0),IR(8003, 6)/* Int16 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {23,IR(0, 0),IR(8009, 22)/* TessellationPointSize */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {24,IR(0, 0),IR(8031, 18)/* GeometryPointSize */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {25,IR(0, 0),IR(8049, 20)/* ImageGatherExtended */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {27,IR(0, 0),IR(8069, 24)/* StorageImageMultisample */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {28,IR(0, 0),IR(8093, 34)/* UniformBufferArrayDynamicIndexing */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {29,IR(0, 0),IR(8127, 33)/* SampledImageArrayDynamicIndexing */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {30,IR(0, 0),IR(8160, 34)/* StorageBufferArrayDynamicIndexing */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {31,IR(0, 0),IR(8194, 33)/* StorageImageArrayDynamicIndexing */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {32,IR(0, 0),IR(4724, 13)/* ClipDistance */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {33,IR(0, 0),IR(4737, 13)/* CullDistance */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {34,IR(0, 0),IR(8227, 15)/* ImageCubeArray */,IR(0, 0),IR(70, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {35,IR(0, 0),IR(5063, 18)/* SampleRateShading */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {36,IR(0, 0),IR(8259, 10)/* ImageRect */,IR(0, 0),IR(71, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {37,IR(0, 0),IR(8269, 12)/* SampledRect */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {38,IR(0, 0),IR(8281, 15)/* GenericPointer */,IR(0, 0),IR(1, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {39,IR(0, 0),IR(8296, 5)/* Int8 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {40,IR(0, 0),IR(8301, 16)/* InputAttachment */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {41,IR(0, 0),IR(8317, 16)/* SparseResidency */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {42,IR(0, 0),IR(8333, 7)/* MinLod */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {43,IR(0, 0),IR(8340, 10)/* Sampled1D */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {44,IR(0, 0),IR(8350, 8)/* Image1D */,IR(0, 0),IR(72, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {45,IR(0, 0),IR(8242, 17)/* SampledCubeArray */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {46,IR(0, 0),IR(8358, 14)/* SampledBuffer */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {47,IR(0, 0),IR(8372, 12)/* ImageBuffer */,IR(0, 0),IR(73, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {48,IR(0, 0),IR(8384, 13)/* ImageMSArray */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {49,IR(0, 0),IR(8397, 28)/* StorageImageExtendedFormats */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {50,IR(0, 0),IR(8425, 11)/* ImageQuery */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {51,IR(0, 0),IR(8436, 18)/* DerivativeControl */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {52,IR(0, 0),IR(8454, 22)/* InterpolationFunction */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {53,IR(0, 0),IR(8476, 18)/* TransformFeedback */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {54,IR(0, 0),IR(8494, 16)/* GeometryStreams */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {55,IR(0, 0),IR(8510, 30)/* StorageImageReadWithoutFormat */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {56,IR(0, 0),IR(8540, 31)/* StorageImageWriteWithoutFormat */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {57,IR(0, 0),IR(4933, 14)/* MultiViewport */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {58,IR(0, 0),IR(8571, 17)/* SubgroupDispatch */,IR(0, 0),IR(74, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {59,IR(0, 0),IR(8588, 13)/* NamedBarrier */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {60,IR(0, 0),IR(8601, 12)/* PipeStorage */,IR(0, 0),IR(75, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {61,IR(0, 0),IR(5314, 16)/* GroupNonUniform */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {62,IR(0, 0),IR(8613, 20)/* GroupNonUniformVote */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {63,IR(0, 0),IR(8633, 26)/* GroupNonUniformArithmetic */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {64,IR(0, 0),IR(5569, 22)/* GroupNonUniformBallot */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {65,IR(0, 0),IR(8659, 23)/* GroupNonUniformShuffle */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {66,IR(0, 0),IR(8682, 31)/* GroupNonUniformShuffleRelative */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {67,IR(0, 0),IR(8713, 25)/* GroupNonUniformClustered */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {68,IR(0, 0),IR(8738, 20)/* GroupNonUniformQuad */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {69,IR(0, 0),IR(4879, 12)/* ShaderLayer */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {70,IR(0, 0),IR(4947, 20)/* ShaderViewportIndex */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {71,IR(0, 0),IR(8758, 18)/* UniformDecoration */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4165,IR(0, 0),IR(5471, 16)/* CoreBuiltinsARM */,IR(0, 0),IR(1, 0),IR(34, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4166,IR(0, 0),IR(8776, 28)/* TileImageColorReadAccessEXT */,IR(0, 0),IR(1, 0),IR(35, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4167,IR(0, 0),IR(8804, 28)/* TileImageDepthReadAccessEXT */,IR(0, 0),IR(1, 0),IR(35, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4168,IR(0, 0),IR(8832, 30)/* TileImageStencilReadAccessEXT */,IR(0, 0),IR(1, 0),IR(35, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4174,IR(0, 0),IR(8862, 11)/* TensorsARM */,IR(0, 0),IR(1, 0),IR(36, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4175,IR(0, 0),IR(8873, 37)/* StorageTensorArrayDynamicIndexingARM */,IR(0, 0),IR(1, 0),IR(36, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4176,IR(0, 0),IR(8910, 40)/* StorageTensorArrayNonUniformIndexingARM */,IR(0, 0),IR(1, 0),IR(36, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4201,IR(0, 0),IR(8950, 28)/* CooperativeMatrixLayoutsARM */,IR(0, 0),IR(1, 0),IR(37, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4212,IR(0, 0),IR(8978, 10)/* Float8EXT */,IR(0, 0),IR(1, 0),IR(38, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4213,IR(0, 0),IR(8988, 27)/* Float8CooperativeMatrixEXT */,IR(0, 0),IR(1, 0),IR(38, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4422,IR(0, 0),IR(5796, 23)/* FragmentShadingRateKHR */,IR(0, 0),IR(3, 1),IR(7, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4423,IR(0, 0),IR(5330, 18)/* SubgroupBallotKHR */,IR(0, 0),IR(1, 0),IR(2, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4427,IR(0, 0),IR(5734, 15)/* DrawParameters */,IR(0, 0),IR(3, 1),IR(3, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4428,IR(0, 0),IR(9015, 33)/* WorkgroupMemoryExplicitLayoutKHR */,IR(0, 0),IR(3, 1),IR(39, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4429,IR(0, 0),IR(9048, 43)/* WorkgroupMemoryExplicitLayout8BitAccessKHR */,IR(0, 0),IR(77, 1),IR(39, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4430,IR(0, 0),IR(9091, 44)/* WorkgroupMemoryExplicitLayout16BitAccessKHR */,IR(0, 0),IR(77, 1),IR(39, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4431,IR(0, 0),IR(9135, 16)/* SubgroupVoteKHR */,IR(0, 0),IR(1, 0),IR(40, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4433,IR(0, 0),IR(9151, 25)/* StorageBuffer16BitAccess */,IR(23, 1),IR(1, 0),IR(41, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4434,IR(0, 0),IR(9204, 35)/* UniformAndStorageBuffer16BitAccess */,IR(24, 1),IR(78, 1),IR(41, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4435,IR(0, 0),IR(9256, 22)/* StoragePushConstant16 */,IR(0, 0),IR(1, 0),IR(41, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4436,IR(0, 0),IR(9278, 21)/* StorageInputOutput16 */,IR(0, 0),IR(1, 0),IR(41, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4437,IR(0, 0),IR(5831, 12)/* DeviceGroup */,IR(0, 0),IR(1, 0),IR(8, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4439,IR(0, 0),IR(5853, 10)/* MultiView */,IR(0, 0),IR(3, 1),IR(9, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4441,IR(0, 0),IR(9299, 30)/* VariablePointersStorageBuffer */,IR(0, 0),IR(3, 1),IR(42, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4442,IR(0, 0),IR(9329, 17)/* VariablePointers */,IR(0, 0),IR(79, 1),IR(42, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4445,IR(0, 0),IR(9346, 17)/* AtomicStorageOps */,IR(0, 0),IR(80, 1),IR(43, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4447,IR(0, 0),IR(9363, 28)/* SampleMaskPostDepthCoverage */,IR(0, 0),IR(1, 0),IR(44, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4448,IR(0, 0),IR(9391, 24)/* StorageBuffer8BitAccess */,IR(0, 0),IR(1, 0),IR(45, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4449,IR(0, 0),IR(9415, 34)/* UniformAndStorageBuffer8BitAccess */,IR(0, 0),IR(81, 1),IR(45, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4450,IR(0, 0),IR(9449, 21)/* StoragePushConstant8 */,IR(0, 0),IR(1, 0),IR(45, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4464,IR(0, 0),IR(9470, 15)/* DenormPreserve */,IR(0, 0),IR(1, 0),IR(46, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4465,IR(0, 0),IR(9485, 18)/* DenormFlushToZero */,IR(0, 0),IR(1, 0),IR(46, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4466,IR(0, 0),IR(9503, 25)/* SignedZeroInfNanPreserve */,IR(0, 0),IR(1, 0),IR(46, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4467,IR(0, 0),IR(9528, 16)/* RoundingModeRTE */,IR(0, 0),IR(1, 0),IR(46, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4468,IR(0, 0),IR(9544, 16)/* RoundingModeRTZ */,IR(0, 0),IR(1, 0),IR(46, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4471,IR(0, 0),IR(9560, 23)/* RayQueryProvisionalKHR */,IR(0, 0),IR(3, 1),IR(47, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4472,IR(0, 0),IR(9583, 12)/* RayQueryKHR */,IR(0, 0),IR(3, 1),IR(47, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4473,IR(0, 0),IR(9595, 19)/* UntypedPointersKHR */,IR(0, 0),IR(1, 0),IR(48, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4478,IR(0, 0),IR(9614, 32)/* RayTraversalPrimitiveCullingKHR */,IR(0, 0),IR(82, 2),IR(49, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4479,IR(0, 0),IR(4817, 14)/* RayTracingKHR */,IR(0, 0),IR(3, 1),IR(28, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4484,IR(0, 0),IR(9646, 26)/* TextureSampleWeightedQCOM */,IR(0, 0),IR(1, 0),IR(51, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4485,IR(0, 0),IR(9672, 21)/* TextureBoxFilterQCOM */,IR(0, 0),IR(1, 0),IR(51, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4486,IR(0, 0),IR(9693, 22)/* TextureBlockMatchQCOM */,IR(0, 0),IR(1, 0),IR(51, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4495,IR(0, 0),IR(5893, 16)/* TileShadingQCOM */,IR(0, 0),IR(3, 1),IR(52, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {4498,IR(0, 0),IR(9715, 23)/* TextureBlockMatch2QCOM */,IR(0, 0),IR(1, 0),IR(53, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5008,IR(0, 0),IR(9738, 16)/* Float16ImageAMD */,IR(0, 0),IR(3, 1),IR(54, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5009,IR(0, 0),IR(9754, 22)/* ImageGatherBiasLodAMD */,IR(0, 0),IR(3, 1),IR(55, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5010,IR(0, 0),IR(9776, 16)/* FragmentMaskAMD */,IR(0, 0),IR(3, 1),IR(56, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5013,IR(0, 0),IR(6130, 17)/* StencilExportEXT */,IR(0, 0),IR(3, 1),IR(11, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5015,IR(0, 0),IR(9792, 21)/* ImageReadWriteLodAMD */,IR(0, 0),IR(3, 1),IR(57, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5016,IR(0, 0),IR(9813, 14)/* Int64ImageEXT */,IR(0, 0),IR(3, 1),IR(58, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5055,IR(0, 0),IR(9827, 15)/* ShaderClockKHR */,IR(0, 0),IR(1, 0),IR(59, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5067,IR(0, 0),IR(6176, 18)/* ShaderEnqueueAMDX */,IR(0, 0),IR(3, 1),IR(60, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5087,IR(0, 0),IR(9842, 15)/* QuadControlKHR */,IR(0, 0),IR(1, 0),IR(61, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5112,IR(0, 0),IR(9857, 14)/* Int4TypeINTEL */,IR(0, 0),IR(1, 0),IR(62, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5114,IR(0, 0),IR(9871, 27)/* Int4CooperativeMatrixINTEL */,IR(0, 0),IR(84, 2),IR(62, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5116,IR(0, 0),IR(9919, 16)/* BFloat16TypeKHR */,IR(0, 0),IR(1, 0),IR(63, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5117,IR(0, 0),IR(9935, 22)/* BFloat16DotProductKHR */,IR(0, 0),IR(86, 1),IR(63, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5118,IR(0, 0),IR(9957, 29)/* BFloat16CooperativeMatrixKHR */,IR(0, 0),IR(87, 2),IR(63, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5249,IR(0, 0),IR(9986, 29)/* SampleMaskOverrideCoverageNV */,IR(0, 0),IR(25, 1),IR(64, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5251,IR(0, 0),IR(10015, 28)/* GeometryShaderPassthroughNV */,IR(0, 0),IR(69, 1),IR(65, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5254,IR(0, 0),IR(4891, 28)/* ShaderViewportIndexLayerEXT */,IR(25, 1),IR(89, 1),IR(66, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5255,IR(0, 0),IR(6225, 21)/* ShaderViewportMaskNV */,IR(0, 0),IR(90, 1),IR(68, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5259,IR(0, 0),IR(6266, 19)/* ShaderStereoViewNV */,IR(0, 0),IR(91, 1),IR(14, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5260,IR(0, 0),IR(6327, 20)/* PerViewAttributesNV */,IR(0, 0),IR(40, 1),IR(69, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5265,IR(0, 0),IR(6385, 24)/* FragmentFullyCoveredEXT */,IR(0, 0),IR(3, 1),IR(17, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5266,IR(0, 0),IR(4831, 14)/* MeshShadingNV */,IR(0, 0),IR(3, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5282,IR(0, 0),IR(10070, 17)/* ImageFootprintNV */,IR(0, 0),IR(1, 0),IR(70, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5283,IR(0, 0),IR(4845, 15)/* MeshShadingEXT */,IR(0, 0),IR(3, 1),IR(23, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5284,IR(0, 0),IR(6575, 23)/* FragmentBarycentricKHR */,IR(26, 1),IR(1, 0),IR(19, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5288,IR(0, 0),IR(10109, 31)/* ComputeDerivativeGroupQuadsKHR */,IR(27, 1),IR(3, 1),IR(71, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5291,IR(0, 0),IR(6664, 19)/* FragmentDensityEXT */,IR(28, 1),IR(3, 1),IR(21, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5297,IR(0, 0),IR(10184, 29)/* GroupNonUniformPartitionedNV */,IR(0, 0),IR(1, 0),IR(73, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5301,IR(0, 0),IR(10213, 17)/* ShaderNonUniform */,IR(29, 1),IR(3, 1),IR(74, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5302,IR(0, 0),IR(10250, 23)/* RuntimeDescriptorArray */,IR(30, 1),IR(3, 1),IR(74, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5303,IR(0, 0),IR(10299, 36)/* InputAttachmentArrayDynamicIndexing */,IR(31, 1),IR(92, 1),IR(74, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5304,IR(0, 0),IR(10374, 39)/* UniformTexelBufferArrayDynamicIndexing */,IR(32, 1),IR(73, 1),IR(74, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5305,IR(0, 0),IR(10455, 39)/* StorageTexelBufferArrayDynamicIndexing */,IR(33, 1),IR(93, 1),IR(74, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5306,IR(0, 0),IR(10536, 37)/* UniformBufferArrayNonUniformIndexing */,IR(34, 1),IR(94, 1),IR(74, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5307,IR(0, 0),IR(10613, 36)/* SampledImageArrayNonUniformIndexing */,IR(35, 1),IR(94, 1),IR(74, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5308,IR(0, 0),IR(10688, 37)/* StorageBufferArrayNonUniformIndexing */,IR(36, 1),IR(94, 1),IR(74, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5309,IR(0, 0),IR(10765, 36)/* StorageImageArrayNonUniformIndexing */,IR(37, 1),IR(94, 1),IR(74, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5310,IR(0, 0),IR(10840, 39)/* InputAttachmentArrayNonUniformIndexing */,IR(38, 1),IR(95, 2),IR(74, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5311,IR(0, 0),IR(10921, 42)/* UniformTexelBufferArrayNonUniformIndexing */,IR(39, 1),IR(97, 2),IR(74, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5312,IR(0, 0),IR(11008, 42)/* StorageTexelBufferArrayNonUniformIndexing */,IR(40, 1),IR(99, 2),IR(74, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5336,IR(0, 0),IR(7279, 27)/* RayTracingPositionFetchKHR */,IR(0, 0),IR(3, 1),IR(75, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5340,IR(0, 0),IR(4804, 13)/* RayTracingNV */,IR(0, 0),IR(3, 1),IR(26, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5341,IR(0, 0),IR(7226, 23)/* RayTracingMotionBlurNV */,IR(0, 0),IR(3, 1),IR(27, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5345,IR(0, 0),IR(11095, 18)/* VulkanMemoryModel */,IR(41, 1),IR(1, 0),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5346,IR(0, 0),IR(11134, 29)/* VulkanMemoryModelDeviceScope */,IR(42, 1),IR(1, 0),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5347,IR(0, 0),IR(4667, 31)/* PhysicalStorageBufferAddresses */,IR(43, 1),IR(3, 1),IR(0, 2),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5350,IR(0, 0),IR(11229, 32)/* ComputeDerivativeGroupLinearKHR */,IR(44, 1),IR(3, 1),IR(71, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5353,IR(0, 0),IR(11292, 25)/* RayTracingProvisionalKHR */,IR(0, 0),IR(3, 1),IR(28, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5357,IR(0, 0),IR(11317, 20)/* CooperativeMatrixNV */,IR(0, 0),IR(3, 1),IR(77, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5363,IR(0, 0),IR(11337, 33)/* FragmentShaderSampleInterlockEXT */,IR(0, 0),IR(3, 1),IR(78, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5372,IR(0, 0),IR(11370, 38)/* FragmentShaderShadingRateInterlockEXT */,IR(0, 0),IR(3, 1),IR(78, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5373,IR(0, 0),IR(7594, 19)/* ShaderSMBuiltinsNV */,IR(0, 0),IR(3, 1),IR(30, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5378,IR(0, 0),IR(11408, 32)/* FragmentShaderPixelInterlockEXT */,IR(0, 0),IR(3, 1),IR(78, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5379,IR(0, 0),IR(11440, 25)/* DemoteToHelperInvocation */,IR(45, 1),IR(3, 1),IR(79, 1),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5380,IR(0, 0),IR(11493, 23)/* DisplacementMicromapNV */,IR(0, 0),IR(3, 1),IR(80, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5381,IR(0, 0),IR(11516, 29)/* RayTracingOpacityMicromapEXT */,IR(0, 0),IR(3, 1),IR(81, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5383,IR(0, 0),IR(11545, 26)/* ShaderInvocationReorderNV */,IR(0, 0),IR(60, 1),IR(82, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5390,IR(0, 0),IR(11571, 18)/* BindlessTextureNV */,IR(0, 0),IR(1, 0),IR(83, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5391,IR(0, 0),IR(11589, 25)/* RayQueryPositionFetchKHR */,IR(0, 0),IR(3, 1),IR(75, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5394,IR(0, 0),IR(11614, 20)/* CooperativeVectorNV */,IR(0, 0),IR(1, 0),IR(84, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5404,IR(0, 0),IR(11634, 22)/* AtomicFloat16VectorNV */,IR(0, 0),IR(1, 0),IR(85, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5409,IR(0, 0),IR(7340, 33)/* RayTracingDisplacementMicromapNV */,IR(0, 0),IR(60, 1),IR(80, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5414,IR(0, 0),IR(11656, 18)/* RawAccessChainsNV */,IR(0, 0),IR(1, 0),IR(86, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5418,IR(0, 0),IR(7483, 28)/* RayTracingSpheresGeometryNV */,IR(0, 0),IR(1, 0),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5419,IR(0, 0),IR(7522, 39)/* RayTracingLinearSweptSpheresGeometryNV */,IR(0, 0),IR(1, 0),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5430,IR(0, 0),IR(11674, 30)/* CooperativeMatrixReductionsNV */,IR(0, 0),IR(1, 0),IR(87, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5431,IR(0, 0),IR(11704, 31)/* CooperativeMatrixConversionsNV */,IR(0, 0),IR(1, 0),IR(87, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5432,IR(0, 0),IR(11735, 40)/* CooperativeMatrixPerElementOperationsNV */,IR(0, 0),IR(1, 0),IR(87, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5433,IR(0, 0),IR(11775, 36)/* CooperativeMatrixTensorAddressingNV */,IR(0, 0),IR(1, 0),IR(87, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5434,IR(0, 0),IR(11811, 30)/* CooperativeMatrixBlockLoadsNV */,IR(0, 0),IR(1, 0),IR(87, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5435,IR(0, 0),IR(11841, 28)/* CooperativeVectorTrainingNV */,IR(0, 0),IR(1, 0),IR(84, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5437,IR(0, 0),IR(7768, 41)/* RayTracingClusterAccelerationStructureNV */,IR(0, 0),IR(60, 1),IR(31, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5439,IR(0, 0),IR(11869, 19)/* TensorAddressingNV */,IR(0, 0),IR(1, 0),IR(88, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5568,IR(0, 0),IR(11888, 21)/* SubgroupShuffleINTEL */,IR(0, 0),IR(1, 0),IR(89, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5569,IR(0, 0),IR(11909, 27)/* SubgroupBufferBlockIOINTEL */,IR(0, 0),IR(1, 0),IR(89, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5570,IR(0, 0),IR(11936, 26)/* SubgroupImageBlockIOINTEL */,IR(0, 0),IR(1, 0),IR(89, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5579,IR(0, 0),IR(11962, 31)/* SubgroupImageMediaBlockIOINTEL */,IR(0, 0),IR(1, 0),IR(90, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5582,IR(0, 0),IR(11993, 21)/* RoundToInfinityINTEL */,IR(0, 0),IR(1, 0),IR(91, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5583,IR(0, 0),IR(12014, 23)/* FloatingPointModeINTEL */,IR(0, 0),IR(1, 0),IR(91, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5584,IR(0, 0),IR(12037, 23)/* IntegerFunctions2INTEL */,IR(0, 0),IR(1, 0),IR(92, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5603,IR(0, 0),IR(12060, 22)/* FunctionPointersINTEL */,IR(0, 0),IR(1, 0),IR(93, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5604,IR(0, 0),IR(12082, 24)/* IndirectReferencesINTEL */,IR(0, 0),IR(1, 0),IR(93, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5606,IR(0, 0),IR(12106, 9)/* AsmINTEL */,IR(0, 0),IR(1, 0),IR(94, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5612,IR(0, 0),IR(12115, 23)/* AtomicFloat32MinMaxEXT */,IR(0, 0),IR(1, 0),IR(95, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5613,IR(0, 0),IR(12138, 23)/* AtomicFloat64MinMaxEXT */,IR(0, 0),IR(1, 0),IR(95, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5616,IR(0, 0),IR(12161, 23)/* AtomicFloat16MinMaxEXT */,IR(0, 0),IR(1, 0),IR(95, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5617,IR(0, 0),IR(12184, 19)/* VectorComputeINTEL */,IR(0, 0),IR(101, 1),IR(96, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5619,IR(0, 0),IR(12203, 15)/* VectorAnyINTEL */,IR(0, 0),IR(1, 0),IR(96, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5629,IR(0, 0),IR(12218, 16)/* ExpectAssumeKHR */,IR(0, 0),IR(1, 0),IR(97, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5696,IR(0, 0),IR(12234, 33)/* SubgroupAvcMotionEstimationINTEL */,IR(0, 0),IR(1, 0),IR(98, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5697,IR(0, 0),IR(12267, 38)/* SubgroupAvcMotionEstimationIntraINTEL */,IR(0, 0),IR(1, 0),IR(98, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5698,IR(0, 0),IR(12305, 39)/* SubgroupAvcMotionEstimationChromaINTEL */,IR(0, 0),IR(1, 0),IR(98, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5817,IR(0, 0),IR(12344, 25)/* VariableLengthArrayINTEL */,IR(0, 0),IR(1, 0),IR(99, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5821,IR(0, 0),IR(12369, 26)/* FunctionFloatControlINTEL */,IR(0, 0),IR(1, 0),IR(91, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5824,IR(0, 0),IR(12395, 26)/* FPGAMemoryAttributesINTEL */,IR(0, 0),IR(1, 0),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5837,IR(0, 0),IR(12421, 20)/* FPFastMathModeINTEL */,IR(0, 0),IR(0, 1),IR(101, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5844,IR(0, 0),IR(12441, 32)/* ArbitraryPrecisionIntegersINTEL */,IR(0, 0),IR(1, 0),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5845,IR(0, 0),IR(12473, 37)/* ArbitraryPrecisionFloatingPointINTEL */,IR(0, 0),IR(1, 0),IR(103, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5886,IR(0, 0),IR(12510, 30)/* UnstructuredLoopControlsINTEL */,IR(0, 0),IR(1, 0),IR(104, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5888,IR(0, 0),IR(12540, 22)/* FPGALoopControlsINTEL */,IR(0, 0),IR(1, 0),IR(105, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5892,IR(0, 0),IR(12562, 22)/* KernelAttributesINTEL */,IR(0, 0),IR(1, 0),IR(106, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5897,IR(0, 0),IR(12584, 26)/* FPGAKernelAttributesINTEL */,IR(0, 0),IR(1, 0),IR(106, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5898,IR(0, 0),IR(12610, 24)/* FPGAMemoryAccessesINTEL */,IR(0, 0),IR(1, 0),IR(107, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5904,IR(0, 0),IR(12634, 27)/* FPGAClusterAttributesINTEL */,IR(0, 0),IR(1, 0),IR(108, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5906,IR(0, 0),IR(12661, 14)/* LoopFuseINTEL */,IR(0, 0),IR(1, 0),IR(109, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5908,IR(0, 0),IR(12675, 20)/* FPGADSPControlINTEL */,IR(0, 0),IR(1, 0),IR(110, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5910,IR(0, 0),IR(12695, 26)/* MemoryAccessAliasingINTEL */,IR(0, 0),IR(1, 0),IR(111, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5916,IR(0, 0),IR(12721, 40)/* FPGAInvocationPipeliningAttributesINTEL */,IR(0, 0),IR(1, 0),IR(112, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5920,IR(0, 0),IR(12761, 24)/* FPGABufferLocationINTEL */,IR(0, 0),IR(1, 0),IR(113, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5922,IR(0, 0),IR(12785, 34)/* ArbitraryPrecisionFixedPointINTEL */,IR(0, 0),IR(1, 0),IR(114, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5935,IR(0, 0),IR(12819, 23)/* USMStorageClassesINTEL */,IR(0, 0),IR(1, 0),IR(115, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5939,IR(0, 0),IR(12842, 29)/* RuntimeAlignedAttributeINTEL */,IR(0, 0),IR(1, 0),IR(116, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5943,IR(0, 0),IR(12871, 13)/* IOPipesINTEL */,IR(0, 0),IR(1, 0),IR(117, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5945,IR(0, 0),IR(12884, 19)/* BlockingPipesINTEL */,IR(0, 0),IR(1, 0),IR(118, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {5948,IR(0, 0),IR(12903, 13)/* FPGARegINTEL */,IR(0, 0),IR(1, 0),IR(119, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6016,IR(0, 0),IR(12916, 19)/* DotProductInputAll */,IR(46, 1),IR(1, 0),IR(120, 1),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6017,IR(0, 0),IR(12957, 22)/* DotProductInput4x8Bit */,IR(47, 1),IR(102, 1),IR(120, 1),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6018,IR(0, 0),IR(13004, 28)/* DotProductInput4x8BitPacked */,IR(48, 1),IR(1, 0),IR(120, 1),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6019,IR(0, 0),IR(13063, 11)/* DotProduct */,IR(49, 1),IR(1, 0),IR(120, 1),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6020,IR(0, 0),IR(7821, 15)/* RayCullMaskKHR */,IR(0, 0),IR(1, 0),IR(32, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6022,IR(0, 0),IR(9898, 21)/* CooperativeMatrixKHR */,IR(0, 0),IR(1, 0),IR(121, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6024,IR(0, 0),IR(13088, 24)/* ReplicatedCompositesEXT */,IR(0, 0),IR(1, 0),IR(122, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6025,IR(0, 0),IR(13112, 16)/* BitInstructions */,IR(0, 0),IR(1, 0),IR(123, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6026,IR(0, 0),IR(13128, 25)/* GroupNonUniformRotateKHR */,IR(0, 0),IR(76, 1),IR(124, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6029,IR(0, 0),IR(13153, 15)/* FloatControls2 */,IR(0, 0),IR(1, 0),IR(125, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6033,IR(0, 0),IR(13168, 20)/* AtomicFloat32AddEXT */,IR(0, 0),IR(1, 0),IR(126, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6034,IR(0, 0),IR(13188, 20)/* AtomicFloat64AddEXT */,IR(0, 0),IR(1, 0),IR(126, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6089,IR(0, 0),IR(13208, 20)/* LongCompositesINTEL */,IR(0, 0),IR(1, 0),IR(127, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6094,IR(0, 0),IR(13228, 11)/* OptNoneEXT */,IR(50, 1),IR(1, 0),IR(128, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6095,IR(0, 0),IR(13252, 20)/* AtomicFloat16AddEXT */,IR(0, 0),IR(1, 0),IR(130, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6114,IR(0, 0),IR(13272, 21)/* DebugInfoModuleINTEL */,IR(0, 0),IR(1, 0),IR(131, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6115,IR(0, 0),IR(13293, 24)/* BFloat16ConversionINTEL */,IR(0, 0),IR(1, 0),IR(132, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6141,IR(0, 0),IR(13317, 18)/* SplitBarrierINTEL */,IR(0, 0),IR(1, 0),IR(133, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6144,IR(0, 0),IR(13335, 19)/* ArithmeticFenceEXT */,IR(0, 0),IR(1, 0),IR(134, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6150,IR(0, 0),IR(13354, 29)/* FPGAClusterAttributesV2INTEL */,IR(0, 0),IR(103, 1),IR(108, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6161,IR(0, 0),IR(13383, 28)/* FPGAKernelAttributesv2INTEL */,IR(0, 0),IR(104, 1),IR(106, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6162,IR(0, 0),IR(13411, 18)/* TaskSequenceINTEL */,IR(0, 0),IR(1, 0),IR(135, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6169,IR(0, 0),IR(13429, 16)/* FPMaxErrorINTEL */,IR(0, 0),IR(1, 0),IR(136, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6171,IR(0, 0),IR(13445, 24)/* FPGALatencyControlINTEL */,IR(0, 0),IR(1, 0),IR(137, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6174,IR(0, 0),IR(13469, 28)/* FPGAArgumentInterfacesINTEL */,IR(0, 0),IR(1, 0),IR(138, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6187,IR(0, 0),IR(13497, 30)/* GlobalVariableHostAccessINTEL */,IR(0, 0),IR(1, 0),IR(139, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6189,IR(0, 0),IR(13527, 35)/* GlobalVariableFPGADecorationsINTEL */,IR(0, 0),IR(1, 0),IR(140, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6220,IR(0, 0),IR(13562, 28)/* SubgroupBufferPrefetchINTEL */,IR(0, 0),IR(1, 0),IR(141, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6228,IR(0, 0),IR(13590, 23)/* Subgroup2DBlockIOINTEL */,IR(0, 0),IR(1, 0),IR(142, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6229,IR(0, 0),IR(13613, 30)/* Subgroup2DBlockTransformINTEL */,IR(0, 0),IR(105, 1),IR(142, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6230,IR(0, 0),IR(13643, 30)/* Subgroup2DBlockTransposeINTEL */,IR(0, 0),IR(105, 1),IR(142, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6236,IR(0, 0),IR(13673, 38)/* SubgroupMatrixMultiplyAccumulateINTEL */,IR(0, 0),IR(1, 0),IR(143, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6241,IR(0, 0),IR(13711, 28)/* TernaryBitwiseFunctionINTEL */,IR(0, 0),IR(1, 0),IR(144, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6400,IR(0, 0),IR(13739, 26)/* GroupUniformArithmeticKHR */,IR(0, 0),IR(1, 0),IR(145, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6425,IR(0, 0),IR(13765, 27)/* TensorFloat32RoundingINTEL */,IR(0, 0),IR(1, 0),IR(146, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6427,IR(0, 0),IR(13792, 25)/* MaskedGatherScatterINTEL */,IR(0, 0),IR(1, 0),IR(147, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6441,IR(0, 0),IR(13817, 19)/* CacheControlsINTEL */,IR(0, 0),IR(1, 0),IR(148, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6460,IR(0, 0),IR(13836, 20)/* RegisterLimitsINTEL */,IR(0, 0),IR(1, 0),IR(149, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {6528,IR(0, 0),IR(13856, 20)/* BindlessImagesINTEL */,IR(0, 0),IR(1, 0),IR(150, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY - {0,IR(0, 0),IR(13876, 12)/* Unspecified */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {1,IR(0, 0),IR(13888, 8)/* Address */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {2,IR(0, 0),IR(13896, 8)/* Boolean */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {3,IR(0, 0),IR(13904, 6)/* Float */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {4,IR(0, 0),IR(13910, 7)/* Signed */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {5,IR(0, 0),IR(13917, 11)/* SignedChar */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {6,IR(0, 0),IR(13928, 9)/* Unsigned */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {7,IR(0, 0),IR(13937, 13)/* UnsignedChar */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {0,IR(0, 0),IR(13950, 6)/* Class */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE - {1,IR(0, 0),IR(13956, 10)/* Structure */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE - {2,IR(0, 0),IR(13966, 6)/* Union */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE - {0,IR(0, 0),IR(13972, 15)/* ImportedModule */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY - {1,IR(0, 0),IR(13987, 20)/* ImportedDeclaration */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {1,IR(0, 0),IR(14012, 16)/* FlagIsProtected */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {2,IR(0, 0),IR(14028, 14)/* FlagIsPrivate */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {3,IR(0, 0),IR(14042, 13)/* FlagIsPublic */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {4,IR(0, 0),IR(14055, 12)/* FlagIsLocal */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {8,IR(0, 0),IR(14067, 17)/* FlagIsDefinition */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {16,IR(0, 0),IR(14084, 12)/* FlagFwdDecl */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {32,IR(0, 0),IR(14096, 15)/* FlagArtificial */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {64,IR(0, 0),IR(14111, 13)/* FlagExplicit */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {128,IR(0, 0),IR(14124, 15)/* FlagPrototyped */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {256,IR(0, 0),IR(14139, 18)/* FlagObjectPointer */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {512,IR(0, 0),IR(14157, 17)/* FlagStaticMember */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {1024,IR(0, 0),IR(14174, 21)/* FlagIndirectVariable */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {2048,IR(0, 0),IR(14195, 20)/* FlagLValueReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {4096,IR(0, 0),IR(14215, 20)/* FlagRValueReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {8192,IR(0, 0),IR(14235, 16)/* FlagIsOptimized */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {16384,IR(0, 0),IR(14251, 16)/* FlagIsEnumClass */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {32768,IR(0, 0),IR(14267, 20)/* FlagTypePassByValue */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {65536,IR(0, 0),IR(14287, 24)/* FlagTypePassByReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {0,IR(0, 0),IR(14311, 6)/* Deref */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {1,IR(0, 0),IR(14317, 5)/* Plus */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {2,IR(0, 0),IR(14322, 6)/* Minus */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {3,IR(0, 1),IR(14361, 11)/* PlusUconst */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {4,IR(1, 2),IR(14372, 9)/* BitPiece */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {5,IR(0, 0),IR(14381, 5)/* Swap */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {6,IR(0, 0),IR(14386, 7)/* Xderef */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {7,IR(0, 0),IR(14393, 11)/* StackValue */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {8,IR(0, 1),IR(14404, 7)/* Constu */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {9,IR(1, 2),IR(14411, 9)/* Fragment */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {0,IR(0, 0),IR(14420, 10)/* ConstType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER - {1,IR(0, 0),IR(14430, 13)/* VolatileType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER - {2,IR(0, 0),IR(14443, 13)/* RestrictType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER - {3,IR(0, 0),IR(14456, 11)/* AtomicType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER - {0,IR(0, 0),IR(14467, 10)/* Float16NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {1,IR(0, 0),IR(14477, 10)/* Float32NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {2,IR(0, 0),IR(14487, 10)/* Float64NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {3,IR(0, 0),IR(14497, 13)/* SignedInt8NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {4,IR(0, 0),IR(14510, 14)/* SignedInt16NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {5,IR(0, 0),IR(14524, 14)/* SignedInt32NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {6,IR(0, 0),IR(14538, 14)/* SignedInt64NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {7,IR(0, 0),IR(14552, 15)/* UnsignedInt8NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {8,IR(0, 0),IR(14567, 16)/* UnsignedInt16NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {9,IR(0, 0),IR(14583, 16)/* UnsignedInt32NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {10,IR(0, 0),IR(14599, 16)/* UnsignedInt64NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {1000491000,IR(0, 0),IR(14615, 19)/* SignedInt8PackedNV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {1000491001,IR(0, 0),IR(14634, 21)/* UnsignedInt8PackedNV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {1000491002,IR(0, 0),IR(14655, 12)/* FloatE4M3NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {1000491003,IR(0, 0),IR(14667, 12)/* FloatE5M2NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE - {0,IR(0, 0),IR(14679, 12)/* RowMajorKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT - {1,IR(0, 0),IR(14691, 15)/* ColumnMajorKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT - {4202,IR(0, 0),IR(14706, 25)/* RowBlockedInterleavedARM */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT - {4203,IR(0, 0),IR(14731, 28)/* ColumnBlockedInterleavedARM */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT - {0,IR(0, 0),IR(14759, 8)/* NoneKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS - {1,IR(0, 0),IR(14767, 27)/* MatrixASignedComponentsKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS - {2,IR(0, 0),IR(14794, 27)/* MatrixBSignedComponentsKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS - {4,IR(0, 0),IR(14821, 27)/* MatrixCSignedComponentsKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS - {8,IR(0, 0),IR(14848, 32)/* MatrixResultSignedComponentsKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS - {16,IR(0, 0),IR(14880, 26)/* SaturatingAccumulationKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS - {1,IR(0, 0),IR(14906, 4)/* Row */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE - {2,IR(0, 0),IR(14910, 7)/* Column */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE - {4,IR(0, 0),IR(14917, 4)/* 2x2 */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE - {0,IR(0, 0),IR(14921, 11)/* MatrixAKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE - {1,IR(0, 0),IR(14932, 11)/* MatrixBKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE - {2,IR(0, 0),IR(14943, 21)/* MatrixAccumulatorKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE - {0,IR(0, 0),IR(14964, 11)/* RowMajorNV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT - {1,IR(0, 0),IR(14975, 14)/* ColumnMajorNV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT - {2,IR(0, 0),IR(14989, 21)/* InferencingOptimalNV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT - {3,IR(0, 0),IR(15010, 18)/* TrainingOptimalNV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT - {0,IR(0, 0),IR(13876, 12)/* Unspecified */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {1,IR(0, 0),IR(13888, 8)/* Address */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {2,IR(0, 0),IR(13896, 8)/* Boolean */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {4,IR(0, 0),IR(13904, 6)/* Float */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {5,IR(0, 0),IR(13910, 7)/* Signed */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {6,IR(0, 0),IR(13917, 11)/* SignedChar */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {7,IR(0, 0),IR(13928, 9)/* Unsigned */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {8,IR(0, 0),IR(13937, 13)/* UnsignedChar */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {0,IR(0, 0),IR(13950, 6)/* Class */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE - {1,IR(0, 0),IR(13956, 10)/* Structure */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE - {2,IR(0, 0),IR(13966, 6)/* Union */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {1,IR(0, 0),IR(14012, 16)/* FlagIsProtected */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {2,IR(0, 0),IR(14028, 14)/* FlagIsPrivate */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {3,IR(0, 0),IR(14042, 13)/* FlagIsPublic */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {4,IR(0, 0),IR(14055, 12)/* FlagIsLocal */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {8,IR(0, 0),IR(14067, 17)/* FlagIsDefinition */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {16,IR(0, 0),IR(14084, 12)/* FlagFwdDecl */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {32,IR(0, 0),IR(14096, 15)/* FlagArtificial */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {64,IR(0, 0),IR(14111, 13)/* FlagExplicit */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {128,IR(0, 0),IR(14124, 15)/* FlagPrototyped */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {256,IR(0, 0),IR(14139, 18)/* FlagObjectPointer */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {512,IR(0, 0),IR(14157, 17)/* FlagStaticMember */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {1024,IR(0, 0),IR(14174, 21)/* FlagIndirectVariable */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {2048,IR(0, 0),IR(14195, 20)/* FlagLValueReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {4096,IR(0, 0),IR(14215, 20)/* FlagRValueReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {8192,IR(0, 0),IR(14235, 16)/* FlagIsOptimized */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {0,IR(0, 0),IR(14311, 6)/* Deref */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION - {1,IR(0, 0),IR(14317, 5)/* Plus */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION - {2,IR(0, 0),IR(14322, 6)/* Minus */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION - {3,IR(0, 1),IR(14361, 11)/* PlusUconst */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION - {4,IR(1, 2),IR(14372, 9)/* BitPiece */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION - {5,IR(0, 0),IR(14381, 5)/* Swap */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION - {6,IR(0, 0),IR(14386, 7)/* Xderef */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION - {7,IR(0, 0),IR(14393, 11)/* StackValue */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION - {8,IR(0, 1),IR(14404, 7)/* Constu */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION - {0,IR(0, 0),IR(14420, 10)/* ConstType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER - {1,IR(0, 0),IR(14430, 13)/* VolatileType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER - {2,IR(0, 0),IR(14443, 13)/* RestrictType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER - {0,IR(0, 0),IR(15028, 17)/* RelaxedPrecision */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {1,IR(0, 1),IR(15045, 7)/* SpecId */,IR(0, 0),IR(106, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {2,IR(0, 0),IR(15052, 6)/* Block */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {3,IR(0, 0),IR(15058, 12)/* BufferBlock */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),SPV_SPIRV_VERSION_WORD(1,3)}, // SPV_OPERAND_TYPE_DECORATION - {4,IR(0, 0),IR(15070, 9)/* RowMajor */,IR(0, 0),IR(66, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5,IR(0, 0),IR(15079, 9)/* ColMajor */,IR(0, 0),IR(66, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6,IR(0, 1),IR(15088, 12)/* ArrayStride */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {7,IR(0, 1),IR(15100, 13)/* MatrixStride */,IR(0, 0),IR(66, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {8,IR(0, 0),IR(15113, 11)/* GLSLShared */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {9,IR(0, 0),IR(15124, 11)/* GLSLPacked */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {10,IR(0, 0),IR(15135, 8)/* CPacked */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {11,IR(3, 1),IR(15169, 8)/* BuiltIn */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {13,IR(0, 0),IR(15177, 14)/* NoPerspective */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {14,IR(0, 0),IR(15191, 5)/* Flat */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {15,IR(0, 0),IR(15196, 6)/* Patch */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {16,IR(0, 0),IR(15202, 9)/* Centroid */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {17,IR(0, 0),IR(15211, 7)/* Sample */,IR(0, 0),IR(25, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {18,IR(0, 0),IR(15218, 10)/* Invariant */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {19,IR(0, 0),IR(15228, 9)/* Restrict */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {20,IR(0, 0),IR(15237, 8)/* Aliased */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {21,IR(0, 0),IR(15245, 9)/* Volatile */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {22,IR(0, 0),IR(15254, 9)/* Constant */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {23,IR(0, 0),IR(15263, 9)/* Coherent */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {24,IR(0, 0),IR(15272, 12)/* NonWritable */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {25,IR(0, 0),IR(15284, 12)/* NonReadable */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {26,IR(0, 0),IR(15296, 8)/* Uniform */,IR(0, 0),IR(108, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {27,IR(4, 1),IR(15330, 10)/* UniformId */,IR(0, 0),IR(108, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {28,IR(0, 0),IR(15340, 20)/* SaturatedConversion */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {29,IR(0, 1),IR(15360, 7)/* Stream */,IR(0, 0),IR(110, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {30,IR(0, 1),IR(15367, 9)/* Location */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {31,IR(0, 1),IR(15376, 10)/* Component */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {32,IR(0, 1),IR(15386, 6)/* Index */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {33,IR(0, 1),IR(15392, 8)/* Binding */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {34,IR(0, 1),IR(15400, 14)/* DescriptorSet */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {35,IR(0, 1),IR(15414, 7)/* Offset */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {36,IR(0, 1),IR(15421, 10)/* XfbBuffer */,IR(0, 0),IR(111, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {37,IR(0, 1),IR(15431, 10)/* XfbStride */,IR(0, 0),IR(111, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {38,IR(5, 1),IR(15487, 14)/* FuncParamAttr */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {39,IR(6, 1),IR(15535, 15)/* FPRoundingMode */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {40,IR(7, 1),IR(15585, 15)/* FPFastMathMode */,IR(0, 0),IR(112, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {41,IR(8, 2),IR(15662, 18)/* LinkageAttributes */,IR(0, 0),IR(114, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {42,IR(0, 0),IR(15680, 14)/* NoContraction */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {43,IR(0, 1),IR(15694, 21)/* InputAttachmentIndex */,IR(0, 0),IR(92, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {44,IR(0, 1),IR(15715, 10)/* Alignment */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {45,IR(0, 1),IR(15725, 14)/* MaxByteOffset */,IR(0, 0),IR(1, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {46,IR(10, 1),IR(15759, 12)/* AlignmentId */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,2),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {47,IR(10, 1),IR(15771, 16)/* MaxByteOffsetId */,IR(0, 0),IR(1, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,2),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {4216,IR(0, 0),IR(15787, 44)/* SaturatedToLargestFloat8NormalConversionEXT */,IR(0, 0),IR(115, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {4469,IR(0, 0),IR(15831, 13)/* NoSignedWrap */,IR(0, 0),IR(1, 0),IR(151, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {4470,IR(0, 0),IR(15844, 15)/* NoUnsignedWrap */,IR(0, 0),IR(1, 0),IR(151, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {4487,IR(0, 0),IR(15859, 18)/* WeightTextureQCOM */,IR(0, 0),IR(1, 0),IR(51, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {4488,IR(0, 0),IR(15877, 22)/* BlockMatchTextureQCOM */,IR(0, 0),IR(1, 0),IR(51, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {4499,IR(0, 0),IR(15899, 22)/* BlockMatchSamplerQCOM */,IR(0, 0),IR(1, 0),IR(53, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {4999,IR(0, 0),IR(15921, 18)/* ExplicitInterpAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5019,IR(10, 1),IR(15939, 32)/* NodeSharesPayloadLimitsWithAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5020,IR(10, 1),IR(15971, 20)/* NodeMaxPayloadsAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5078,IR(0, 0),IR(15991, 23)/* TrackFinishWritingAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5091,IR(10, 1),IR(16014, 20)/* PayloadNodeNameAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5098,IR(10, 1),IR(16034, 25)/* PayloadNodeBaseIndexAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5099,IR(0, 0),IR(16059, 27)/* PayloadNodeSparseArrayAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5100,IR(10, 1),IR(16086, 25)/* PayloadNodeArraySizeAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5105,IR(0, 0),IR(16111, 28)/* PayloadDispatchIndirectAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5248,IR(0, 0),IR(16139, 19)/* OverrideCoverageNV */,IR(0, 0),IR(116, 1),IR(64, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5250,IR(0, 0),IR(16158, 14)/* PassthroughNV */,IR(0, 0),IR(117, 1),IR(65, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5252,IR(0, 0),IR(16172, 19)/* ViewportRelativeNV */,IR(0, 0),IR(91, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5256,IR(0, 1),IR(16191, 28)/* SecondaryViewportRelativeNV */,IR(0, 0),IR(46, 1),IR(14, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5271,IR(0, 0),IR(16219, 16)/* PerPrimitiveEXT */,IR(51, 1),IR(118, 2),IR(152, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5272,IR(0, 0),IR(16250, 10)/* PerViewNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5273,IR(0, 0),IR(16260, 10)/* PerTaskNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5285,IR(0, 0),IR(16270, 13)/* PerVertexKHR */,IR(52, 1),IR(51, 1),IR(19, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5300,IR(0, 0),IR(16295, 11)/* NonUniform */,IR(53, 1),IR(94, 1),IR(74, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5355,IR(0, 0),IR(16320, 16)/* RestrictPointer */,IR(54, 1),IR(2, 1),IR(0, 2),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5356,IR(0, 0),IR(16355, 15)/* AliasedPointer */,IR(55, 1),IR(2, 1),IR(0, 2),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5386,IR(0, 0),IR(16388, 30)/* HitObjectShaderRecordBufferNV */,IR(0, 0),IR(120, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5398,IR(0, 0),IR(16418, 18)/* BindlessSamplerNV */,IR(0, 0),IR(121, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5399,IR(0, 0),IR(16436, 16)/* BindlessImageNV */,IR(0, 0),IR(121, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5400,IR(0, 0),IR(16452, 15)/* BoundSamplerNV */,IR(0, 0),IR(121, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5401,IR(0, 0),IR(16467, 13)/* BoundImageNV */,IR(0, 0),IR(121, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5599,IR(0, 1),IR(16480, 14)/* SIMTCallINTEL */,IR(0, 0),IR(122, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5602,IR(0, 0),IR(16494, 26)/* ReferencedIndirectlyINTEL */,IR(0, 0),IR(123, 1),IR(93, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5607,IR(11, 1),IR(16520, 13)/* ClobberINTEL */,IR(0, 0),IR(124, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5608,IR(0, 0),IR(16533, 17)/* SideEffectsINTEL */,IR(0, 0),IR(124, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5624,IR(0, 0),IR(16550, 27)/* VectorComputeVariableINTEL */,IR(0, 0),IR(122, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5625,IR(0, 1),IR(16577, 21)/* FuncParamIOKindINTEL */,IR(0, 0),IR(122, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5626,IR(0, 0),IR(16598, 27)/* VectorComputeFunctionINTEL */,IR(0, 0),IR(122, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5627,IR(0, 0),IR(16625, 15)/* StackCallINTEL */,IR(0, 0),IR(122, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5628,IR(0, 1),IR(16640, 26)/* GlobalVariableOffsetINTEL */,IR(0, 0),IR(122, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5634,IR(10, 1),IR(16666, 14)/* CounterBuffer */,IR(56, 1),IR(1, 0),IR(154, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5635,IR(11, 1),IR(16704, 13)/* UserSemantic */,IR(57, 1),IR(1, 0),IR(154, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5636,IR(11, 1),IR(16736, 15)/* UserTypeGOOGLE */,IR(0, 0),IR(1, 0),IR(155, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5822,IR(12, 2),IR(16751, 26)/* FunctionRoundingModeINTEL */,IR(0, 0),IR(125, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5823,IR(14, 2),IR(16808, 24)/* FunctionDenormModeINTEL */,IR(0, 0),IR(125, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5825,IR(0, 0),IR(16832, 14)/* RegisterINTEL */,IR(0, 0),IR(126, 1),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5826,IR(11, 1),IR(16846, 12)/* MemoryINTEL */,IR(0, 0),IR(126, 1),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5827,IR(0, 1),IR(16858, 14)/* NumbanksINTEL */,IR(0, 0),IR(126, 1),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5828,IR(0, 1),IR(16872, 15)/* BankwidthINTEL */,IR(0, 0),IR(126, 1),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5829,IR(0, 1),IR(16887, 22)/* MaxPrivateCopiesINTEL */,IR(0, 0),IR(126, 1),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5830,IR(0, 0),IR(16909, 16)/* SinglepumpINTEL */,IR(0, 0),IR(126, 1),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5831,IR(0, 0),IR(16925, 16)/* DoublepumpINTEL */,IR(0, 0),IR(126, 1),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5832,IR(0, 1),IR(16941, 19)/* MaxReplicatesINTEL */,IR(0, 0),IR(126, 1),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5833,IR(0, 0),IR(16960, 20)/* SimpleDualPortINTEL */,IR(0, 0),IR(126, 1),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5834,IR(16, 2),IR(16980, 11)/* MergeINTEL */,IR(0, 0),IR(126, 1),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5835,IR(18, 1),IR(17033, 14)/* BankBitsINTEL */,IR(0, 0),IR(126, 1),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5836,IR(0, 1),IR(17047, 20)/* ForcePow2DepthINTEL */,IR(0, 0),IR(126, 1),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5883,IR(0, 1),IR(17067, 16)/* StridesizeINTEL */,IR(0, 0),IR(126, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5884,IR(0, 1),IR(17083, 14)/* WordsizeINTEL */,IR(0, 0),IR(126, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5885,IR(0, 0),IR(17097, 18)/* TrueDualPortINTEL */,IR(0, 0),IR(126, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5899,IR(0, 0),IR(17115, 19)/* BurstCoalesceINTEL */,IR(0, 0),IR(127, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5900,IR(0, 1),IR(17134, 15)/* CacheSizeINTEL */,IR(0, 0),IR(127, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5901,IR(0, 0),IR(17149, 28)/* DontStaticallyCoalesceINTEL */,IR(0, 0),IR(127, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5902,IR(0, 1),IR(17177, 14)/* PrefetchINTEL */,IR(0, 0),IR(127, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5905,IR(0, 0),IR(17191, 17)/* StallEnableINTEL */,IR(0, 0),IR(103, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5907,IR(0, 0),IR(17208, 25)/* FuseLoopsInFunctionINTEL */,IR(0, 0),IR(128, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5909,IR(1, 2),IR(17233, 19)/* MathOpDSPModeINTEL */,IR(0, 0),IR(129, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5914,IR(10, 1),IR(17252, 16)/* AliasScopeINTEL */,IR(0, 0),IR(130, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5915,IR(10, 1),IR(17268, 13)/* NoAliasINTEL */,IR(0, 0),IR(130, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5917,IR(0, 1),IR(17281, 24)/* InitiationIntervalINTEL */,IR(0, 0),IR(131, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5918,IR(0, 1),IR(17305, 20)/* MaxConcurrencyINTEL */,IR(0, 0),IR(131, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5919,IR(0, 1),IR(17325, 20)/* PipelineEnableINTEL */,IR(0, 0),IR(131, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5921,IR(0, 1),IR(17345, 20)/* BufferLocationINTEL */,IR(0, 0),IR(132, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {5944,IR(0, 1),IR(17365, 19)/* IOPipeStorageINTEL */,IR(0, 0),IR(133, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6080,IR(19, 2),IR(17418, 31)/* FunctionFloatingPointModeINTEL */,IR(0, 0),IR(125, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6085,IR(0, 0),IR(17449, 25)/* SingleElementVectorINTEL */,IR(0, 0),IR(122, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6087,IR(0, 0),IR(17474, 35)/* VectorComputeCallableFunctionINTEL */,IR(0, 0),IR(122, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6140,IR(0, 0),IR(17509, 18)/* MediaBlockIOINTEL */,IR(0, 0),IR(122, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6151,IR(0, 0),IR(17527, 15)/* StallFreeINTEL */,IR(0, 0),IR(134, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6170,IR(21, 1),IR(17573, 26)/* FPMaxErrorDecorationINTEL */,IR(0, 0),IR(135, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6172,IR(0, 1),IR(17599, 25)/* LatencyControlLabelINTEL */,IR(0, 0),IR(136, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6173,IR(22, 3),IR(17624, 30)/* LatencyControlConstraintINTEL */,IR(0, 0),IR(136, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6175,IR(0, 0),IR(17654, 27)/* ConduitKernelArgumentINTEL */,IR(0, 0),IR(137, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6176,IR(0, 0),IR(17681, 31)/* RegisterMapKernelArgumentINTEL */,IR(0, 0),IR(137, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6177,IR(0, 1),IR(17712, 33)/* MMHostInterfaceAddressWidthINTEL */,IR(0, 0),IR(137, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6178,IR(0, 1),IR(17745, 30)/* MMHostInterfaceDataWidthINTEL */,IR(0, 0),IR(137, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6179,IR(0, 1),IR(17775, 28)/* MMHostInterfaceLatencyINTEL */,IR(0, 0),IR(137, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6180,IR(25, 1),IR(17837, 34)/* MMHostInterfaceReadWriteModeINTEL */,IR(0, 0),IR(137, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6181,IR(0, 1),IR(17871, 29)/* MMHostInterfaceMaxBurstINTEL */,IR(0, 0),IR(137, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6182,IR(0, 1),IR(17900, 32)/* MMHostInterfaceWaitRequestINTEL */,IR(0, 0),IR(137, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6183,IR(0, 0),IR(17932, 26)/* StableKernelArgumentINTEL */,IR(0, 0),IR(137, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6188,IR(26, 2),IR(17997, 16)/* HostAccessINTEL */,IR(0, 0),IR(138, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6190,IR(28, 1),IR(18060, 14)/* InitModeINTEL */,IR(0, 0),IR(139, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6191,IR(0, 1),IR(18074, 28)/* ImplementInRegisterMapINTEL */,IR(0, 0),IR(139, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6442,IR(29, 2),IR(18138, 22)/* CacheControlLoadINTEL */,IR(0, 0),IR(140, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {6443,IR(31, 2),IR(18197, 23)/* CacheControlStoreINTEL */,IR(0, 0),IR(140, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION - {0,IR(0, 0),IR(18220, 3)/* 1D */,IR(0, 0),IR(72, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY - {1,IR(0, 0),IR(18223, 3)/* 2D */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY - {2,IR(0, 0),IR(18226, 3)/* 3D */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY - {3,IR(0, 0),IR(18229, 5)/* Cube */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY - {4,IR(0, 0),IR(18234, 5)/* Rect */,IR(0, 0),IR(71, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY - {5,IR(0, 0),IR(18239, 7)/* Buffer */,IR(0, 0),IR(73, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY - {6,IR(0, 0),IR(18246, 12)/* SubpassData */,IR(0, 0),IR(92, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY - {4173,IR(0, 0),IR(18258, 17)/* TileImageDataEXT */,IR(0, 0),IR(141, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY - {0,IR(0, 1),IR(18275, 12)/* Invocations */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {1,IR(0, 0),IR(18287, 13)/* SpacingEqual */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {2,IR(0, 0),IR(18300, 22)/* SpacingFractionalEven */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {3,IR(0, 0),IR(18322, 21)/* SpacingFractionalOdd */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {4,IR(0, 0),IR(18343, 14)/* VertexOrderCw */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5,IR(0, 0),IR(18357, 15)/* VertexOrderCcw */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {6,IR(0, 0),IR(18372, 19)/* PixelCenterInteger */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {7,IR(0, 0),IR(18391, 16)/* OriginUpperLeft */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {8,IR(0, 0),IR(18407, 16)/* OriginLowerLeft */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {9,IR(0, 0),IR(18423, 19)/* EarlyFragmentTests */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {10,IR(0, 0),IR(18442, 10)/* PointMode */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {11,IR(0, 0),IR(18452, 4)/* Xfb */,IR(0, 0),IR(111, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {12,IR(0, 0),IR(18456, 15)/* DepthReplacing */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {14,IR(0, 0),IR(18471, 13)/* DepthGreater */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {15,IR(0, 0),IR(18484, 10)/* DepthLess */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {16,IR(0, 0),IR(18494, 15)/* DepthUnchanged */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {17,IR(22, 3),IR(18509, 10)/* LocalSize */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {18,IR(22, 3),IR(18519, 14)/* LocalSizeHint */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {19,IR(0, 0),IR(18533, 12)/* InputPoints */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {20,IR(0, 0),IR(18545, 11)/* InputLines */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {21,IR(0, 0),IR(18556, 20)/* InputLinesAdjacency */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {22,IR(0, 0),IR(18576, 10)/* Triangles */,IR(0, 0),IR(12, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {23,IR(0, 0),IR(18586, 24)/* InputTrianglesAdjacency */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {24,IR(0, 0),IR(18610, 6)/* Quads */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {25,IR(0, 0),IR(18616, 9)/* Isolines */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {26,IR(0, 1),IR(18625, 15)/* OutputVertices */,IR(0, 0),IR(142, 4),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {27,IR(0, 0),IR(18640, 13)/* OutputPoints */,IR(0, 0),IR(146, 3),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {28,IR(0, 0),IR(18653, 16)/* OutputLineStrip */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {29,IR(0, 0),IR(18669, 20)/* OutputTriangleStrip */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {30,IR(0, 1),IR(18689, 12)/* VecTypeHint */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {31,IR(0, 0),IR(18701, 15)/* ContractionOff */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {33,IR(0, 0),IR(18716, 12)/* Initializer */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {34,IR(0, 0),IR(18728, 10)/* Finalizer */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {35,IR(0, 1),IR(5301, 13)/* SubgroupSize */,IR(0, 0),IR(149, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {36,IR(0, 1),IR(18738, 22)/* SubgroupsPerWorkgroup */,IR(0, 0),IR(149, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {37,IR(10, 1),IR(18760, 24)/* SubgroupsPerWorkgroupId */,IR(0, 0),IR(149, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,2),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {38,IR(33, 3),IR(18784, 12)/* LocalSizeId */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,2),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {39,IR(33, 3),IR(18796, 16)/* LocalSizeHintId */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,2),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {4169,IR(0, 0),IR(18812, 34)/* NonCoherentColorAttachmentReadEXT */,IR(0, 0),IR(141, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {4170,IR(0, 0),IR(18846, 34)/* NonCoherentDepthAttachmentReadEXT */,IR(0, 0),IR(150, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {4171,IR(0, 0),IR(18880, 36)/* NonCoherentStencilAttachmentReadEXT */,IR(0, 0),IR(151, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {4421,IR(0, 0),IR(18916, 30)/* SubgroupUniformControlFlowKHR */,IR(0, 0),IR(3, 1),IR(156, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {4446,IR(0, 0),IR(18946, 18)/* PostDepthCoverage */,IR(0, 0),IR(152, 1),IR(44, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {4459,IR(0, 1),IR(9470, 15)/* DenormPreserve */,IR(0, 0),IR(153, 1),IR(46, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {4460,IR(0, 1),IR(9485, 18)/* DenormFlushToZero */,IR(0, 0),IR(154, 1),IR(46, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {4461,IR(0, 1),IR(9503, 25)/* SignedZeroInfNanPreserve */,IR(0, 0),IR(155, 1),IR(46, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {4462,IR(0, 1),IR(9528, 16)/* RoundingModeRTE */,IR(0, 0),IR(156, 1),IR(46, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {4463,IR(0, 1),IR(9544, 16)/* RoundingModeRTZ */,IR(0, 0),IR(157, 1),IR(46, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {4489,IR(0, 0),IR(18964, 34)/* NonCoherentTileAttachmentReadQCOM */,IR(0, 0),IR(41, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {4490,IR(22, 3),IR(18998, 20)/* TileShadingRateQCOM */,IR(0, 0),IR(41, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5017,IR(0, 0),IR(19018, 29)/* EarlyAndLateFragmentTestsAMD */,IR(0, 0),IR(3, 1),IR(157, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5027,IR(0, 0),IR(19047, 23)/* StencilRefReplacingEXT */,IR(0, 0),IR(42, 1),IR(11, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5069,IR(0, 0),IR(19070, 15)/* CoalescingAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5070,IR(10, 1),IR(19085, 15)/* IsApiEntryAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5071,IR(10, 1),IR(19100, 21)/* MaxNodeRecursionAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5072,IR(33, 3),IR(19121, 24)/* StaticNumWorkgroupsAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5073,IR(10, 1),IR(6194, 16)/* ShaderIndexAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5077,IR(33, 3),IR(19145, 21)/* MaxNumWorkgroupsAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5079,IR(0, 0),IR(19166, 28)/* StencilRefUnchangedFrontAMD */,IR(0, 0),IR(42, 1),IR(158, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5080,IR(0, 0),IR(19194, 26)/* StencilRefGreaterFrontAMD */,IR(0, 0),IR(42, 1),IR(158, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5081,IR(0, 0),IR(19220, 23)/* StencilRefLessFrontAMD */,IR(0, 0),IR(42, 1),IR(158, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5082,IR(0, 0),IR(19243, 27)/* StencilRefUnchangedBackAMD */,IR(0, 0),IR(42, 1),IR(158, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5083,IR(0, 0),IR(19270, 25)/* StencilRefGreaterBackAMD */,IR(0, 0),IR(42, 1),IR(158, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5084,IR(0, 0),IR(19295, 22)/* StencilRefLessBackAMD */,IR(0, 0),IR(42, 1),IR(158, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5088,IR(0, 0),IR(19317, 19)/* QuadDerivativesKHR */,IR(0, 0),IR(158, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5089,IR(0, 0),IR(19336, 20)/* RequireFullQuadsKHR */,IR(0, 0),IR(158, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5102,IR(36, 2),IR(19356, 20)/* SharesInputWithAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5269,IR(0, 0),IR(19376, 15)/* OutputLinesEXT */,IR(58, 1),IR(118, 2),IR(152, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5270,IR(0, 1),IR(19405, 20)/* OutputPrimitivesEXT */,IR(59, 1),IR(118, 2),IR(152, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5289,IR(0, 0),IR(19444, 24)/* DerivativeGroupQuadsKHR */,IR(60, 1),IR(159, 2),IR(71, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5290,IR(0, 0),IR(19491, 25)/* DerivativeGroupLinearKHR */,IR(61, 1),IR(161, 2),IR(71, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5298,IR(0, 0),IR(19540, 19)/* OutputTrianglesEXT */,IR(62, 1),IR(118, 2),IR(152, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5366,IR(0, 0),IR(19577, 25)/* PixelInterlockOrderedEXT */,IR(0, 0),IR(163, 1),IR(78, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5367,IR(0, 0),IR(19602, 27)/* PixelInterlockUnorderedEXT */,IR(0, 0),IR(163, 1),IR(78, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5368,IR(0, 0),IR(19629, 26)/* SampleInterlockOrderedEXT */,IR(0, 0),IR(164, 1),IR(78, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5369,IR(0, 0),IR(19655, 28)/* SampleInterlockUnorderedEXT */,IR(0, 0),IR(164, 1),IR(78, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5370,IR(0, 0),IR(19683, 31)/* ShadingRateInterlockOrderedEXT */,IR(0, 0),IR(165, 1),IR(78, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5371,IR(0, 0),IR(19714, 33)/* ShadingRateInterlockUnorderedEXT */,IR(0, 0),IR(165, 1),IR(78, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5618,IR(0, 1),IR(19747, 27)/* SharedLocalMemorySizeINTEL */,IR(0, 0),IR(122, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5620,IR(0, 1),IR(19774, 21)/* RoundingModeRTPINTEL */,IR(0, 0),IR(166, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5621,IR(0, 1),IR(19795, 21)/* RoundingModeRTNINTEL */,IR(0, 0),IR(166, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5622,IR(0, 1),IR(19816, 26)/* FloatingPointModeALTINTEL */,IR(0, 0),IR(166, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5623,IR(0, 1),IR(19842, 27)/* FloatingPointModeIEEEINTEL */,IR(0, 0),IR(166, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5893,IR(22, 3),IR(19869, 22)/* MaxWorkgroupSizeINTEL */,IR(0, 0),IR(167, 1),IR(106, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5894,IR(0, 1),IR(19891, 16)/* MaxWorkDimINTEL */,IR(0, 0),IR(167, 1),IR(106, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5895,IR(0, 0),IR(19907, 20)/* NoGlobalOffsetINTEL */,IR(0, 0),IR(167, 1),IR(106, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5896,IR(0, 1),IR(19927, 22)/* NumSIMDWorkitemsINTEL */,IR(0, 0),IR(104, 1),IR(106, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {5903,IR(0, 1),IR(19949, 28)/* SchedulerTargetFmaxMhzINTEL */,IR(0, 0),IR(104, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {6023,IR(0, 0),IR(19977, 24)/* MaximallyReconvergesKHR */,IR(0, 0),IR(3, 1),IR(160, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {6028,IR(36, 2),IR(20001, 18)/* FPFastMathDefault */,IR(0, 0),IR(168, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {6154,IR(0, 1),IR(20019, 24)/* StreamingInterfaceINTEL */,IR(0, 0),IR(104, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {6160,IR(0, 1),IR(20043, 26)/* RegisterMapInterfaceINTEL */,IR(0, 0),IR(169, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {6417,IR(0, 1),IR(20069, 23)/* NamedBarrierCountINTEL */,IR(0, 0),IR(122, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {6461,IR(0, 1),IR(20092, 22)/* MaximumRegistersINTEL */,IR(0, 0),IR(170, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {6462,IR(10, 1),IR(20114, 24)/* MaximumRegistersIdINTEL */,IR(0, 0),IR(170, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {6463,IR(38, 1),IR(20189, 27)/* NamedMaximumRegistersINTEL */,IR(0, 0),IR(170, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE - {0,IR(0, 0),IR(20216, 7)/* Vertex */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {1,IR(0, 0),IR(20223, 20)/* TessellationControl */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {2,IR(0, 0),IR(20243, 23)/* TessellationEvaluation */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {3,IR(0, 0),IR(4782, 9)/* Geometry */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {4,IR(0, 0),IR(14411, 9)/* Fragment */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {5,IR(0, 0),IR(20266, 10)/* GLCompute */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {6,IR(0, 0),IR(4549, 7)/* Kernel */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {5267,IR(0, 0),IR(20276, 7)/* TaskNV */,IR(0, 0),IR(50, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {5268,IR(0, 0),IR(20283, 7)/* MeshNV */,IR(0, 0),IR(50, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {5313,IR(0, 0),IR(20290, 17)/* RayGenerationKHR */,IR(63, 1),IR(54, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {5314,IR(0, 0),IR(20323, 16)/* IntersectionKHR */,IR(64, 1),IR(54, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {5315,IR(0, 0),IR(20354, 10)/* AnyHitKHR */,IR(65, 1),IR(54, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {5316,IR(0, 0),IR(20373, 14)/* ClosestHitKHR */,IR(66, 1),IR(54, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {5317,IR(0, 0),IR(20400, 8)/* MissKHR */,IR(67, 1),IR(54, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {5318,IR(0, 0),IR(20415, 12)/* CallableKHR */,IR(68, 1),IR(54, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {5364,IR(0, 0),IR(20438, 8)/* TaskEXT */,IR(0, 0),IR(53, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {5365,IR(0, 0),IR(20446, 8)/* MeshEXT */,IR(0, 0),IR(53, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL - {0,IR(0, 0),IR(20454, 9)/* Preserve */,IR(0, 0),IR(125, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPDENORM_MODE - {1,IR(0, 0),IR(20463, 12)/* FlushToZero */,IR(0, 0),IR(125, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPDENORM_MODE - {0,IR(0, 0),IR(20475, 12)/* BFloat16KHR */,IR(0, 0),IR(86, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPENCODING - {4214,IR(0, 0),IR(20487, 14)/* Float8E4M3EXT */,IR(0, 0),IR(115, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPENCODING - {4215,IR(0, 0),IR(20501, 14)/* Float8E5M2EXT */,IR(0, 0),IR(115, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPENCODING - {0,IR(0, 0),IR(20515, 5)/* IEEE */,IR(0, 0),IR(125, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPOPERATION_MODE - {1,IR(0, 0),IR(20520, 4)/* ALT */,IR(0, 0),IR(125, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPOPERATION_MODE - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {1,IR(0, 0),IR(20524, 7)/* NotNaN */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {2,IR(0, 0),IR(20531, 7)/* NotInf */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {4,IR(0, 0),IR(20538, 4)/* NSZ */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {8,IR(0, 0),IR(20542, 11)/* AllowRecip */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {16,IR(0, 0),IR(20553, 5)/* Fast */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {65536,IR(0, 0),IR(20558, 14)/* AllowContract */,IR(69, 1),IR(171, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {131072,IR(0, 0),IR(20595, 13)/* AllowReassoc */,IR(70, 1),IR(171, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {262144,IR(0, 0),IR(20626, 15)/* AllowTransform */,IR(0, 0),IR(168, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {0,IR(0, 0),IR(20641, 4)/* RTE */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_ROUNDING_MODE - {1,IR(0, 0),IR(20645, 4)/* RTZ */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_ROUNDING_MODE - {2,IR(0, 0),IR(20649, 4)/* RTP */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_ROUNDING_MODE - {3,IR(0, 0),IR(20653, 4)/* RTN */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_ROUNDING_MODE - {1,IR(0, 0),IR(20657, 16)/* Vertical2Pixels */,IR(0, 0),IR(38, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE - {2,IR(0, 0),IR(20673, 16)/* Vertical4Pixels */,IR(0, 0),IR(38, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE - {4,IR(0, 0),IR(20689, 18)/* Horizontal2Pixels */,IR(0, 0),IR(38, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE - {8,IR(0, 0),IR(20707, 18)/* Horizontal4Pixels */,IR(0, 0),IR(38, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_CONTROL - {1,IR(0, 0),IR(20725, 7)/* Inline */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_CONTROL - {2,IR(0, 0),IR(20732, 11)/* DontInline */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_CONTROL - {4,IR(0, 0),IR(20743, 5)/* Pure */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_CONTROL - {8,IR(0, 0),IR(20748, 6)/* Const */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_CONTROL - {65536,IR(0, 0),IR(13228, 11)/* OptNoneEXT */,IR(50, 1),IR(173, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_CONTROL - {0,IR(0, 0),IR(20754, 5)/* Zext */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {1,IR(0, 0),IR(20759, 5)/* Sext */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {2,IR(0, 0),IR(20764, 6)/* ByVal */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {3,IR(0, 0),IR(20770, 5)/* Sret */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {4,IR(0, 0),IR(20775, 8)/* NoAlias */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {5,IR(0, 0),IR(20783, 10)/* NoCapture */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {6,IR(0, 0),IR(20793, 8)/* NoWrite */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {7,IR(0, 0),IR(20801, 12)/* NoReadWrite */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {5940,IR(0, 0),IR(20813, 20)/* RuntimeAlignedINTEL */,IR(0, 0),IR(174, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {0,IR(0, 0),IR(20833, 7)/* Reduce */,IR(0, 0),IR(175, 3),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION - {1,IR(0, 0),IR(20840, 14)/* InclusiveScan */,IR(0, 0),IR(175, 3),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION - {2,IR(0, 0),IR(20854, 14)/* ExclusiveScan */,IR(0, 0),IR(175, 3),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION - {3,IR(0, 0),IR(20868, 16)/* ClusteredReduce */,IR(0, 0),IR(178, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION - {6,IR(0, 0),IR(20884, 20)/* PartitionedReduceNV */,IR(0, 0),IR(179, 1),IR(73, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION - {7,IR(0, 0),IR(20904, 27)/* PartitionedInclusiveScanNV */,IR(0, 0),IR(179, 1),IR(73, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION - {8,IR(0, 0),IR(20931, 27)/* PartitionedExclusiveScanNV */,IR(0, 0),IR(179, 1),IR(73, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION - {0,IR(0, 0),IR(20958, 10)/* NoneINTEL */,IR(0, 0),IR(138, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER - {1,IR(0, 0),IR(20968, 10)/* ReadINTEL */,IR(0, 0),IR(138, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER - {2,IR(0, 0),IR(20978, 11)/* WriteINTEL */,IR(0, 0),IR(138, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER - {3,IR(0, 0),IR(20989, 15)/* ReadWriteINTEL */,IR(0, 0),IR(138, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {1,IR(10, 1),IR(21004, 5)/* Bias */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {2,IR(10, 1),IR(21009, 4)/* Lod */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {4,IR(36, 2),IR(21013, 5)/* Grad */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {8,IR(10, 1),IR(21018, 12)/* ConstOffset */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {16,IR(10, 1),IR(15414, 7)/* Offset */,IR(0, 0),IR(180, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {32,IR(10, 1),IR(21030, 13)/* ConstOffsets */,IR(0, 0),IR(180, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {64,IR(10, 1),IR(15211, 7)/* Sample */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {128,IR(10, 1),IR(8333, 7)/* MinLod */,IR(0, 0),IR(181, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {256,IR(4, 1),IR(21043, 19)/* MakeTexelAvailable */,IR(71, 1),IR(182, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {512,IR(4, 1),IR(21084, 17)/* MakeTexelVisible */,IR(72, 1),IR(182, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {1024,IR(0, 0),IR(21121, 16)/* NonPrivateTexel */,IR(73, 1),IR(182, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {2048,IR(0, 0),IR(21156, 14)/* VolatileTexel */,IR(74, 1),IR(182, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {4096,IR(0, 0),IR(21187, 11)/* SignExtend */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {8192,IR(0, 0),IR(21198, 11)/* ZeroExtend */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {16384,IR(0, 0),IR(21209, 12)/* Nontemporal */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {65536,IR(10, 1),IR(21221, 8)/* Offsets */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE - {0,IR(0, 0),IR(21229, 10)/* SnormInt8 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {1,IR(0, 0),IR(21239, 11)/* SnormInt16 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {2,IR(0, 0),IR(21250, 10)/* UnormInt8 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {3,IR(0, 0),IR(21260, 11)/* UnormInt16 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {4,IR(0, 0),IR(21271, 14)/* UnormShort565 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {5,IR(0, 0),IR(21285, 14)/* UnormShort555 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {6,IR(0, 0),IR(21299, 15)/* UnormInt101010 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {7,IR(0, 0),IR(21314, 11)/* SignedInt8 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {8,IR(0, 0),IR(21325, 12)/* SignedInt16 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {9,IR(0, 0),IR(21337, 12)/* SignedInt32 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {10,IR(0, 0),IR(21349, 13)/* UnsignedInt8 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {11,IR(0, 0),IR(21362, 14)/* UnsignedInt16 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {12,IR(0, 0),IR(21376, 14)/* UnsignedInt32 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {13,IR(0, 0),IR(21390, 10)/* HalfFloat */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {14,IR(0, 0),IR(13904, 6)/* Float */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {15,IR(0, 0),IR(21400, 11)/* UnormInt24 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {16,IR(0, 0),IR(21411, 17)/* UnormInt101010_2 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {17,IR(0, 0),IR(21428, 16)/* UnormInt10X6EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {19,IR(0, 0),IR(21444, 20)/* UnsignedIntRaw10EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {20,IR(0, 0),IR(21464, 20)/* UnsignedIntRaw12EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {21,IR(0, 0),IR(21484, 20)/* UnormInt2_101010EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {22,IR(0, 0),IR(21504, 19)/* UnsignedInt10X6EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {23,IR(0, 0),IR(21523, 19)/* UnsignedInt12X4EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {24,IR(0, 0),IR(21542, 19)/* UnsignedInt14X2EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {25,IR(0, 0),IR(21561, 16)/* UnormInt12X4EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {26,IR(0, 0),IR(21577, 16)/* UnormInt14X2EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {0,IR(0, 0),IR(21593, 2)/* R */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {1,IR(0, 0),IR(21595, 2)/* A */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {2,IR(0, 0),IR(21597, 3)/* RG */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {3,IR(0, 0),IR(21600, 3)/* RA */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {4,IR(0, 0),IR(21603, 4)/* RGB */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {5,IR(0, 0),IR(21607, 5)/* RGBA */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {6,IR(0, 0),IR(21612, 5)/* BGRA */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {7,IR(0, 0),IR(21617, 5)/* ARGB */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {8,IR(0, 0),IR(21622, 10)/* Intensity */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {9,IR(0, 0),IR(21632, 10)/* Luminance */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {10,IR(0, 0),IR(21642, 3)/* Rx */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {11,IR(0, 0),IR(21645, 4)/* RGx */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {12,IR(0, 0),IR(21649, 5)/* RGBx */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {13,IR(0, 0),IR(21654, 6)/* Depth */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {14,IR(0, 0),IR(21660, 13)/* DepthStencil */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {15,IR(0, 0),IR(21673, 5)/* sRGB */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {16,IR(0, 0),IR(21678, 6)/* sRGBx */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {17,IR(0, 0),IR(21684, 6)/* sRGBA */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {18,IR(0, 0),IR(21690, 6)/* sBGRA */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {19,IR(0, 0),IR(21696, 5)/* ABGR */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {0,IR(0, 0),IR(21701, 27)/* InitOnDeviceReprogramINTEL */,IR(0, 0),IR(139, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER - {1,IR(0, 0),IR(21728, 23)/* InitOnDeviceResetINTEL */,IR(0, 0),IR(139, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER - {0,IR(0, 0),IR(21751, 7)/* NoWait */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS - {1,IR(0, 0),IR(21758, 11)/* WaitKernel */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS - {2,IR(0, 0),IR(21769, 14)/* WaitWorkGroup */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO - {1,IR(0, 0),IR(21783, 12)/* CmdExecTime */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_PROPERTY_FLAGS - {1,IR(0, 0),IR(21795, 13)/* MayUsePrintf */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_PROPERTY_FLAGS - {0,IR(0, 0),IR(21808, 7)/* Export */,IR(0, 0),IR(114, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_LINKAGE_TYPE - {1,IR(0, 0),IR(21815, 7)/* Import */,IR(0, 0),IR(114, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_LINKAGE_TYPE - {2,IR(0, 0),IR(21822, 12)/* LinkOnceODR */,IR(0, 0),IR(114, 1),IR(161, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LINKAGE_TYPE - {0,IR(0, 0),IR(21834, 14)/* UncachedINTEL */,IR(0, 0),IR(140, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL - {1,IR(0, 0),IR(21848, 12)/* CachedINTEL */,IR(0, 0),IR(140, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL - {2,IR(0, 0),IR(21860, 15)/* StreamingINTEL */,IR(0, 0),IR(140, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL - {3,IR(0, 0),IR(21875, 25)/* InvalidateAfterReadINTEL */,IR(0, 0),IR(140, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL - {4,IR(0, 0),IR(21900, 17)/* ConstCachedINTEL */,IR(0, 0),IR(140, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {1,IR(0, 0),IR(21917, 7)/* Unroll */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {2,IR(0, 0),IR(21924, 11)/* DontUnroll */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {4,IR(0, 0),IR(21935, 19)/* DependencyInfinite */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {8,IR(0, 1),IR(21954, 17)/* DependencyLength */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {16,IR(0, 1),IR(21971, 14)/* MinIterations */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {32,IR(0, 1),IR(21985, 14)/* MaxIterations */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {64,IR(0, 1),IR(21999, 18)/* IterationMultiple */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {128,IR(0, 1),IR(22017, 10)/* PeelCount */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {256,IR(0, 1),IR(22027, 13)/* PartialCount */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {65536,IR(0, 1),IR(17281, 24)/* InitiationIntervalINTEL */,IR(0, 0),IR(183, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {131072,IR(0, 1),IR(17305, 20)/* MaxConcurrencyINTEL */,IR(0, 0),IR(183, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {262144,IR(0, 1),IR(22040, 21)/* DependencyArrayINTEL */,IR(0, 0),IR(183, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {524288,IR(0, 1),IR(17325, 20)/* PipelineEnableINTEL */,IR(0, 0),IR(183, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {1048576,IR(0, 1),IR(22061, 18)/* LoopCoalesceINTEL */,IR(0, 0),IR(183, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {2097152,IR(0, 1),IR(22079, 21)/* MaxInterleavingINTEL */,IR(0, 0),IR(183, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {4194304,IR(0, 1),IR(22100, 26)/* SpeculatedIterationsINTEL */,IR(0, 0),IR(183, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {8388608,IR(0, 0),IR(22126, 14)/* NoFusionINTEL */,IR(0, 0),IR(183, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {16777216,IR(0, 1),IR(22140, 15)/* LoopCountINTEL */,IR(0, 0),IR(183, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {33554432,IR(0, 1),IR(22155, 26)/* MaxReinvocationDelayINTEL */,IR(0, 0),IR(183, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {1,IR(0, 0),IR(22181, 29)/* MatrixASignedComponentsINTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {2,IR(0, 0),IR(22210, 29)/* MatrixBSignedComponentsINTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {4,IR(0, 0),IR(22239, 21)/* MatrixCBFloat16INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {8,IR(0, 0),IR(22260, 26)/* MatrixResultBFloat16INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {16,IR(0, 0),IR(22286, 23)/* MatrixAPackedInt8INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {32,IR(0, 0),IR(22309, 23)/* MatrixBPackedInt8INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {64,IR(0, 0),IR(22332, 23)/* MatrixAPackedInt4INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {128,IR(0, 0),IR(22355, 23)/* MatrixBPackedInt4INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {256,IR(0, 0),IR(22378, 17)/* MatrixATF32INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {512,IR(0, 0),IR(22395, 17)/* MatrixBTF32INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {1024,IR(0, 0),IR(22412, 26)/* MatrixAPackedFloat16INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {2048,IR(0, 0),IR(22438, 26)/* MatrixBPackedFloat16INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {4096,IR(0, 0),IR(22464, 27)/* MatrixAPackedBFloat16INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {8192,IR(0, 0),IR(22491, 27)/* MatrixBPackedBFloat16INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS - {1,IR(0, 0),IR(15245, 9)/* Volatile */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS - {2,IR(0, 1),IR(22518, 8)/* Aligned */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS - {4,IR(0, 0),IR(21209, 12)/* Nontemporal */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS - {8,IR(4, 1),IR(22526, 21)/* MakePointerAvailable */,IR(75, 1),IR(182, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS - {16,IR(4, 1),IR(22571, 19)/* MakePointerVisible */,IR(76, 1),IR(182, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS - {32,IR(0, 0),IR(22612, 18)/* NonPrivatePointer */,IR(77, 1),IR(182, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS - {65536,IR(10, 1),IR(22651, 20)/* AliasScopeINTELMask */,IR(0, 0),IR(130, 1),IR(111, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS - {131072,IR(10, 1),IR(22671, 17)/* NoAliasINTELMask */,IR(0, 0),IR(130, 1),IR(111, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS - {0,IR(0, 0),IR(22688, 7)/* Simple */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_MODEL - {1,IR(0, 0),IR(22695, 8)/* GLSL450 */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_MODEL - {2,IR(0, 0),IR(22703, 7)/* OpenCL */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_MODEL - {3,IR(0, 0),IR(22710, 7)/* Vulkan */,IR(78, 1),IR(182, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_MODEL - {0,IR(0, 0),IR(22727, 8)/* Relaxed */,IR(79, 1),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {2,IR(0, 0),IR(22735, 8)/* Acquire */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {4,IR(0, 0),IR(22743, 8)/* Release */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {8,IR(0, 0),IR(22751, 15)/* AcquireRelease */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {16,IR(0, 0),IR(22766, 23)/* SequentiallyConsistent */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {64,IR(0, 0),IR(22789, 14)/* UniformMemory */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {128,IR(0, 0),IR(22803, 15)/* SubgroupMemory */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {256,IR(0, 0),IR(22818, 16)/* WorkgroupMemory */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {512,IR(0, 0),IR(22834, 21)/* CrossWorkgroupMemory */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {1024,IR(0, 0),IR(22855, 20)/* AtomicCounterMemory */,IR(0, 0),IR(80, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {2048,IR(0, 0),IR(22875, 12)/* ImageMemory */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {4096,IR(0, 0),IR(22887, 13)/* OutputMemory */,IR(80, 1),IR(182, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {8192,IR(0, 0),IR(22916, 14)/* MakeAvailable */,IR(81, 1),IR(182, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {16384,IR(0, 0),IR(22947, 12)/* MakeVisible */,IR(82, 1),IR(182, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {32768,IR(0, 0),IR(15245, 9)/* Volatile */,IR(0, 0),IR(182, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {0,IR(0, 0),IR(22974, 10)/* AutoINTEL */,IR(0, 0),IR(170, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS - {0,IR(0, 0),IR(22984, 5)/* WRAP */,IR(0, 0),IR(184, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_OVERFLOW_MODES - {1,IR(0, 0),IR(22989, 4)/* SAT */,IR(0, 0),IR(184, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_OVERFLOW_MODES - {2,IR(0, 0),IR(22993, 9)/* SAT_ZERO */,IR(0, 0),IR(184, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_OVERFLOW_MODES - {3,IR(0, 0),IR(23002, 8)/* SAT_SYM */,IR(0, 0),IR(184, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_OVERFLOW_MODES - {0,IR(0, 0),IR(23010, 25)/* PackedVectorFormat4x8Bit */,IR(83, 1),IR(1, 0),IR(120, 1),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT - {0,IR(0, 0),IR(23063, 4)/* TRN */,IR(0, 0),IR(184, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES - {1,IR(0, 0),IR(23067, 9)/* TRN_ZERO */,IR(0, 0),IR(184, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES - {2,IR(0, 0),IR(23076, 4)/* RND */,IR(0, 0),IR(184, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES - {3,IR(0, 0),IR(23080, 9)/* RND_ZERO */,IR(0, 0),IR(184, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES - {4,IR(0, 0),IR(23089, 8)/* RND_INF */,IR(0, 0),IR(184, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES - {5,IR(0, 0),IR(23097, 12)/* RND_MIN_INF */,IR(0, 0),IR(184, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES - {6,IR(0, 0),IR(23109, 9)/* RND_CONV */,IR(0, 0),IR(184, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES - {7,IR(0, 0),IR(23118, 13)/* RND_CONV_ODD */,IR(0, 0),IR(184, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS - {1,IR(0, 0),IR(23131, 25)/* RobustnessPerComponentNV */,IR(0, 0),IR(185, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS - {2,IR(0, 0),IR(23156, 23)/* RobustnessPerElementNV */,IR(0, 0),IR(185, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS - {0,IR(0, 0),IR(14759, 8)/* NoneKHR */,IR(0, 0),IR(82, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS - {1,IR(0, 0),IR(23179, 10)/* OpaqueKHR */,IR(0, 0),IR(82, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS - {2,IR(0, 0),IR(23189, 12)/* NoOpaqueKHR */,IR(0, 0),IR(82, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS - {4,IR(0, 0),IR(23201, 23)/* TerminateOnFirstHitKHR */,IR(0, 0),IR(82, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS - {8,IR(0, 0),IR(23224, 24)/* SkipClosestHitShaderKHR */,IR(0, 0),IR(82, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS - {16,IR(0, 0),IR(23248, 27)/* CullBackFacingTrianglesKHR */,IR(0, 0),IR(82, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS - {32,IR(0, 0),IR(23275, 28)/* CullFrontFacingTrianglesKHR */,IR(0, 0),IR(82, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS - {64,IR(0, 0),IR(23303, 14)/* CullOpaqueKHR */,IR(0, 0),IR(82, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS - {128,IR(0, 0),IR(23317, 16)/* CullNoOpaqueKHR */,IR(0, 0),IR(82, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS - {256,IR(0, 0),IR(23333, 17)/* SkipTrianglesKHR */,IR(84, 1),IR(186, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS - {512,IR(0, 0),IR(23374, 13)/* SkipAABBsKHR */,IR(0, 0),IR(186, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS - {1024,IR(0, 0),IR(23387, 30)/* ForceOpacityMicromap2StateEXT */,IR(0, 0),IR(187, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS - {0,IR(0, 0),IR(23417, 41)/* RayQueryCandidateIntersectionTriangleKHR */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE - {1,IR(0, 0),IR(23458, 37)/* RayQueryCandidateIntersectionAABBKHR */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE - {0,IR(0, 0),IR(23495, 37)/* RayQueryCommittedIntersectionNoneKHR */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE - {1,IR(0, 0),IR(23532, 41)/* RayQueryCommittedIntersectionTriangleKHR */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE - {2,IR(0, 0),IR(23573, 42)/* RayQueryCommittedIntersectionGeneratedKHR */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE - {0,IR(0, 0),IR(23615, 33)/* RayQueryCandidateIntersectionKHR */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION - {1,IR(0, 0),IR(23648, 33)/* RayQueryCommittedIntersectionKHR */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE - {1,IR(0, 0),IR(23681, 12)/* ClampToEdge */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE - {2,IR(0, 0),IR(23693, 6)/* Clamp */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE - {3,IR(0, 0),IR(23699, 7)/* Repeat */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE - {4,IR(0, 0),IR(23706, 15)/* RepeatMirrored */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE - {0,IR(0, 0),IR(23721, 8)/* Nearest */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE - {1,IR(0, 0),IR(23729, 7)/* Linear */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE - {0,IR(0, 0),IR(23736, 8)/* Unknown */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {1,IR(0, 0),IR(23744, 8)/* Rgba32f */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {2,IR(0, 0),IR(23752, 8)/* Rgba16f */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {3,IR(0, 0),IR(23760, 5)/* R32f */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {4,IR(0, 0),IR(23765, 6)/* Rgba8 */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {5,IR(0, 0),IR(23771, 11)/* Rgba8Snorm */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {6,IR(0, 0),IR(23782, 6)/* Rg32f */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {7,IR(0, 0),IR(23788, 6)/* Rg16f */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {8,IR(0, 0),IR(23794, 13)/* R11fG11fB10f */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {9,IR(0, 0),IR(23807, 5)/* R16f */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {10,IR(0, 0),IR(23812, 7)/* Rgba16 */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {11,IR(0, 0),IR(23819, 8)/* Rgb10A2 */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {12,IR(0, 0),IR(23827, 5)/* Rg16 */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {13,IR(0, 0),IR(23832, 4)/* Rg8 */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {14,IR(0, 0),IR(23836, 4)/* R16 */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {15,IR(0, 0),IR(23840, 3)/* R8 */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {16,IR(0, 0),IR(23843, 12)/* Rgba16Snorm */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {17,IR(0, 0),IR(23855, 10)/* Rg16Snorm */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {18,IR(0, 0),IR(23865, 9)/* Rg8Snorm */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {19,IR(0, 0),IR(23874, 9)/* R16Snorm */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {20,IR(0, 0),IR(23883, 8)/* R8Snorm */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {21,IR(0, 0),IR(23891, 8)/* Rgba32i */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {22,IR(0, 0),IR(23899, 8)/* Rgba16i */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {23,IR(0, 0),IR(23907, 7)/* Rgba8i */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {24,IR(0, 0),IR(23914, 5)/* R32i */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {25,IR(0, 0),IR(23919, 6)/* Rg32i */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {26,IR(0, 0),IR(23925, 6)/* Rg16i */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {27,IR(0, 0),IR(23931, 5)/* Rg8i */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {28,IR(0, 0),IR(23936, 5)/* R16i */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {29,IR(0, 0),IR(23941, 4)/* R8i */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {30,IR(0, 0),IR(23945, 9)/* Rgba32ui */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {31,IR(0, 0),IR(23954, 9)/* Rgba16ui */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {32,IR(0, 0),IR(23963, 8)/* Rgba8ui */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {33,IR(0, 0),IR(23971, 6)/* R32ui */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {34,IR(0, 0),IR(23977, 10)/* Rgb10a2ui */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {35,IR(0, 0),IR(23987, 7)/* Rg32ui */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {36,IR(0, 0),IR(23994, 7)/* Rg16ui */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {37,IR(0, 0),IR(24001, 6)/* Rg8ui */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {38,IR(0, 0),IR(24007, 6)/* R16ui */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {39,IR(0, 0),IR(24013, 5)/* R8ui */,IR(0, 0),IR(189, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {40,IR(0, 0),IR(24018, 6)/* R64ui */,IR(0, 0),IR(190, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {41,IR(0, 0),IR(24024, 5)/* R64i */,IR(0, 0),IR(190, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {0,IR(0, 0),IR(24029, 12)/* CrossDevice */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID - {1,IR(0, 0),IR(24041, 7)/* Device */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID - {2,IR(0, 0),IR(24048, 10)/* Workgroup */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID - {3,IR(0, 0),IR(24058, 9)/* Subgroup */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID - {4,IR(0, 0),IR(24067, 11)/* Invocation */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID - {5,IR(0, 0),IR(24078, 12)/* QueueFamily */,IR(85, 1),IR(182, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID - {6,IR(0, 0),IR(24105, 14)/* ShaderCallKHR */,IR(0, 0),IR(60, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SELECTION_CONTROL - {1,IR(0, 0),IR(24119, 8)/* Flatten */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SELECTION_CONTROL - {2,IR(0, 0),IR(24127, 12)/* DontFlatten */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SELECTION_CONTROL - {1,IR(0, 0),IR(24139, 29)/* IdentifierPossibleDuplicates */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_BUILD_IDENTIFIER_FLAGS - {0,IR(0, 0),IR(13876, 12)/* Unspecified */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {1,IR(0, 0),IR(13888, 8)/* Address */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {2,IR(0, 0),IR(13896, 8)/* Boolean */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {3,IR(0, 0),IR(13904, 6)/* Float */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {4,IR(0, 0),IR(13910, 7)/* Signed */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {5,IR(0, 0),IR(13917, 11)/* SignedChar */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {6,IR(0, 0),IR(13928, 9)/* Unsigned */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {7,IR(0, 0),IR(13937, 13)/* UnsignedChar */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {0,IR(0, 0),IR(13950, 6)/* Class */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE - {1,IR(0, 0),IR(13956, 10)/* Structure */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE - {2,IR(0, 0),IR(13966, 6)/* Union */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE - {0,IR(0, 0),IR(13972, 15)/* ImportedModule */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_IMPORTED_ENTITY - {1,IR(0, 0),IR(13987, 20)/* ImportedDeclaration */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_IMPORTED_ENTITY - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {1,IR(0, 0),IR(14012, 16)/* FlagIsProtected */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {2,IR(0, 0),IR(14028, 14)/* FlagIsPrivate */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {3,IR(0, 0),IR(14042, 13)/* FlagIsPublic */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {4,IR(0, 0),IR(14055, 12)/* FlagIsLocal */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {8,IR(0, 0),IR(14067, 17)/* FlagIsDefinition */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {16,IR(0, 0),IR(14084, 12)/* FlagFwdDecl */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {32,IR(0, 0),IR(14096, 15)/* FlagArtificial */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {64,IR(0, 0),IR(14111, 13)/* FlagExplicit */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {128,IR(0, 0),IR(14124, 15)/* FlagPrototyped */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {256,IR(0, 0),IR(14139, 18)/* FlagObjectPointer */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {512,IR(0, 0),IR(14157, 17)/* FlagStaticMember */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {1024,IR(0, 0),IR(14174, 21)/* FlagIndirectVariable */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {2048,IR(0, 0),IR(14195, 20)/* FlagLValueReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {4096,IR(0, 0),IR(14215, 20)/* FlagRValueReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {8192,IR(0, 0),IR(14235, 16)/* FlagIsOptimized */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {16384,IR(0, 0),IR(14251, 16)/* FlagIsEnumClass */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {32768,IR(0, 0),IR(14267, 20)/* FlagTypePassByValue */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {65536,IR(0, 0),IR(14287, 24)/* FlagTypePassByReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {131072,IR(0, 0),IR(24168, 26)/* FlagUnknownPhysicalLayout */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {0,IR(0, 0),IR(14311, 6)/* Deref */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {1,IR(0, 0),IR(14317, 5)/* Plus */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {2,IR(0, 0),IR(14322, 6)/* Minus */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {3,IR(10, 1),IR(14361, 11)/* PlusUconst */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {4,IR(36, 2),IR(14372, 9)/* BitPiece */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {5,IR(0, 0),IR(14381, 5)/* Swap */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {6,IR(0, 0),IR(14386, 7)/* Xderef */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {7,IR(0, 0),IR(14393, 11)/* StackValue */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {8,IR(10, 1),IR(14404, 7)/* Constu */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {9,IR(36, 2),IR(14411, 9)/* Fragment */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {0,IR(0, 0),IR(14420, 10)/* ConstType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER - {1,IR(0, 0),IR(14430, 13)/* VolatileType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER - {2,IR(0, 0),IR(14443, 13)/* RestrictType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER - {3,IR(0, 0),IR(14456, 11)/* AtomicType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER - {0,IR(0, 0),IR(23736, 8)/* Unknown */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {1,IR(0, 0),IR(24194, 5)/* ESSL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {2,IR(0, 0),IR(24199, 5)/* GLSL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {3,IR(0, 0),IR(24204, 9)/* OpenCL_C */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {4,IR(0, 0),IR(24213, 11)/* OpenCL_CPP */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {5,IR(0, 0),IR(24224, 5)/* HLSL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {6,IR(0, 0),IR(24229, 15)/* CPP_for_OpenCL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {7,IR(0, 0),IR(24244, 5)/* SYCL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {8,IR(0, 0),IR(24249, 7)/* HERO_C */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {9,IR(0, 0),IR(24256, 5)/* NZSL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {10,IR(0, 0),IR(24261, 5)/* WGSL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {11,IR(0, 0),IR(24266, 6)/* Slang */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {12,IR(0, 0),IR(24272, 4)/* Zig */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {13,IR(0, 0),IR(24276, 5)/* Rust */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {0,IR(0, 0),IR(24281, 16)/* UniformConstant */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {1,IR(0, 0),IR(24297, 6)/* Input */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {2,IR(0, 0),IR(15296, 8)/* Uniform */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {3,IR(0, 0),IR(24303, 7)/* Output */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {4,IR(0, 0),IR(24048, 10)/* Workgroup */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5,IR(0, 0),IR(24310, 15)/* CrossWorkgroup */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {6,IR(0, 0),IR(24325, 8)/* Private */,IR(0, 0),IR(191, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {7,IR(0, 0),IR(24333, 9)/* Function */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {8,IR(0, 0),IR(24342, 8)/* Generic */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {9,IR(0, 0),IR(24350, 13)/* PushConstant */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {10,IR(0, 0),IR(24363, 14)/* AtomicCounter */,IR(0, 0),IR(80, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {11,IR(0, 0),IR(24377, 6)/* Image */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {12,IR(0, 0),IR(24383, 14)/* StorageBuffer */,IR(0, 0),IR(3, 1),IR(162, 2),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {4172,IR(0, 0),IR(24397, 13)/* TileImageEXT */,IR(0, 0),IR(141, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {4491,IR(0, 0),IR(24410, 19)/* TileAttachmentQCOM */,IR(0, 0),IR(41, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5068,IR(0, 0),IR(24429, 16)/* NodePayloadAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5328,IR(0, 0),IR(24445, 16)/* CallableDataKHR */,IR(86, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5329,IR(0, 0),IR(24476, 24)/* IncomingCallableDataKHR */,IR(87, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5338,IR(0, 0),IR(24523, 14)/* RayPayloadKHR */,IR(88, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5339,IR(0, 0),IR(24550, 16)/* HitAttributeKHR */,IR(89, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5342,IR(0, 0),IR(24581, 22)/* IncomingRayPayloadKHR */,IR(90, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5343,IR(0, 0),IR(24624, 22)/* ShaderRecordBufferKHR */,IR(91, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5349,IR(0, 0),IR(24667, 22)/* PhysicalStorageBuffer */,IR(92, 1),IR(2, 1),IR(0, 2),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5385,IR(0, 0),IR(24714, 21)/* HitObjectAttributeNV */,IR(0, 0),IR(120, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5402,IR(0, 0),IR(24735, 24)/* TaskPayloadWorkgroupEXT */,IR(0, 0),IR(53, 1),IR(23, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5605,IR(0, 0),IR(24759, 17)/* CodeSectionINTEL */,IR(0, 0),IR(194, 1),IR(93, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5936,IR(0, 0),IR(24776, 16)/* DeviceOnlyINTEL */,IR(0, 0),IR(195, 1),IR(115, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {5937,IR(0, 0),IR(24792, 14)/* HostOnlyINTEL */,IR(0, 0),IR(195, 1),IR(115, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS - {0,IR(0, 0),IR(21834, 14)/* UncachedINTEL */,IR(0, 0),IR(140, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORE_CACHE_CONTROL - {1,IR(0, 0),IR(24806, 18)/* WriteThroughINTEL */,IR(0, 0),IR(140, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORE_CACHE_CONTROL - {2,IR(0, 0),IR(24824, 15)/* WriteBackINTEL */,IR(0, 0),IR(140, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORE_CACHE_CONTROL - {3,IR(0, 0),IR(21860, 15)/* StreamingINTEL */,IR(0, 0),IR(140, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORE_CACHE_CONTROL - {0,IR(0, 0),IR(14007, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS - {1,IR(10, 1),IR(24839, 11)/* TensorView */,IR(0, 0),IR(196, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS - {2,IR(10, 1),IR(24850, 11)/* DecodeFunc */,IR(0, 0),IR(197, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS - {0,IR(0, 0),IR(24861, 10)/* Undefined */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE - {1,IR(0, 0),IR(15254, 9)/* Constant */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE - {2,IR(0, 0),IR(23681, 12)/* ClampToEdge */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE - {3,IR(0, 0),IR(23699, 7)/* Repeat */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE - {4,IR(0, 0),IR(23706, 15)/* RepeatMirrored */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE - {0,IR(0, 0),IR(24871, 8)/* NoneARM */,IR(0, 0),IR(198, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_OPERANDS - {1,IR(0, 0),IR(24879, 15)/* NontemporalARM */,IR(0, 0),IR(198, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_OPERANDS - {2,IR(10, 1),IR(24894, 20)/* OutOfBoundsValueARM */,IR(0, 0),IR(198, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_OPERANDS - {4,IR(10, 1),IR(24914, 24)/* MakeElementAvailableARM */,IR(0, 0),IR(198, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_OPERANDS - {8,IR(10, 1),IR(24938, 22)/* MakeElementVisibleARM */,IR(0, 0),IR(198, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_OPERANDS - {16,IR(0, 0),IR(24960, 21)/* NonPrivateElementARM */,IR(0, 0),IR(198, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_OPERANDS +static const std::array kOperandsByValue{{ + {0,IR(0, 0),IR(4633, 9)/* ReadOnly */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_ACCESS_QUALIFIER + {1,IR(0, 0),IR(4649, 10)/* WriteOnly */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_ACCESS_QUALIFIER + {2,IR(0, 0),IR(4659, 10)/* ReadWrite */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_ACCESS_QUALIFIER + {0,IR(0, 0),IR(4669, 8)/* Logical */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_ADDRESSING_MODEL + {1,IR(0, 0),IR(4677, 11)/* Physical32 */,IR(0, 0),IR(1, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_ADDRESSING_MODEL + {2,IR(0, 0),IR(4698, 11)/* Physical64 */,IR(0, 0),IR(1, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_ADDRESSING_MODEL + {5348,IR(0, 0),IR(4709, 24)/* PhysicalStorageBuffer64 */,IR(0, 1),IR(2, 1),IR(0, 2),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_ADDRESSING_MODEL + {0,IR(0, 0),IR(4791, 9)/* Position */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {1,IR(0, 0),IR(4807, 10)/* PointSize */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {3,IR(0, 0),IR(4817, 13)/* ClipDistance */,IR(0, 0),IR(4, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4,IR(0, 0),IR(4830, 13)/* CullDistance */,IR(0, 0),IR(5, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5,IR(0, 0),IR(4843, 9)/* VertexId */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {6,IR(0, 0),IR(4852, 11)/* InstanceId */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {7,IR(0, 0),IR(4863, 12)/* PrimitiveId */,IR(0, 0),IR(6, 6),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {8,IR(0, 0),IR(4953, 13)/* InvocationId */,IR(0, 0),IR(12, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {9,IR(0, 0),IR(4966, 6)/* Layer */,IR(0, 0),IR(14, 5),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {10,IR(0, 0),IR(5012, 14)/* ViewportIndex */,IR(0, 0),IR(19, 5),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {11,IR(0, 0),IR(5060, 15)/* TessLevelOuter */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {12,IR(0, 0),IR(5075, 15)/* TessLevelInner */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {13,IR(0, 0),IR(5090, 10)/* TessCoord */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {14,IR(0, 0),IR(5100, 14)/* PatchVertices */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {15,IR(0, 0),IR(5114, 10)/* FragCoord */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {16,IR(0, 0),IR(5124, 11)/* PointCoord */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {17,IR(0, 0),IR(5135, 12)/* FrontFacing */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {18,IR(0, 0),IR(5147, 9)/* SampleId */,IR(0, 0),IR(25, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {19,IR(0, 0),IR(5174, 15)/* SamplePosition */,IR(0, 0),IR(25, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {20,IR(0, 0),IR(5189, 11)/* SampleMask */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {22,IR(0, 0),IR(5200, 10)/* FragDepth */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {23,IR(0, 0),IR(5210, 17)/* HelperInvocation */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {24,IR(0, 0),IR(5227, 14)/* NumWorkgroups */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {25,IR(0, 0),IR(5241, 14)/* WorkgroupSize */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {26,IR(0, 0),IR(5255, 12)/* WorkgroupId */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {27,IR(0, 0),IR(5267, 18)/* LocalInvocationId */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {28,IR(0, 0),IR(5285, 19)/* GlobalInvocationId */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {29,IR(0, 0),IR(5304, 21)/* LocalInvocationIndex */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {30,IR(0, 0),IR(5325, 8)/* WorkDim */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {31,IR(0, 0),IR(5333, 11)/* GlobalSize */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {32,IR(0, 0),IR(5344, 22)/* EnqueuedWorkgroupSize */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {33,IR(0, 0),IR(5366, 13)/* GlobalOffset */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {34,IR(0, 0),IR(5379, 15)/* GlobalLinearId */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {36,IR(0, 0),IR(5394, 13)/* SubgroupSize */,IR(0, 0),IR(26, 3),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {37,IR(0, 0),IR(5441, 16)/* SubgroupMaxSize */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {38,IR(0, 0),IR(5457, 13)/* NumSubgroups */,IR(0, 0),IR(29, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {39,IR(0, 0),IR(5470, 21)/* NumEnqueuedSubgroups */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {40,IR(0, 0),IR(5491, 11)/* SubgroupId */,IR(0, 0),IR(29, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {41,IR(0, 0),IR(5502, 26)/* SubgroupLocalInvocationId */,IR(0, 0),IR(26, 3),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {42,IR(0, 0),IR(5528, 12)/* VertexIndex */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {43,IR(0, 0),IR(5540, 14)/* InstanceIndex */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4160,IR(0, 0),IR(5554, 10)/* CoreIDARM */,IR(0, 0),IR(31, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4161,IR(0, 0),IR(5580, 13)/* CoreCountARM */,IR(0, 0),IR(31, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4162,IR(0, 0),IR(5593, 13)/* CoreMaxIDARM */,IR(0, 0),IR(31, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4163,IR(0, 0),IR(5606, 10)/* WarpIDARM */,IR(0, 0),IR(31, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4164,IR(0, 0),IR(5616, 13)/* WarpMaxIDARM */,IR(0, 0),IR(31, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4416,IR(0, 0),IR(5629, 15)/* SubgroupEqMask */,IR(1, 1),IR(32, 2),IR(2, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4417,IR(0, 0),IR(5684, 15)/* SubgroupGeMask */,IR(2, 1),IR(32, 2),IR(2, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4418,IR(0, 0),IR(5717, 15)/* SubgroupGtMask */,IR(3, 1),IR(32, 2),IR(2, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4419,IR(0, 0),IR(5750, 15)/* SubgroupLeMask */,IR(4, 1),IR(32, 2),IR(2, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4420,IR(0, 0),IR(5783, 15)/* SubgroupLtMask */,IR(5, 1),IR(32, 2),IR(2, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4424,IR(0, 0),IR(5816, 11)/* BaseVertex */,IR(0, 0),IR(34, 1),IR(3, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4425,IR(0, 0),IR(5842, 13)/* BaseInstance */,IR(0, 0),IR(34, 1),IR(3, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4426,IR(0, 0),IR(5855, 10)/* DrawIndex */,IR(0, 0),IR(35, 3),IR(4, 3),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4432,IR(0, 0),IR(5865, 24)/* PrimitiveShadingRateKHR */,IR(0, 0),IR(38, 1),IR(7, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4438,IR(0, 0),IR(5912, 12)/* DeviceIndex */,IR(0, 0),IR(39, 1),IR(8, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4440,IR(0, 0),IR(5936, 10)/* ViewIndex */,IR(0, 0),IR(40, 1),IR(9, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4444,IR(0, 0),IR(5956, 15)/* ShadingRateKHR */,IR(0, 0),IR(38, 1),IR(7, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4492,IR(0, 0),IR(5971, 15)/* TileOffsetQCOM */,IR(0, 0),IR(41, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4493,IR(0, 0),IR(6002, 18)/* TileDimensionQCOM */,IR(0, 0),IR(41, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4494,IR(0, 0),IR(6020, 18)/* TileApronSizeQCOM */,IR(0, 0),IR(41, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4992,IR(0, 0),IR(6038, 20)/* BaryCoordNoPerspAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4993,IR(0, 0),IR(6058, 28)/* BaryCoordNoPerspCentroidAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4994,IR(0, 0),IR(6086, 26)/* BaryCoordNoPerspSampleAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4995,IR(0, 0),IR(6112, 19)/* BaryCoordSmoothAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4996,IR(0, 0),IR(6131, 27)/* BaryCoordSmoothCentroidAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4997,IR(0, 0),IR(6158, 25)/* BaryCoordSmoothSampleAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {4998,IR(0, 0),IR(6183, 22)/* BaryCoordPullModelAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5014,IR(0, 0),IR(6205, 18)/* FragStencilRefEXT */,IR(0, 0),IR(42, 1),IR(11, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5021,IR(0, 0),IR(6240, 29)/* RemainingRecursionLevelsAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5073,IR(0, 0),IR(6287, 16)/* ShaderIndexAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5253,IR(0, 0),IR(6303, 15)/* ViewportMaskNV */,IR(0, 0),IR(44, 2),IR(12, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5257,IR(0, 0),IR(6339, 20)/* SecondaryPositionNV */,IR(0, 0),IR(46, 1),IR(14, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5258,IR(0, 0),IR(6378, 24)/* SecondaryViewportMaskNV */,IR(0, 0),IR(46, 1),IR(14, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5261,IR(0, 0),IR(6402, 18)/* PositionPerViewNV */,IR(0, 0),IR(47, 2),IR(15, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5262,IR(0, 0),IR(6440, 22)/* ViewportMaskPerViewNV */,IR(0, 0),IR(47, 2),IR(15, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5264,IR(0, 0),IR(6462, 16)/* FullyCoveredEXT */,IR(0, 0),IR(49, 1),IR(17, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5274,IR(0, 0),IR(6502, 12)/* TaskCountNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5275,IR(0, 0),IR(6514, 17)/* PrimitiveCountNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5276,IR(0, 0),IR(6531, 19)/* PrimitiveIndicesNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5277,IR(0, 0),IR(6550, 22)/* ClipDistancePerViewNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5278,IR(0, 0),IR(6572, 22)/* CullDistancePerViewNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5279,IR(0, 0),IR(6594, 15)/* LayerPerViewNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5280,IR(0, 0),IR(6609, 16)/* MeshViewCountNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5281,IR(0, 0),IR(6625, 18)/* MeshViewIndicesNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5286,IR(0, 0),IR(6643, 13)/* BaryCoordKHR */,IR(6, 1),IR(51, 1),IR(19, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5287,IR(0, 0),IR(6691, 20)/* BaryCoordNoPerspKHR */,IR(7, 1),IR(51, 1),IR(19, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5292,IR(0, 0),IR(6730, 12)/* FragSizeEXT */,IR(8, 1),IR(52, 1),IR(21, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5293,IR(0, 0),IR(6776, 23)/* FragInvocationCountEXT */,IR(9, 1),IR(52, 1),IR(21, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5294,IR(0, 0),IR(6821, 25)/* PrimitivePointIndicesEXT */,IR(0, 0),IR(53, 1),IR(23, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5295,IR(0, 0),IR(6846, 24)/* PrimitiveLineIndicesEXT */,IR(0, 0),IR(53, 1),IR(23, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5296,IR(0, 0),IR(6870, 28)/* PrimitiveTriangleIndicesEXT */,IR(0, 0),IR(53, 1),IR(23, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5299,IR(0, 0),IR(6898, 17)/* CullPrimitiveEXT */,IR(0, 0),IR(53, 1),IR(23, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5319,IR(0, 0),IR(6915, 12)/* LaunchIdKHR */,IR(10, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5320,IR(0, 0),IR(6938, 14)/* LaunchSizeKHR */,IR(11, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5321,IR(0, 0),IR(6965, 18)/* WorldRayOriginKHR */,IR(12, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5322,IR(0, 0),IR(7000, 21)/* WorldRayDirectionKHR */,IR(13, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5323,IR(0, 0),IR(7041, 19)/* ObjectRayOriginKHR */,IR(14, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5324,IR(0, 0),IR(7078, 22)/* ObjectRayDirectionKHR */,IR(15, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5325,IR(0, 0),IR(7121, 11)/* RayTminKHR */,IR(16, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5326,IR(0, 0),IR(7142, 11)/* RayTmaxKHR */,IR(17, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5327,IR(0, 0),IR(7163, 23)/* InstanceCustomIndexKHR */,IR(18, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5330,IR(0, 0),IR(7208, 17)/* ObjectToWorldKHR */,IR(19, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5331,IR(0, 0),IR(7241, 17)/* WorldToObjectKHR */,IR(20, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5332,IR(0, 0),IR(7274, 7)/* HitTNV */,IR(0, 0),IR(56, 1),IR(26, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5333,IR(0, 0),IR(7281, 11)/* HitKindKHR */,IR(21, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5334,IR(0, 0),IR(7302, 17)/* CurrentRayTimeNV */,IR(0, 0),IR(57, 1),IR(27, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5335,IR(0, 0),IR(7342, 30)/* HitTriangleVertexPositionsKHR */,IR(0, 0),IR(58, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5337,IR(0, 0),IR(7399, 34)/* HitMicroTriangleVertexPositionsNV */,IR(0, 0),IR(59, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5344,IR(0, 0),IR(7466, 37)/* HitMicroTriangleVertexBarycentricsNV */,IR(0, 0),IR(59, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5351,IR(0, 0),IR(7503, 20)/* IncomingRayFlagsKHR */,IR(22, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5352,IR(0, 0),IR(7542, 20)/* RayGeometryIndexKHR */,IR(0, 0),IR(60, 1),IR(28, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5359,IR(0, 0),IR(7562, 14)/* HitIsSphereNV */,IR(0, 0),IR(61, 1),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5360,IR(0, 0),IR(7604, 11)/* HitIsLSSNV */,IR(0, 0),IR(62, 1),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5361,IR(0, 0),IR(7654, 20)/* HitSpherePositionNV */,IR(0, 0),IR(61, 1),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5374,IR(0, 0),IR(7674, 13)/* WarpsPerSMNV */,IR(0, 0),IR(63, 1),IR(30, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5375,IR(0, 0),IR(7706, 10)/* SMCountNV */,IR(0, 0),IR(63, 1),IR(30, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5376,IR(0, 0),IR(7716, 9)/* WarpIDNV */,IR(0, 0),IR(63, 1),IR(30, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5377,IR(0, 0),IR(7725, 7)/* SMIDNV */,IR(0, 0),IR(63, 1),IR(30, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5396,IR(0, 0),IR(7732, 18)/* HitLSSPositionsNV */,IR(0, 0),IR(62, 1),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5405,IR(0, 0),IR(7750, 34)/* HitKindFrontFacingMicroTriangleNV */,IR(0, 0),IR(59, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5406,IR(0, 0),IR(7784, 33)/* HitKindBackFacingMicroTriangleNV */,IR(0, 0),IR(59, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5420,IR(0, 0),IR(7817, 18)/* HitSphereRadiusNV */,IR(0, 0),IR(61, 1),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5421,IR(0, 0),IR(7835, 14)/* HitLSSRadiiNV */,IR(0, 0),IR(62, 1),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {5436,IR(0, 0),IR(7849, 12)/* ClusterIDNV */,IR(0, 0),IR(64, 1),IR(31, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {6021,IR(0, 0),IR(7902, 12)/* CullMaskKHR */,IR(0, 0),IR(65, 1),IR(32, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_BUILT_IN + {0,IR(0, 0),IR(7929, 7)/* Matrix */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {1,IR(0, 0),IR(4800, 7)/* Shader */,IR(0, 0),IR(66, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {2,IR(0, 0),IR(4875, 9)/* Geometry */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {3,IR(0, 0),IR(4884, 13)/* Tessellation */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4,IR(0, 0),IR(4688, 10)/* Addresses */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5,IR(0, 0),IR(7936, 8)/* Linkage */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6,IR(0, 0),IR(4642, 7)/* Kernel */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {7,IR(0, 0),IR(7944, 9)/* Vector16 */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {8,IR(0, 0),IR(7953, 14)/* Float16Buffer */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {9,IR(0, 0),IR(7967, 8)/* Float16 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {10,IR(0, 0),IR(7975, 8)/* Float64 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {11,IR(0, 0),IR(7983, 6)/* Int64 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {12,IR(0, 0),IR(7989, 13)/* Int64Atomics */,IR(0, 0),IR(67, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {13,IR(0, 0),IR(8002, 11)/* ImageBasic */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {14,IR(0, 0),IR(8013, 15)/* ImageReadWrite */,IR(0, 0),IR(68, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {15,IR(0, 0),IR(8028, 12)/* ImageMipmap */,IR(0, 0),IR(68, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {17,IR(0, 0),IR(8040, 6)/* Pipes */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {18,IR(0, 0),IR(8046, 7)/* Groups */,IR(0, 0),IR(1, 0),IR(33, 1),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {19,IR(0, 0),IR(8053, 14)/* DeviceEnqueue */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {20,IR(0, 0),IR(8067, 15)/* LiteralSampler */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {21,IR(0, 0),IR(8082, 14)/* AtomicStorage */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {22,IR(0, 0),IR(8096, 6)/* Int16 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {23,IR(0, 0),IR(8102, 22)/* TessellationPointSize */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {24,IR(0, 0),IR(8124, 18)/* GeometryPointSize */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {25,IR(0, 0),IR(8142, 20)/* ImageGatherExtended */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {27,IR(0, 0),IR(8162, 24)/* StorageImageMultisample */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {28,IR(0, 0),IR(8186, 34)/* UniformBufferArrayDynamicIndexing */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {29,IR(0, 0),IR(8220, 33)/* SampledImageArrayDynamicIndexing */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {30,IR(0, 0),IR(8253, 34)/* StorageBufferArrayDynamicIndexing */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {31,IR(0, 0),IR(8287, 33)/* StorageImageArrayDynamicIndexing */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {32,IR(0, 0),IR(4817, 13)/* ClipDistance */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {33,IR(0, 0),IR(4830, 13)/* CullDistance */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {34,IR(0, 0),IR(8320, 15)/* ImageCubeArray */,IR(0, 0),IR(70, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {35,IR(0, 0),IR(5156, 18)/* SampleRateShading */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {36,IR(0, 0),IR(8352, 10)/* ImageRect */,IR(0, 0),IR(71, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {37,IR(0, 0),IR(8362, 12)/* SampledRect */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {38,IR(0, 0),IR(8374, 15)/* GenericPointer */,IR(0, 0),IR(1, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {39,IR(0, 0),IR(8389, 5)/* Int8 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {40,IR(0, 0),IR(8394, 16)/* InputAttachment */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {41,IR(0, 0),IR(8410, 16)/* SparseResidency */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {42,IR(0, 0),IR(8426, 7)/* MinLod */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {43,IR(0, 0),IR(8433, 10)/* Sampled1D */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {44,IR(0, 0),IR(8443, 8)/* Image1D */,IR(0, 0),IR(72, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {45,IR(0, 0),IR(8335, 17)/* SampledCubeArray */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {46,IR(0, 0),IR(8451, 14)/* SampledBuffer */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {47,IR(0, 0),IR(8465, 12)/* ImageBuffer */,IR(0, 0),IR(73, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {48,IR(0, 0),IR(8477, 13)/* ImageMSArray */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {49,IR(0, 0),IR(8490, 28)/* StorageImageExtendedFormats */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {50,IR(0, 0),IR(8518, 11)/* ImageQuery */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {51,IR(0, 0),IR(8529, 18)/* DerivativeControl */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {52,IR(0, 0),IR(8547, 22)/* InterpolationFunction */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {53,IR(0, 0),IR(8569, 18)/* TransformFeedback */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {54,IR(0, 0),IR(8587, 16)/* GeometryStreams */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {55,IR(0, 0),IR(8603, 30)/* StorageImageReadWithoutFormat */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {56,IR(0, 0),IR(8633, 31)/* StorageImageWriteWithoutFormat */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {57,IR(0, 0),IR(5026, 14)/* MultiViewport */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {58,IR(0, 0),IR(8664, 17)/* SubgroupDispatch */,IR(0, 0),IR(74, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {59,IR(0, 0),IR(8681, 13)/* NamedBarrier */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {60,IR(0, 0),IR(8694, 12)/* PipeStorage */,IR(0, 0),IR(75, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {61,IR(0, 0),IR(5407, 16)/* GroupNonUniform */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {62,IR(0, 0),IR(8706, 20)/* GroupNonUniformVote */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {63,IR(0, 0),IR(8726, 26)/* GroupNonUniformArithmetic */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {64,IR(0, 0),IR(5662, 22)/* GroupNonUniformBallot */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {65,IR(0, 0),IR(8752, 23)/* GroupNonUniformShuffle */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {66,IR(0, 0),IR(8775, 31)/* GroupNonUniformShuffleRelative */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {67,IR(0, 0),IR(8806, 25)/* GroupNonUniformClustered */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {68,IR(0, 0),IR(8831, 20)/* GroupNonUniformQuad */,IR(0, 0),IR(76, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {69,IR(0, 0),IR(4972, 12)/* ShaderLayer */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {70,IR(0, 0),IR(5040, 20)/* ShaderViewportIndex */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {71,IR(0, 0),IR(8851, 18)/* UniformDecoration */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4165,IR(0, 0),IR(5564, 16)/* CoreBuiltinsARM */,IR(0, 0),IR(1, 0),IR(34, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4166,IR(0, 0),IR(8869, 28)/* TileImageColorReadAccessEXT */,IR(0, 0),IR(1, 0),IR(35, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4167,IR(0, 0),IR(8897, 28)/* TileImageDepthReadAccessEXT */,IR(0, 0),IR(1, 0),IR(35, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4168,IR(0, 0),IR(8925, 30)/* TileImageStencilReadAccessEXT */,IR(0, 0),IR(1, 0),IR(35, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4174,IR(0, 0),IR(8955, 11)/* TensorsARM */,IR(0, 0),IR(1, 0),IR(36, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4175,IR(0, 0),IR(8966, 37)/* StorageTensorArrayDynamicIndexingARM */,IR(0, 0),IR(1, 0),IR(36, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4176,IR(0, 0),IR(9003, 40)/* StorageTensorArrayNonUniformIndexingARM */,IR(0, 0),IR(1, 0),IR(36, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4191,IR(0, 0),IR(9043, 9)/* GraphARM */,IR(0, 0),IR(1, 0),IR(37, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4201,IR(0, 0),IR(9052, 28)/* CooperativeMatrixLayoutsARM */,IR(0, 0),IR(1, 0),IR(38, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4212,IR(0, 0),IR(9080, 10)/* Float8EXT */,IR(0, 0),IR(1, 0),IR(39, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4213,IR(0, 0),IR(9090, 27)/* Float8CooperativeMatrixEXT */,IR(0, 0),IR(77, 2),IR(39, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4422,IR(0, 0),IR(5889, 23)/* FragmentShadingRateKHR */,IR(0, 0),IR(3, 1),IR(7, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4423,IR(0, 0),IR(5423, 18)/* SubgroupBallotKHR */,IR(0, 0),IR(1, 0),IR(2, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4427,IR(0, 0),IR(5827, 15)/* DrawParameters */,IR(0, 0),IR(3, 1),IR(3, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4428,IR(0, 0),IR(9138, 33)/* WorkgroupMemoryExplicitLayoutKHR */,IR(0, 0),IR(3, 1),IR(40, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4429,IR(0, 0),IR(9171, 43)/* WorkgroupMemoryExplicitLayout8BitAccessKHR */,IR(0, 0),IR(79, 1),IR(40, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4430,IR(0, 0),IR(9214, 44)/* WorkgroupMemoryExplicitLayout16BitAccessKHR */,IR(0, 0),IR(79, 1),IR(40, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4431,IR(0, 0),IR(9258, 16)/* SubgroupVoteKHR */,IR(0, 0),IR(1, 0),IR(41, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4433,IR(0, 0),IR(9274, 25)/* StorageBuffer16BitAccess */,IR(23, 1),IR(1, 0),IR(42, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4434,IR(0, 0),IR(9327, 35)/* UniformAndStorageBuffer16BitAccess */,IR(24, 1),IR(80, 1),IR(42, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4435,IR(0, 0),IR(9379, 22)/* StoragePushConstant16 */,IR(0, 0),IR(1, 0),IR(42, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4436,IR(0, 0),IR(9401, 21)/* StorageInputOutput16 */,IR(0, 0),IR(1, 0),IR(42, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4437,IR(0, 0),IR(5924, 12)/* DeviceGroup */,IR(0, 0),IR(1, 0),IR(8, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4439,IR(0, 0),IR(5946, 10)/* MultiView */,IR(0, 0),IR(3, 1),IR(9, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4441,IR(0, 0),IR(9422, 30)/* VariablePointersStorageBuffer */,IR(0, 0),IR(3, 1),IR(43, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4442,IR(0, 0),IR(9452, 17)/* VariablePointers */,IR(0, 0),IR(81, 1),IR(43, 1),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4445,IR(0, 0),IR(9469, 17)/* AtomicStorageOps */,IR(0, 0),IR(82, 1),IR(44, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4447,IR(0, 0),IR(9486, 28)/* SampleMaskPostDepthCoverage */,IR(0, 0),IR(1, 0),IR(45, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4448,IR(0, 0),IR(9514, 24)/* StorageBuffer8BitAccess */,IR(0, 0),IR(1, 0),IR(46, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4449,IR(0, 0),IR(9538, 34)/* UniformAndStorageBuffer8BitAccess */,IR(0, 0),IR(83, 1),IR(46, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4450,IR(0, 0),IR(9572, 21)/* StoragePushConstant8 */,IR(0, 0),IR(1, 0),IR(46, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4464,IR(0, 0),IR(9593, 15)/* DenormPreserve */,IR(0, 0),IR(1, 0),IR(47, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4465,IR(0, 0),IR(9608, 18)/* DenormFlushToZero */,IR(0, 0),IR(1, 0),IR(47, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4466,IR(0, 0),IR(9626, 25)/* SignedZeroInfNanPreserve */,IR(0, 0),IR(1, 0),IR(47, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4467,IR(0, 0),IR(9651, 16)/* RoundingModeRTE */,IR(0, 0),IR(1, 0),IR(47, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4468,IR(0, 0),IR(9667, 16)/* RoundingModeRTZ */,IR(0, 0),IR(1, 0),IR(47, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4471,IR(0, 0),IR(9683, 23)/* RayQueryProvisionalKHR */,IR(0, 0),IR(3, 1),IR(48, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4472,IR(0, 0),IR(9706, 12)/* RayQueryKHR */,IR(0, 0),IR(3, 1),IR(48, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4473,IR(0, 0),IR(9718, 19)/* UntypedPointersKHR */,IR(0, 0),IR(1, 0),IR(49, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4478,IR(0, 0),IR(9737, 32)/* RayTraversalPrimitiveCullingKHR */,IR(0, 0),IR(84, 2),IR(50, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4479,IR(0, 0),IR(4910, 14)/* RayTracingKHR */,IR(0, 0),IR(3, 1),IR(28, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4484,IR(0, 0),IR(9769, 26)/* TextureSampleWeightedQCOM */,IR(0, 0),IR(1, 0),IR(52, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4485,IR(0, 0),IR(9795, 21)/* TextureBoxFilterQCOM */,IR(0, 0),IR(1, 0),IR(52, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4486,IR(0, 0),IR(9816, 22)/* TextureBlockMatchQCOM */,IR(0, 0),IR(1, 0),IR(52, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4495,IR(0, 0),IR(5986, 16)/* TileShadingQCOM */,IR(0, 0),IR(3, 1),IR(53, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4496,IR(0, 0),IR(9838, 32)/* CooperativeMatrixConversionQCOM */,IR(0, 0),IR(86, 1),IR(54, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {4498,IR(0, 0),IR(9870, 23)/* TextureBlockMatch2QCOM */,IR(0, 0),IR(1, 0),IR(55, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5008,IR(0, 0),IR(9893, 16)/* Float16ImageAMD */,IR(0, 0),IR(3, 1),IR(56, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5009,IR(0, 0),IR(9909, 22)/* ImageGatherBiasLodAMD */,IR(0, 0),IR(3, 1),IR(57, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5010,IR(0, 0),IR(9931, 16)/* FragmentMaskAMD */,IR(0, 0),IR(3, 1),IR(58, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5013,IR(0, 0),IR(6223, 17)/* StencilExportEXT */,IR(0, 0),IR(3, 1),IR(11, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5015,IR(0, 0),IR(9947, 21)/* ImageReadWriteLodAMD */,IR(0, 0),IR(3, 1),IR(59, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5016,IR(0, 0),IR(9968, 14)/* Int64ImageEXT */,IR(0, 0),IR(3, 1),IR(60, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5055,IR(0, 0),IR(9982, 15)/* ShaderClockKHR */,IR(0, 0),IR(1, 0),IR(61, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5067,IR(0, 0),IR(6269, 18)/* ShaderEnqueueAMDX */,IR(0, 0),IR(3, 1),IR(62, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5087,IR(0, 0),IR(9997, 15)/* QuadControlKHR */,IR(0, 0),IR(1, 0),IR(63, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5112,IR(0, 0),IR(10012, 14)/* Int4TypeINTEL */,IR(0, 0),IR(1, 0),IR(64, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5114,IR(0, 0),IR(10026, 27)/* Int4CooperativeMatrixINTEL */,IR(0, 0),IR(87, 2),IR(64, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5116,IR(0, 0),IR(10053, 16)/* BFloat16TypeKHR */,IR(0, 0),IR(1, 0),IR(65, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5117,IR(0, 0),IR(10069, 22)/* BFloat16DotProductKHR */,IR(0, 0),IR(89, 1),IR(65, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5118,IR(0, 0),IR(10091, 29)/* BFloat16CooperativeMatrixKHR */,IR(0, 0),IR(90, 2),IR(65, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5249,IR(0, 0),IR(10120, 29)/* SampleMaskOverrideCoverageNV */,IR(0, 0),IR(25, 1),IR(66, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5251,IR(0, 0),IR(10149, 28)/* GeometryShaderPassthroughNV */,IR(0, 0),IR(69, 1),IR(67, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5254,IR(0, 0),IR(4984, 28)/* ShaderViewportIndexLayerEXT */,IR(25, 1),IR(92, 1),IR(68, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5255,IR(0, 0),IR(6318, 21)/* ShaderViewportMaskNV */,IR(0, 0),IR(93, 1),IR(70, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5259,IR(0, 0),IR(6359, 19)/* ShaderStereoViewNV */,IR(0, 0),IR(94, 1),IR(14, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5260,IR(0, 0),IR(6420, 20)/* PerViewAttributesNV */,IR(0, 0),IR(40, 1),IR(71, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5265,IR(0, 0),IR(6478, 24)/* FragmentFullyCoveredEXT */,IR(0, 0),IR(3, 1),IR(17, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5266,IR(0, 0),IR(4924, 14)/* MeshShadingNV */,IR(0, 0),IR(3, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5282,IR(0, 0),IR(10204, 17)/* ImageFootprintNV */,IR(0, 0),IR(1, 0),IR(72, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5283,IR(0, 0),IR(4938, 15)/* MeshShadingEXT */,IR(0, 0),IR(3, 1),IR(23, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5284,IR(0, 0),IR(6668, 23)/* FragmentBarycentricKHR */,IR(26, 1),IR(1, 0),IR(19, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5288,IR(0, 0),IR(10243, 31)/* ComputeDerivativeGroupQuadsKHR */,IR(27, 1),IR(3, 1),IR(73, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5291,IR(0, 0),IR(6757, 19)/* FragmentDensityEXT */,IR(28, 1),IR(3, 1),IR(21, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5297,IR(0, 0),IR(10318, 29)/* GroupNonUniformPartitionedNV */,IR(0, 0),IR(1, 0),IR(75, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5301,IR(0, 0),IR(10347, 17)/* ShaderNonUniform */,IR(29, 1),IR(3, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5302,IR(0, 0),IR(10384, 23)/* RuntimeDescriptorArray */,IR(30, 1),IR(3, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5303,IR(0, 0),IR(10433, 36)/* InputAttachmentArrayDynamicIndexing */,IR(31, 1),IR(95, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5304,IR(0, 0),IR(10508, 39)/* UniformTexelBufferArrayDynamicIndexing */,IR(32, 1),IR(73, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5305,IR(0, 0),IR(10589, 39)/* StorageTexelBufferArrayDynamicIndexing */,IR(33, 1),IR(96, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5306,IR(0, 0),IR(10670, 37)/* UniformBufferArrayNonUniformIndexing */,IR(34, 1),IR(97, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5307,IR(0, 0),IR(10747, 36)/* SampledImageArrayNonUniformIndexing */,IR(35, 1),IR(97, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5308,IR(0, 0),IR(10822, 37)/* StorageBufferArrayNonUniformIndexing */,IR(36, 1),IR(97, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5309,IR(0, 0),IR(10899, 36)/* StorageImageArrayNonUniformIndexing */,IR(37, 1),IR(97, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5310,IR(0, 0),IR(10974, 39)/* InputAttachmentArrayNonUniformIndexing */,IR(38, 1),IR(98, 2),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5311,IR(0, 0),IR(11055, 42)/* UniformTexelBufferArrayNonUniformIndexing */,IR(39, 1),IR(100, 2),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5312,IR(0, 0),IR(11142, 42)/* StorageTexelBufferArrayNonUniformIndexing */,IR(40, 1),IR(102, 2),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5336,IR(0, 0),IR(7372, 27)/* RayTracingPositionFetchKHR */,IR(0, 0),IR(3, 1),IR(77, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5340,IR(0, 0),IR(4897, 13)/* RayTracingNV */,IR(0, 0),IR(3, 1),IR(26, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5341,IR(0, 0),IR(7319, 23)/* RayTracingMotionBlurNV */,IR(0, 0),IR(3, 1),IR(27, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5345,IR(0, 0),IR(11229, 18)/* VulkanMemoryModel */,IR(41, 1),IR(1, 0),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5346,IR(0, 0),IR(11268, 29)/* VulkanMemoryModelDeviceScope */,IR(42, 1),IR(1, 0),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5347,IR(0, 0),IR(4760, 31)/* PhysicalStorageBufferAddresses */,IR(43, 1),IR(3, 1),IR(0, 2),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5350,IR(0, 0),IR(11363, 32)/* ComputeDerivativeGroupLinearKHR */,IR(44, 1),IR(3, 1),IR(73, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5353,IR(0, 0),IR(11426, 25)/* RayTracingProvisionalKHR */,IR(0, 0),IR(3, 1),IR(28, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5357,IR(0, 0),IR(11451, 20)/* CooperativeMatrixNV */,IR(0, 0),IR(3, 1),IR(79, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5363,IR(0, 0),IR(11471, 33)/* FragmentShaderSampleInterlockEXT */,IR(0, 0),IR(3, 1),IR(80, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5372,IR(0, 0),IR(11504, 38)/* FragmentShaderShadingRateInterlockEXT */,IR(0, 0),IR(3, 1),IR(80, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5373,IR(0, 0),IR(7687, 19)/* ShaderSMBuiltinsNV */,IR(0, 0),IR(3, 1),IR(30, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5378,IR(0, 0),IR(11542, 32)/* FragmentShaderPixelInterlockEXT */,IR(0, 0),IR(3, 1),IR(80, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5379,IR(0, 0),IR(11574, 25)/* DemoteToHelperInvocation */,IR(45, 1),IR(3, 1),IR(81, 1),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5380,IR(0, 0),IR(11627, 23)/* DisplacementMicromapNV */,IR(0, 0),IR(3, 1),IR(82, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5381,IR(0, 0),IR(11650, 29)/* RayTracingOpacityMicromapEXT */,IR(0, 0),IR(3, 1),IR(83, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5383,IR(0, 0),IR(11679, 26)/* ShaderInvocationReorderNV */,IR(0, 0),IR(60, 1),IR(84, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5390,IR(0, 0),IR(11705, 18)/* BindlessTextureNV */,IR(0, 0),IR(1, 0),IR(85, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5391,IR(0, 0),IR(11723, 25)/* RayQueryPositionFetchKHR */,IR(0, 0),IR(3, 1),IR(77, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5394,IR(0, 0),IR(11748, 20)/* CooperativeVectorNV */,IR(0, 0),IR(1, 0),IR(86, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5404,IR(0, 0),IR(11768, 22)/* AtomicFloat16VectorNV */,IR(0, 0),IR(1, 0),IR(87, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5409,IR(0, 0),IR(7433, 33)/* RayTracingDisplacementMicromapNV */,IR(0, 0),IR(60, 1),IR(82, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5414,IR(0, 0),IR(11790, 18)/* RawAccessChainsNV */,IR(0, 0),IR(1, 0),IR(88, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5418,IR(0, 0),IR(7576, 28)/* RayTracingSpheresGeometryNV */,IR(0, 0),IR(1, 0),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5419,IR(0, 0),IR(7615, 39)/* RayTracingLinearSweptSpheresGeometryNV */,IR(0, 0),IR(1, 0),IR(29, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5430,IR(0, 0),IR(11808, 30)/* CooperativeMatrixReductionsNV */,IR(0, 0),IR(1, 0),IR(89, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5431,IR(0, 0),IR(11838, 31)/* CooperativeMatrixConversionsNV */,IR(0, 0),IR(1, 0),IR(89, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5432,IR(0, 0),IR(11869, 40)/* CooperativeMatrixPerElementOperationsNV */,IR(0, 0),IR(1, 0),IR(89, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5433,IR(0, 0),IR(11909, 36)/* CooperativeMatrixTensorAddressingNV */,IR(0, 0),IR(1, 0),IR(89, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5434,IR(0, 0),IR(11945, 30)/* CooperativeMatrixBlockLoadsNV */,IR(0, 0),IR(1, 0),IR(89, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5435,IR(0, 0),IR(11975, 28)/* CooperativeVectorTrainingNV */,IR(0, 0),IR(1, 0),IR(86, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5437,IR(0, 0),IR(7861, 41)/* RayTracingClusterAccelerationStructureNV */,IR(0, 0),IR(60, 1),IR(31, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5439,IR(0, 0),IR(12003, 19)/* TensorAddressingNV */,IR(0, 0),IR(1, 0),IR(90, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5568,IR(0, 0),IR(12022, 21)/* SubgroupShuffleINTEL */,IR(0, 0),IR(1, 0),IR(91, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5569,IR(0, 0),IR(12043, 27)/* SubgroupBufferBlockIOINTEL */,IR(0, 0),IR(1, 0),IR(91, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5570,IR(0, 0),IR(12070, 26)/* SubgroupImageBlockIOINTEL */,IR(0, 0),IR(1, 0),IR(91, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5579,IR(0, 0),IR(12096, 31)/* SubgroupImageMediaBlockIOINTEL */,IR(0, 0),IR(1, 0),IR(92, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5582,IR(0, 0),IR(12127, 21)/* RoundToInfinityINTEL */,IR(0, 0),IR(1, 0),IR(93, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5583,IR(0, 0),IR(12148, 23)/* FloatingPointModeINTEL */,IR(0, 0),IR(1, 0),IR(93, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5584,IR(0, 0),IR(12171, 23)/* IntegerFunctions2INTEL */,IR(0, 0),IR(1, 0),IR(94, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5603,IR(0, 0),IR(12194, 22)/* FunctionPointersINTEL */,IR(0, 0),IR(1, 0),IR(95, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5604,IR(0, 0),IR(12216, 24)/* IndirectReferencesINTEL */,IR(0, 0),IR(1, 0),IR(95, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5606,IR(0, 0),IR(12240, 9)/* AsmINTEL */,IR(0, 0),IR(1, 0),IR(96, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5612,IR(0, 0),IR(12249, 23)/* AtomicFloat32MinMaxEXT */,IR(0, 0),IR(1, 0),IR(97, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5613,IR(0, 0),IR(12272, 23)/* AtomicFloat64MinMaxEXT */,IR(0, 0),IR(1, 0),IR(97, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5616,IR(0, 0),IR(12295, 23)/* AtomicFloat16MinMaxEXT */,IR(0, 0),IR(1, 0),IR(97, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5617,IR(0, 0),IR(12318, 19)/* VectorComputeINTEL */,IR(0, 0),IR(104, 1),IR(98, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5619,IR(0, 0),IR(12337, 15)/* VectorAnyINTEL */,IR(0, 0),IR(1, 0),IR(98, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5629,IR(0, 0),IR(12352, 16)/* ExpectAssumeKHR */,IR(0, 0),IR(1, 0),IR(99, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5696,IR(0, 0),IR(12368, 33)/* SubgroupAvcMotionEstimationINTEL */,IR(0, 0),IR(1, 0),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5697,IR(0, 0),IR(12401, 38)/* SubgroupAvcMotionEstimationIntraINTEL */,IR(0, 0),IR(1, 0),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5698,IR(0, 0),IR(12439, 39)/* SubgroupAvcMotionEstimationChromaINTEL */,IR(0, 0),IR(1, 0),IR(100, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5817,IR(0, 0),IR(12478, 25)/* VariableLengthArrayINTEL */,IR(0, 0),IR(1, 0),IR(101, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5821,IR(0, 0),IR(12503, 26)/* FunctionFloatControlINTEL */,IR(0, 0),IR(1, 0),IR(93, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5824,IR(0, 0),IR(12529, 26)/* FPGAMemoryAttributesINTEL */,IR(0, 0),IR(1, 0),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5837,IR(0, 0),IR(12555, 20)/* FPFastMathModeINTEL */,IR(0, 0),IR(0, 1),IR(103, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5844,IR(0, 0),IR(12575, 32)/* ArbitraryPrecisionIntegersINTEL */,IR(0, 0),IR(1, 0),IR(104, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5845,IR(0, 0),IR(12607, 37)/* ArbitraryPrecisionFloatingPointINTEL */,IR(0, 0),IR(1, 0),IR(105, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5886,IR(0, 0),IR(12644, 30)/* UnstructuredLoopControlsINTEL */,IR(0, 0),IR(1, 0),IR(106, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5888,IR(0, 0),IR(12674, 22)/* FPGALoopControlsINTEL */,IR(0, 0),IR(1, 0),IR(107, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5892,IR(0, 0),IR(12696, 22)/* KernelAttributesINTEL */,IR(0, 0),IR(1, 0),IR(108, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5897,IR(0, 0),IR(12718, 26)/* FPGAKernelAttributesINTEL */,IR(0, 0),IR(1, 0),IR(108, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5898,IR(0, 0),IR(12744, 24)/* FPGAMemoryAccessesINTEL */,IR(0, 0),IR(1, 0),IR(109, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5904,IR(0, 0),IR(12768, 27)/* FPGAClusterAttributesINTEL */,IR(0, 0),IR(1, 0),IR(110, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5906,IR(0, 0),IR(12795, 14)/* LoopFuseINTEL */,IR(0, 0),IR(1, 0),IR(111, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5908,IR(0, 0),IR(12809, 20)/* FPGADSPControlINTEL */,IR(0, 0),IR(1, 0),IR(112, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5910,IR(0, 0),IR(12829, 26)/* MemoryAccessAliasingINTEL */,IR(0, 0),IR(1, 0),IR(113, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5916,IR(0, 0),IR(12855, 40)/* FPGAInvocationPipeliningAttributesINTEL */,IR(0, 0),IR(1, 0),IR(114, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5920,IR(0, 0),IR(12895, 24)/* FPGABufferLocationINTEL */,IR(0, 0),IR(1, 0),IR(115, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5922,IR(0, 0),IR(12919, 34)/* ArbitraryPrecisionFixedPointINTEL */,IR(0, 0),IR(1, 0),IR(116, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5935,IR(0, 0),IR(12953, 23)/* USMStorageClassesINTEL */,IR(0, 0),IR(1, 0),IR(117, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5939,IR(0, 0),IR(12976, 29)/* RuntimeAlignedAttributeINTEL */,IR(0, 0),IR(1, 0),IR(118, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5943,IR(0, 0),IR(13005, 13)/* IOPipesINTEL */,IR(0, 0),IR(1, 0),IR(119, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5945,IR(0, 0),IR(13018, 19)/* BlockingPipesINTEL */,IR(0, 0),IR(1, 0),IR(120, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {5948,IR(0, 0),IR(13037, 13)/* FPGARegINTEL */,IR(0, 0),IR(1, 0),IR(121, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6016,IR(0, 0),IR(13050, 19)/* DotProductInputAll */,IR(46, 1),IR(1, 0),IR(122, 1),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6017,IR(0, 0),IR(13091, 22)/* DotProductInput4x8Bit */,IR(47, 1),IR(105, 1),IR(122, 1),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6018,IR(0, 0),IR(13138, 28)/* DotProductInput4x8BitPacked */,IR(48, 1),IR(1, 0),IR(122, 1),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6019,IR(0, 0),IR(13197, 11)/* DotProduct */,IR(49, 1),IR(1, 0),IR(122, 1),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6020,IR(0, 0),IR(7914, 15)/* RayCullMaskKHR */,IR(0, 0),IR(1, 0),IR(32, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6022,IR(0, 0),IR(9117, 21)/* CooperativeMatrixKHR */,IR(0, 0),IR(1, 0),IR(123, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6024,IR(0, 0),IR(13222, 24)/* ReplicatedCompositesEXT */,IR(0, 0),IR(1, 0),IR(124, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6025,IR(0, 0),IR(13246, 16)/* BitInstructions */,IR(0, 0),IR(1, 0),IR(125, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6026,IR(0, 0),IR(13262, 25)/* GroupNonUniformRotateKHR */,IR(0, 0),IR(76, 1),IR(126, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6029,IR(0, 0),IR(13287, 15)/* FloatControls2 */,IR(0, 0),IR(1, 0),IR(127, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6030,IR(0, 0),IR(13302, 7)/* FMAKHR */,IR(0, 0),IR(1, 0),IR(128, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6033,IR(0, 0),IR(13309, 20)/* AtomicFloat32AddEXT */,IR(0, 0),IR(1, 0),IR(129, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6034,IR(0, 0),IR(13329, 20)/* AtomicFloat64AddEXT */,IR(0, 0),IR(1, 0),IR(129, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6089,IR(0, 0),IR(13349, 20)/* LongCompositesINTEL */,IR(0, 0),IR(1, 0),IR(130, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6094,IR(0, 0),IR(13369, 11)/* OptNoneEXT */,IR(50, 1),IR(1, 0),IR(131, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6095,IR(0, 0),IR(13393, 20)/* AtomicFloat16AddEXT */,IR(0, 0),IR(1, 0),IR(133, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6114,IR(0, 0),IR(13413, 21)/* DebugInfoModuleINTEL */,IR(0, 0),IR(1, 0),IR(134, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6115,IR(0, 0),IR(13434, 24)/* BFloat16ConversionINTEL */,IR(0, 0),IR(1, 0),IR(135, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6141,IR(0, 0),IR(13458, 18)/* SplitBarrierINTEL */,IR(0, 0),IR(1, 0),IR(136, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6144,IR(0, 0),IR(13476, 19)/* ArithmeticFenceEXT */,IR(0, 0),IR(1, 0),IR(137, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6150,IR(0, 0),IR(13495, 29)/* FPGAClusterAttributesV2INTEL */,IR(0, 0),IR(106, 1),IR(110, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6161,IR(0, 0),IR(13524, 28)/* FPGAKernelAttributesv2INTEL */,IR(0, 0),IR(107, 1),IR(108, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6162,IR(0, 0),IR(13552, 18)/* TaskSequenceINTEL */,IR(0, 0),IR(1, 0),IR(138, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6169,IR(0, 0),IR(13570, 16)/* FPMaxErrorINTEL */,IR(0, 0),IR(1, 0),IR(139, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6171,IR(0, 0),IR(13586, 24)/* FPGALatencyControlINTEL */,IR(0, 0),IR(1, 0),IR(140, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6174,IR(0, 0),IR(13610, 28)/* FPGAArgumentInterfacesINTEL */,IR(0, 0),IR(1, 0),IR(141, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6187,IR(0, 0),IR(13638, 30)/* GlobalVariableHostAccessINTEL */,IR(0, 0),IR(1, 0),IR(142, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6189,IR(0, 0),IR(13668, 35)/* GlobalVariableFPGADecorationsINTEL */,IR(0, 0),IR(1, 0),IR(143, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6220,IR(0, 0),IR(13703, 28)/* SubgroupBufferPrefetchINTEL */,IR(0, 0),IR(1, 0),IR(144, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6228,IR(0, 0),IR(13731, 23)/* Subgroup2DBlockIOINTEL */,IR(0, 0),IR(1, 0),IR(145, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6229,IR(0, 0),IR(13754, 30)/* Subgroup2DBlockTransformINTEL */,IR(0, 0),IR(108, 1),IR(145, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6230,IR(0, 0),IR(13784, 30)/* Subgroup2DBlockTransposeINTEL */,IR(0, 0),IR(108, 1),IR(145, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6236,IR(0, 0),IR(13814, 38)/* SubgroupMatrixMultiplyAccumulateINTEL */,IR(0, 0),IR(1, 0),IR(146, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6241,IR(0, 0),IR(13852, 28)/* TernaryBitwiseFunctionINTEL */,IR(0, 0),IR(1, 0),IR(147, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6243,IR(0, 0),IR(13880, 32)/* UntypedVariableLengthArrayINTEL */,IR(0, 0),IR(109, 2),IR(101, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6245,IR(0, 0),IR(13912, 21)/* SpecConditionalINTEL */,IR(0, 0),IR(1, 0),IR(148, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6246,IR(0, 0),IR(13933, 22)/* FunctionVariantsINTEL */,IR(0, 0),IR(111, 1),IR(148, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6400,IR(0, 0),IR(13955, 26)/* GroupUniformArithmeticKHR */,IR(0, 0),IR(1, 0),IR(149, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6425,IR(0, 0),IR(13981, 27)/* TensorFloat32RoundingINTEL */,IR(0, 0),IR(1, 0),IR(150, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6427,IR(0, 0),IR(14008, 25)/* MaskedGatherScatterINTEL */,IR(0, 0),IR(1, 0),IR(151, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6441,IR(0, 0),IR(14033, 19)/* CacheControlsINTEL */,IR(0, 0),IR(1, 0),IR(152, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6460,IR(0, 0),IR(14052, 20)/* RegisterLimitsINTEL */,IR(0, 0),IR(1, 0),IR(153, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {6528,IR(0, 0),IR(14072, 20)/* BindlessImagesINTEL */,IR(0, 0),IR(1, 0),IR(154, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_CAPABILITY + {0,IR(0, 0),IR(14092, 12)/* Unspecified */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {1,IR(0, 0),IR(14104, 8)/* Address */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {2,IR(0, 0),IR(14112, 8)/* Boolean */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {3,IR(0, 0),IR(14120, 6)/* Float */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {4,IR(0, 0),IR(14126, 7)/* Signed */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {5,IR(0, 0),IR(14133, 11)/* SignedChar */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {6,IR(0, 0),IR(14144, 9)/* Unsigned */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {7,IR(0, 0),IR(14153, 13)/* UnsignedChar */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {0,IR(0, 0),IR(14166, 6)/* Class */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE + {1,IR(0, 0),IR(14172, 10)/* Structure */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE + {2,IR(0, 0),IR(14182, 6)/* Union */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE + {0,IR(0, 0),IR(14188, 15)/* ImportedModule */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY + {1,IR(0, 0),IR(14203, 20)/* ImportedDeclaration */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {1,IR(0, 0),IR(14228, 16)/* FlagIsProtected */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {2,IR(0, 0),IR(14244, 14)/* FlagIsPrivate */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {3,IR(0, 0),IR(14258, 13)/* FlagIsPublic */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {4,IR(0, 0),IR(14271, 12)/* FlagIsLocal */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {8,IR(0, 0),IR(14283, 17)/* FlagIsDefinition */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {16,IR(0, 0),IR(14300, 12)/* FlagFwdDecl */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {32,IR(0, 0),IR(14312, 15)/* FlagArtificial */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {64,IR(0, 0),IR(14327, 13)/* FlagExplicit */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {128,IR(0, 0),IR(14340, 15)/* FlagPrototyped */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {256,IR(0, 0),IR(14355, 18)/* FlagObjectPointer */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {512,IR(0, 0),IR(14373, 17)/* FlagStaticMember */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {1024,IR(0, 0),IR(14390, 21)/* FlagIndirectVariable */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {2048,IR(0, 0),IR(14411, 20)/* FlagLValueReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {4096,IR(0, 0),IR(14431, 20)/* FlagRValueReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {8192,IR(0, 0),IR(14451, 16)/* FlagIsOptimized */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {16384,IR(0, 0),IR(14467, 16)/* FlagIsEnumClass */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {32768,IR(0, 0),IR(14483, 20)/* FlagTypePassByValue */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {65536,IR(0, 0),IR(14503, 24)/* FlagTypePassByReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {0,IR(0, 0),IR(14527, 6)/* Deref */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {1,IR(0, 0),IR(14533, 5)/* Plus */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {2,IR(0, 0),IR(14538, 6)/* Minus */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {3,IR(0, 1),IR(14577, 11)/* PlusUconst */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {4,IR(1, 2),IR(14588, 9)/* BitPiece */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {5,IR(0, 0),IR(14597, 5)/* Swap */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {6,IR(0, 0),IR(14602, 7)/* Xderef */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {7,IR(0, 0),IR(14609, 11)/* StackValue */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {8,IR(0, 1),IR(14620, 7)/* Constu */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {9,IR(1, 2),IR(14627, 9)/* Fragment */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {0,IR(0, 0),IR(14636, 10)/* ConstType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER + {1,IR(0, 0),IR(14646, 13)/* VolatileType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER + {2,IR(0, 0),IR(14659, 13)/* RestrictType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER + {3,IR(0, 0),IR(14672, 11)/* AtomicType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER + {0,IR(0, 0),IR(14683, 10)/* Float16NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {1,IR(0, 0),IR(14693, 10)/* Float32NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {2,IR(0, 0),IR(14703, 10)/* Float64NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {3,IR(0, 0),IR(14713, 13)/* SignedInt8NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {4,IR(0, 0),IR(14726, 14)/* SignedInt16NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {5,IR(0, 0),IR(14740, 14)/* SignedInt32NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {6,IR(0, 0),IR(14754, 14)/* SignedInt64NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {7,IR(0, 0),IR(14768, 15)/* UnsignedInt8NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {8,IR(0, 0),IR(14783, 16)/* UnsignedInt16NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {9,IR(0, 0),IR(14799, 16)/* UnsignedInt32NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {10,IR(0, 0),IR(14815, 16)/* UnsignedInt64NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {1000491000,IR(0, 0),IR(14831, 19)/* SignedInt8PackedNV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {1000491001,IR(0, 0),IR(14850, 21)/* UnsignedInt8PackedNV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {1000491002,IR(0, 0),IR(14871, 12)/* FloatE4M3NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {1000491003,IR(0, 0),IR(14883, 12)/* FloatE5M2NV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COMPONENT_TYPE + {0,IR(0, 0),IR(14895, 12)/* RowMajorKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT + {1,IR(0, 0),IR(14907, 15)/* ColumnMajorKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT + {4202,IR(0, 0),IR(14922, 25)/* RowBlockedInterleavedARM */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT + {4203,IR(0, 0),IR(14947, 28)/* ColumnBlockedInterleavedARM */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT + {0,IR(0, 0),IR(14975, 8)/* NoneKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS + {1,IR(0, 0),IR(14983, 27)/* MatrixASignedComponentsKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS + {2,IR(0, 0),IR(15010, 27)/* MatrixBSignedComponentsKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS + {4,IR(0, 0),IR(15037, 27)/* MatrixCSignedComponentsKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS + {8,IR(0, 0),IR(15064, 32)/* MatrixResultSignedComponentsKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS + {16,IR(0, 0),IR(15096, 26)/* SaturatingAccumulationKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS + {1,IR(0, 0),IR(15122, 4)/* Row */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE + {2,IR(0, 0),IR(15126, 7)/* Column */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE + {4,IR(0, 0),IR(15133, 4)/* 2x2 */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE + {0,IR(0, 0),IR(15137, 11)/* MatrixAKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE + {1,IR(0, 0),IR(15148, 11)/* MatrixBKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE + {2,IR(0, 0),IR(15159, 21)/* MatrixAccumulatorKHR */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE + {0,IR(0, 0),IR(15180, 11)/* RowMajorNV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT + {1,IR(0, 0),IR(15191, 14)/* ColumnMajorNV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT + {2,IR(0, 0),IR(15205, 21)/* InferencingOptimalNV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT + {3,IR(0, 0),IR(15226, 18)/* TrainingOptimalNV */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT + {0,IR(0, 0),IR(14092, 12)/* Unspecified */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {1,IR(0, 0),IR(14104, 8)/* Address */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {2,IR(0, 0),IR(14112, 8)/* Boolean */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {4,IR(0, 0),IR(14120, 6)/* Float */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {5,IR(0, 0),IR(14126, 7)/* Signed */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {6,IR(0, 0),IR(14133, 11)/* SignedChar */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {7,IR(0, 0),IR(14144, 9)/* Unsigned */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {8,IR(0, 0),IR(14153, 13)/* UnsignedChar */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {0,IR(0, 0),IR(14166, 6)/* Class */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE + {1,IR(0, 0),IR(14172, 10)/* Structure */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE + {2,IR(0, 0),IR(14182, 6)/* Union */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {1,IR(0, 0),IR(14228, 16)/* FlagIsProtected */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {2,IR(0, 0),IR(14244, 14)/* FlagIsPrivate */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {3,IR(0, 0),IR(14258, 13)/* FlagIsPublic */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {4,IR(0, 0),IR(14271, 12)/* FlagIsLocal */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {8,IR(0, 0),IR(14283, 17)/* FlagIsDefinition */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {16,IR(0, 0),IR(14300, 12)/* FlagFwdDecl */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {32,IR(0, 0),IR(14312, 15)/* FlagArtificial */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {64,IR(0, 0),IR(14327, 13)/* FlagExplicit */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {128,IR(0, 0),IR(14340, 15)/* FlagPrototyped */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {256,IR(0, 0),IR(14355, 18)/* FlagObjectPointer */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {512,IR(0, 0),IR(14373, 17)/* FlagStaticMember */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {1024,IR(0, 0),IR(14390, 21)/* FlagIndirectVariable */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {2048,IR(0, 0),IR(14411, 20)/* FlagLValueReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {4096,IR(0, 0),IR(14431, 20)/* FlagRValueReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {8192,IR(0, 0),IR(14451, 16)/* FlagIsOptimized */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {0,IR(0, 0),IR(14527, 6)/* Deref */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION + {1,IR(0, 0),IR(14533, 5)/* Plus */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION + {2,IR(0, 0),IR(14538, 6)/* Minus */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION + {3,IR(0, 1),IR(14577, 11)/* PlusUconst */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION + {4,IR(1, 2),IR(14588, 9)/* BitPiece */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION + {5,IR(0, 0),IR(14597, 5)/* Swap */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION + {6,IR(0, 0),IR(14602, 7)/* Xderef */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION + {7,IR(0, 0),IR(14609, 11)/* StackValue */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION + {8,IR(0, 1),IR(14620, 7)/* Constu */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_OPERATION + {0,IR(0, 0),IR(14636, 10)/* ConstType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER + {1,IR(0, 0),IR(14646, 13)/* VolatileType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER + {2,IR(0, 0),IR(14659, 13)/* RestrictType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER + {0,IR(0, 0),IR(15244, 17)/* RelaxedPrecision */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {1,IR(0, 1),IR(15261, 7)/* SpecId */,IR(0, 0),IR(112, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {2,IR(0, 0),IR(15268, 6)/* Block */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {3,IR(0, 0),IR(15274, 12)/* BufferBlock */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),SPV_SPIRV_VERSION_WORD(1,3)}, // SPV_OPERAND_TYPE_DECORATION + {4,IR(0, 0),IR(15286, 9)/* RowMajor */,IR(0, 0),IR(66, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5,IR(0, 0),IR(15295, 9)/* ColMajor */,IR(0, 0),IR(66, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6,IR(0, 1),IR(15304, 12)/* ArrayStride */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {7,IR(0, 1),IR(15316, 13)/* MatrixStride */,IR(0, 0),IR(66, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {8,IR(0, 0),IR(15329, 11)/* GLSLShared */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {9,IR(0, 0),IR(15340, 11)/* GLSLPacked */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {10,IR(0, 0),IR(15351, 8)/* CPacked */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {11,IR(3, 1),IR(15385, 8)/* BuiltIn */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {13,IR(0, 0),IR(15393, 14)/* NoPerspective */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {14,IR(0, 0),IR(15407, 5)/* Flat */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {15,IR(0, 0),IR(15412, 6)/* Patch */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {16,IR(0, 0),IR(15418, 9)/* Centroid */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {17,IR(0, 0),IR(15427, 7)/* Sample */,IR(0, 0),IR(25, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {18,IR(0, 0),IR(15434, 10)/* Invariant */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {19,IR(0, 0),IR(15444, 9)/* Restrict */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {20,IR(0, 0),IR(15453, 8)/* Aliased */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {21,IR(0, 0),IR(15461, 9)/* Volatile */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {22,IR(0, 0),IR(15470, 9)/* Constant */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {23,IR(0, 0),IR(15479, 9)/* Coherent */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {24,IR(0, 0),IR(15488, 12)/* NonWritable */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {25,IR(0, 0),IR(15500, 12)/* NonReadable */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {26,IR(0, 0),IR(15512, 8)/* Uniform */,IR(0, 0),IR(114, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {27,IR(4, 1),IR(15546, 10)/* UniformId */,IR(0, 0),IR(114, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {28,IR(0, 0),IR(15556, 20)/* SaturatedConversion */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {29,IR(0, 1),IR(15576, 7)/* Stream */,IR(0, 0),IR(116, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {30,IR(0, 1),IR(15583, 9)/* Location */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {31,IR(0, 1),IR(15592, 10)/* Component */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {32,IR(0, 1),IR(15602, 6)/* Index */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {33,IR(0, 1),IR(15608, 8)/* Binding */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {34,IR(0, 1),IR(15616, 14)/* DescriptorSet */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {35,IR(0, 1),IR(15630, 7)/* Offset */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {36,IR(0, 1),IR(15637, 10)/* XfbBuffer */,IR(0, 0),IR(117, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {37,IR(0, 1),IR(15647, 10)/* XfbStride */,IR(0, 0),IR(117, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {38,IR(5, 1),IR(15703, 14)/* FuncParamAttr */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {39,IR(6, 1),IR(15751, 15)/* FPRoundingMode */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {40,IR(7, 1),IR(15801, 15)/* FPFastMathMode */,IR(0, 0),IR(118, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {41,IR(8, 2),IR(15878, 18)/* LinkageAttributes */,IR(0, 0),IR(120, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {42,IR(0, 0),IR(15896, 14)/* NoContraction */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {43,IR(0, 1),IR(15910, 21)/* InputAttachmentIndex */,IR(0, 0),IR(95, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {44,IR(0, 1),IR(15931, 10)/* Alignment */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {45,IR(0, 1),IR(15941, 14)/* MaxByteOffset */,IR(0, 0),IR(1, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {46,IR(10, 1),IR(15975, 12)/* AlignmentId */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,2),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {47,IR(10, 1),IR(15987, 16)/* MaxByteOffsetId */,IR(0, 0),IR(1, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,2),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {4216,IR(0, 0),IR(16003, 44)/* SaturatedToLargestFloat8NormalConversionEXT */,IR(0, 0),IR(121, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {4469,IR(0, 0),IR(16047, 13)/* NoSignedWrap */,IR(0, 0),IR(1, 0),IR(155, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {4470,IR(0, 0),IR(16060, 15)/* NoUnsignedWrap */,IR(0, 0),IR(1, 0),IR(155, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {4487,IR(0, 0),IR(16075, 18)/* WeightTextureQCOM */,IR(0, 0),IR(1, 0),IR(52, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {4488,IR(0, 0),IR(16093, 22)/* BlockMatchTextureQCOM */,IR(0, 0),IR(1, 0),IR(52, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {4499,IR(0, 0),IR(16115, 22)/* BlockMatchSamplerQCOM */,IR(0, 0),IR(1, 0),IR(55, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {4999,IR(0, 0),IR(16137, 18)/* ExplicitInterpAMD */,IR(0, 0),IR(1, 0),IR(10, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5019,IR(10, 1),IR(16155, 32)/* NodeSharesPayloadLimitsWithAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5020,IR(10, 1),IR(16187, 20)/* NodeMaxPayloadsAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5078,IR(0, 0),IR(16207, 23)/* TrackFinishWritingAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5091,IR(10, 1),IR(16230, 20)/* PayloadNodeNameAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5098,IR(10, 1),IR(16250, 25)/* PayloadNodeBaseIndexAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5099,IR(0, 0),IR(16275, 27)/* PayloadNodeSparseArrayAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5100,IR(10, 1),IR(16302, 25)/* PayloadNodeArraySizeAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5105,IR(0, 0),IR(16327, 28)/* PayloadDispatchIndirectAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5248,IR(0, 0),IR(16355, 19)/* OverrideCoverageNV */,IR(0, 0),IR(122, 1),IR(66, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5250,IR(0, 0),IR(16374, 14)/* PassthroughNV */,IR(0, 0),IR(123, 1),IR(67, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5252,IR(0, 0),IR(16388, 19)/* ViewportRelativeNV */,IR(0, 0),IR(94, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5256,IR(0, 1),IR(16407, 28)/* SecondaryViewportRelativeNV */,IR(0, 0),IR(46, 1),IR(14, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5271,IR(0, 0),IR(16435, 16)/* PerPrimitiveEXT */,IR(51, 1),IR(124, 2),IR(156, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5272,IR(0, 0),IR(16466, 10)/* PerViewNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5273,IR(0, 0),IR(16476, 10)/* PerTaskNV */,IR(0, 0),IR(50, 1),IR(18, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5285,IR(0, 0),IR(16486, 13)/* PerVertexKHR */,IR(52, 1),IR(51, 1),IR(19, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5300,IR(0, 0),IR(16511, 11)/* NonUniform */,IR(53, 1),IR(97, 1),IR(76, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5355,IR(0, 0),IR(16536, 16)/* RestrictPointer */,IR(54, 1),IR(2, 1),IR(0, 2),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5356,IR(0, 0),IR(16571, 15)/* AliasedPointer */,IR(55, 1),IR(2, 1),IR(0, 2),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5386,IR(0, 0),IR(16604, 30)/* HitObjectShaderRecordBufferNV */,IR(0, 0),IR(126, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5398,IR(0, 0),IR(16634, 18)/* BindlessSamplerNV */,IR(0, 0),IR(127, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5399,IR(0, 0),IR(16652, 16)/* BindlessImageNV */,IR(0, 0),IR(127, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5400,IR(0, 0),IR(16668, 15)/* BoundSamplerNV */,IR(0, 0),IR(127, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5401,IR(0, 0),IR(16683, 13)/* BoundImageNV */,IR(0, 0),IR(127, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5599,IR(0, 1),IR(16696, 14)/* SIMTCallINTEL */,IR(0, 0),IR(128, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5602,IR(0, 0),IR(16710, 26)/* ReferencedIndirectlyINTEL */,IR(0, 0),IR(129, 1),IR(95, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5607,IR(11, 1),IR(16736, 13)/* ClobberINTEL */,IR(0, 0),IR(130, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5608,IR(0, 0),IR(16749, 17)/* SideEffectsINTEL */,IR(0, 0),IR(130, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5624,IR(0, 0),IR(16766, 27)/* VectorComputeVariableINTEL */,IR(0, 0),IR(128, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5625,IR(0, 1),IR(16793, 21)/* FuncParamIOKindINTEL */,IR(0, 0),IR(128, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5626,IR(0, 0),IR(16814, 27)/* VectorComputeFunctionINTEL */,IR(0, 0),IR(128, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5627,IR(0, 0),IR(16841, 15)/* StackCallINTEL */,IR(0, 0),IR(128, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5628,IR(0, 1),IR(16856, 26)/* GlobalVariableOffsetINTEL */,IR(0, 0),IR(128, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5634,IR(10, 1),IR(16882, 14)/* CounterBuffer */,IR(56, 1),IR(1, 0),IR(158, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5635,IR(11, 1),IR(16920, 13)/* UserSemantic */,IR(57, 1),IR(1, 0),IR(158, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5636,IR(11, 1),IR(16952, 15)/* UserTypeGOOGLE */,IR(0, 0),IR(1, 0),IR(159, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5822,IR(12, 2),IR(16967, 26)/* FunctionRoundingModeINTEL */,IR(0, 0),IR(131, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5823,IR(14, 2),IR(17024, 24)/* FunctionDenormModeINTEL */,IR(0, 0),IR(131, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5825,IR(0, 0),IR(17048, 14)/* RegisterINTEL */,IR(0, 0),IR(132, 1),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5826,IR(11, 1),IR(17062, 12)/* MemoryINTEL */,IR(0, 0),IR(132, 1),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5827,IR(0, 1),IR(17074, 14)/* NumbanksINTEL */,IR(0, 0),IR(132, 1),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5828,IR(0, 1),IR(17088, 15)/* BankwidthINTEL */,IR(0, 0),IR(132, 1),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5829,IR(0, 1),IR(17103, 22)/* MaxPrivateCopiesINTEL */,IR(0, 0),IR(132, 1),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5830,IR(0, 0),IR(17125, 16)/* SinglepumpINTEL */,IR(0, 0),IR(132, 1),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5831,IR(0, 0),IR(17141, 16)/* DoublepumpINTEL */,IR(0, 0),IR(132, 1),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5832,IR(0, 1),IR(17157, 19)/* MaxReplicatesINTEL */,IR(0, 0),IR(132, 1),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5833,IR(0, 0),IR(17176, 20)/* SimpleDualPortINTEL */,IR(0, 0),IR(132, 1),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5834,IR(16, 2),IR(17196, 11)/* MergeINTEL */,IR(0, 0),IR(132, 1),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5835,IR(18, 1),IR(17249, 14)/* BankBitsINTEL */,IR(0, 0),IR(132, 1),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5836,IR(0, 1),IR(17263, 20)/* ForcePow2DepthINTEL */,IR(0, 0),IR(132, 1),IR(102, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5883,IR(0, 1),IR(17283, 16)/* StridesizeINTEL */,IR(0, 0),IR(132, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5884,IR(0, 1),IR(17299, 14)/* WordsizeINTEL */,IR(0, 0),IR(132, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5885,IR(0, 0),IR(17313, 18)/* TrueDualPortINTEL */,IR(0, 0),IR(132, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5899,IR(0, 0),IR(17331, 19)/* BurstCoalesceINTEL */,IR(0, 0),IR(133, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5900,IR(0, 1),IR(17350, 15)/* CacheSizeINTEL */,IR(0, 0),IR(133, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5901,IR(0, 0),IR(17365, 28)/* DontStaticallyCoalesceINTEL */,IR(0, 0),IR(133, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5902,IR(0, 1),IR(17393, 14)/* PrefetchINTEL */,IR(0, 0),IR(133, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5905,IR(0, 0),IR(17407, 17)/* StallEnableINTEL */,IR(0, 0),IR(106, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5907,IR(0, 0),IR(17424, 25)/* FuseLoopsInFunctionINTEL */,IR(0, 0),IR(134, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5909,IR(1, 2),IR(17449, 19)/* MathOpDSPModeINTEL */,IR(0, 0),IR(135, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5914,IR(10, 1),IR(17468, 16)/* AliasScopeINTEL */,IR(0, 0),IR(136, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5915,IR(10, 1),IR(17484, 13)/* NoAliasINTEL */,IR(0, 0),IR(136, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5917,IR(0, 1),IR(17497, 24)/* InitiationIntervalINTEL */,IR(0, 0),IR(137, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5918,IR(0, 1),IR(17521, 20)/* MaxConcurrencyINTEL */,IR(0, 0),IR(137, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5919,IR(0, 1),IR(17541, 20)/* PipelineEnableINTEL */,IR(0, 0),IR(137, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5921,IR(0, 1),IR(17561, 20)/* BufferLocationINTEL */,IR(0, 0),IR(138, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {5944,IR(0, 1),IR(17581, 19)/* IOPipeStorageINTEL */,IR(0, 0),IR(139, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6080,IR(19, 2),IR(17634, 31)/* FunctionFloatingPointModeINTEL */,IR(0, 0),IR(131, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6085,IR(0, 0),IR(17665, 25)/* SingleElementVectorINTEL */,IR(0, 0),IR(128, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6087,IR(0, 0),IR(17690, 35)/* VectorComputeCallableFunctionINTEL */,IR(0, 0),IR(128, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6140,IR(0, 0),IR(17725, 18)/* MediaBlockIOINTEL */,IR(0, 0),IR(128, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6151,IR(0, 0),IR(17743, 15)/* StallFreeINTEL */,IR(0, 0),IR(140, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6170,IR(21, 1),IR(17789, 26)/* FPMaxErrorDecorationINTEL */,IR(0, 0),IR(141, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6172,IR(0, 1),IR(17815, 25)/* LatencyControlLabelINTEL */,IR(0, 0),IR(142, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6173,IR(22, 3),IR(17840, 30)/* LatencyControlConstraintINTEL */,IR(0, 0),IR(142, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6175,IR(0, 0),IR(17870, 27)/* ConduitKernelArgumentINTEL */,IR(0, 0),IR(143, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6176,IR(0, 0),IR(17897, 31)/* RegisterMapKernelArgumentINTEL */,IR(0, 0),IR(143, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6177,IR(0, 1),IR(17928, 33)/* MMHostInterfaceAddressWidthINTEL */,IR(0, 0),IR(143, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6178,IR(0, 1),IR(17961, 30)/* MMHostInterfaceDataWidthINTEL */,IR(0, 0),IR(143, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6179,IR(0, 1),IR(17991, 28)/* MMHostInterfaceLatencyINTEL */,IR(0, 0),IR(143, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6180,IR(25, 1),IR(18053, 34)/* MMHostInterfaceReadWriteModeINTEL */,IR(0, 0),IR(143, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6181,IR(0, 1),IR(18087, 29)/* MMHostInterfaceMaxBurstINTEL */,IR(0, 0),IR(143, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6182,IR(0, 1),IR(18116, 32)/* MMHostInterfaceWaitRequestINTEL */,IR(0, 0),IR(143, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6183,IR(0, 0),IR(18148, 26)/* StableKernelArgumentINTEL */,IR(0, 0),IR(143, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6188,IR(26, 2),IR(18213, 16)/* HostAccessINTEL */,IR(0, 0),IR(144, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6190,IR(28, 1),IR(18276, 14)/* InitModeINTEL */,IR(0, 0),IR(145, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6191,IR(0, 1),IR(18290, 28)/* ImplementInRegisterMapINTEL */,IR(0, 0),IR(145, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6247,IR(10, 1),IR(18318, 17)/* ConditionalINTEL */,IR(0, 0),IR(111, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6442,IR(29, 2),IR(18371, 22)/* CacheControlLoadINTEL */,IR(0, 0),IR(146, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {6443,IR(31, 2),IR(18430, 23)/* CacheControlStoreINTEL */,IR(0, 0),IR(146, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DECORATION + {0,IR(0, 0),IR(18453, 3)/* 1D */,IR(0, 0),IR(72, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY + {1,IR(0, 0),IR(18456, 3)/* 2D */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY + {2,IR(0, 0),IR(18459, 3)/* 3D */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY + {3,IR(0, 0),IR(18462, 5)/* Cube */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY + {4,IR(0, 0),IR(18467, 5)/* Rect */,IR(0, 0),IR(71, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY + {5,IR(0, 0),IR(18472, 7)/* Buffer */,IR(0, 0),IR(73, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY + {6,IR(0, 0),IR(18479, 12)/* SubpassData */,IR(0, 0),IR(95, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY + {4173,IR(0, 0),IR(18491, 17)/* TileImageDataEXT */,IR(0, 0),IR(147, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_DIMENSIONALITY + {0,IR(0, 1),IR(18508, 12)/* Invocations */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {1,IR(0, 0),IR(18520, 13)/* SpacingEqual */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {2,IR(0, 0),IR(18533, 22)/* SpacingFractionalEven */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {3,IR(0, 0),IR(18555, 21)/* SpacingFractionalOdd */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {4,IR(0, 0),IR(18576, 14)/* VertexOrderCw */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5,IR(0, 0),IR(18590, 15)/* VertexOrderCcw */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {6,IR(0, 0),IR(18605, 19)/* PixelCenterInteger */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {7,IR(0, 0),IR(18624, 16)/* OriginUpperLeft */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {8,IR(0, 0),IR(18640, 16)/* OriginLowerLeft */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {9,IR(0, 0),IR(18656, 19)/* EarlyFragmentTests */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {10,IR(0, 0),IR(18675, 10)/* PointMode */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {11,IR(0, 0),IR(18685, 4)/* Xfb */,IR(0, 0),IR(117, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {12,IR(0, 0),IR(18689, 15)/* DepthReplacing */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {14,IR(0, 0),IR(18704, 13)/* DepthGreater */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {15,IR(0, 0),IR(18717, 10)/* DepthLess */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {16,IR(0, 0),IR(18727, 15)/* DepthUnchanged */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {17,IR(22, 3),IR(18742, 10)/* LocalSize */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {18,IR(22, 3),IR(18752, 14)/* LocalSizeHint */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {19,IR(0, 0),IR(18766, 12)/* InputPoints */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {20,IR(0, 0),IR(18778, 11)/* InputLines */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {21,IR(0, 0),IR(18789, 20)/* InputLinesAdjacency */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {22,IR(0, 0),IR(18809, 10)/* Triangles */,IR(0, 0),IR(12, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {23,IR(0, 0),IR(18819, 24)/* InputTrianglesAdjacency */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {24,IR(0, 0),IR(18843, 6)/* Quads */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {25,IR(0, 0),IR(18849, 9)/* Isolines */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {26,IR(0, 1),IR(18858, 15)/* OutputVertices */,IR(0, 0),IR(148, 4),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {27,IR(0, 0),IR(18873, 13)/* OutputPoints */,IR(0, 0),IR(152, 3),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {28,IR(0, 0),IR(18886, 16)/* OutputLineStrip */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {29,IR(0, 0),IR(18902, 20)/* OutputTriangleStrip */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {30,IR(0, 1),IR(18922, 12)/* VecTypeHint */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {31,IR(0, 0),IR(18934, 15)/* ContractionOff */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {33,IR(0, 0),IR(18949, 12)/* Initializer */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {34,IR(0, 0),IR(18961, 10)/* Finalizer */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {35,IR(0, 1),IR(5394, 13)/* SubgroupSize */,IR(0, 0),IR(155, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {36,IR(0, 1),IR(18971, 22)/* SubgroupsPerWorkgroup */,IR(0, 0),IR(155, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {37,IR(10, 1),IR(18993, 24)/* SubgroupsPerWorkgroupId */,IR(0, 0),IR(155, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,2),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {38,IR(33, 3),IR(19017, 12)/* LocalSizeId */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,2),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {39,IR(33, 3),IR(19029, 16)/* LocalSizeHintId */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,2),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {4169,IR(0, 0),IR(19045, 34)/* NonCoherentColorAttachmentReadEXT */,IR(0, 0),IR(147, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {4170,IR(0, 0),IR(19079, 34)/* NonCoherentDepthAttachmentReadEXT */,IR(0, 0),IR(156, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {4171,IR(0, 0),IR(19113, 36)/* NonCoherentStencilAttachmentReadEXT */,IR(0, 0),IR(157, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {4421,IR(0, 0),IR(19149, 30)/* SubgroupUniformControlFlowKHR */,IR(0, 0),IR(3, 1),IR(160, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {4446,IR(0, 0),IR(19179, 18)/* PostDepthCoverage */,IR(0, 0),IR(158, 1),IR(45, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {4459,IR(0, 1),IR(9593, 15)/* DenormPreserve */,IR(0, 0),IR(159, 1),IR(47, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {4460,IR(0, 1),IR(9608, 18)/* DenormFlushToZero */,IR(0, 0),IR(160, 1),IR(47, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {4461,IR(0, 1),IR(9626, 25)/* SignedZeroInfNanPreserve */,IR(0, 0),IR(161, 1),IR(47, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {4462,IR(0, 1),IR(9651, 16)/* RoundingModeRTE */,IR(0, 0),IR(162, 1),IR(47, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {4463,IR(0, 1),IR(9667, 16)/* RoundingModeRTZ */,IR(0, 0),IR(163, 1),IR(47, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {4489,IR(0, 0),IR(19197, 34)/* NonCoherentTileAttachmentReadQCOM */,IR(0, 0),IR(41, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {4490,IR(22, 3),IR(19231, 20)/* TileShadingRateQCOM */,IR(0, 0),IR(41, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5017,IR(0, 0),IR(19251, 29)/* EarlyAndLateFragmentTestsAMD */,IR(0, 0),IR(3, 1),IR(161, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5027,IR(0, 0),IR(19280, 23)/* StencilRefReplacingEXT */,IR(0, 0),IR(42, 1),IR(11, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5069,IR(0, 0),IR(19303, 15)/* CoalescingAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5070,IR(10, 1),IR(19318, 15)/* IsApiEntryAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5071,IR(10, 1),IR(19333, 21)/* MaxNodeRecursionAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5072,IR(33, 3),IR(19354, 24)/* StaticNumWorkgroupsAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5073,IR(10, 1),IR(6287, 16)/* ShaderIndexAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5077,IR(33, 3),IR(19378, 21)/* MaxNumWorkgroupsAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5079,IR(0, 0),IR(19399, 28)/* StencilRefUnchangedFrontAMD */,IR(0, 0),IR(42, 1),IR(162, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5080,IR(0, 0),IR(19427, 26)/* StencilRefGreaterFrontAMD */,IR(0, 0),IR(42, 1),IR(162, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5081,IR(0, 0),IR(19453, 23)/* StencilRefLessFrontAMD */,IR(0, 0),IR(42, 1),IR(162, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5082,IR(0, 0),IR(19476, 27)/* StencilRefUnchangedBackAMD */,IR(0, 0),IR(42, 1),IR(162, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5083,IR(0, 0),IR(19503, 25)/* StencilRefGreaterBackAMD */,IR(0, 0),IR(42, 1),IR(162, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5084,IR(0, 0),IR(19528, 22)/* StencilRefLessBackAMD */,IR(0, 0),IR(42, 1),IR(162, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5088,IR(0, 0),IR(19550, 19)/* QuadDerivativesKHR */,IR(0, 0),IR(164, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5089,IR(0, 0),IR(19569, 20)/* RequireFullQuadsKHR */,IR(0, 0),IR(164, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5102,IR(36, 2),IR(19589, 20)/* SharesInputWithAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5269,IR(0, 0),IR(19609, 15)/* OutputLinesEXT */,IR(58, 1),IR(124, 2),IR(156, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5270,IR(0, 1),IR(19638, 20)/* OutputPrimitivesEXT */,IR(59, 1),IR(124, 2),IR(156, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5289,IR(0, 0),IR(19677, 24)/* DerivativeGroupQuadsKHR */,IR(60, 1),IR(165, 1),IR(73, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5290,IR(0, 0),IR(19724, 25)/* DerivativeGroupLinearKHR */,IR(61, 1),IR(166, 1),IR(73, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5298,IR(0, 0),IR(19773, 19)/* OutputTrianglesEXT */,IR(62, 1),IR(124, 2),IR(156, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5366,IR(0, 0),IR(19810, 25)/* PixelInterlockOrderedEXT */,IR(0, 0),IR(167, 1),IR(80, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5367,IR(0, 0),IR(19835, 27)/* PixelInterlockUnorderedEXT */,IR(0, 0),IR(167, 1),IR(80, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5368,IR(0, 0),IR(19862, 26)/* SampleInterlockOrderedEXT */,IR(0, 0),IR(168, 1),IR(80, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5369,IR(0, 0),IR(19888, 28)/* SampleInterlockUnorderedEXT */,IR(0, 0),IR(168, 1),IR(80, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5370,IR(0, 0),IR(19916, 31)/* ShadingRateInterlockOrderedEXT */,IR(0, 0),IR(169, 1),IR(80, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5371,IR(0, 0),IR(19947, 33)/* ShadingRateInterlockUnorderedEXT */,IR(0, 0),IR(169, 1),IR(80, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5618,IR(0, 1),IR(19980, 27)/* SharedLocalMemorySizeINTEL */,IR(0, 0),IR(128, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5620,IR(0, 1),IR(20007, 21)/* RoundingModeRTPINTEL */,IR(0, 0),IR(170, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5621,IR(0, 1),IR(20028, 21)/* RoundingModeRTNINTEL */,IR(0, 0),IR(170, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5622,IR(0, 1),IR(20049, 26)/* FloatingPointModeALTINTEL */,IR(0, 0),IR(170, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5623,IR(0, 1),IR(20075, 27)/* FloatingPointModeIEEEINTEL */,IR(0, 0),IR(170, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5893,IR(22, 3),IR(20102, 22)/* MaxWorkgroupSizeINTEL */,IR(0, 0),IR(171, 1),IR(108, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5894,IR(0, 1),IR(20124, 16)/* MaxWorkDimINTEL */,IR(0, 0),IR(171, 1),IR(108, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5895,IR(0, 0),IR(20140, 20)/* NoGlobalOffsetINTEL */,IR(0, 0),IR(171, 1),IR(108, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5896,IR(0, 1),IR(20160, 22)/* NumSIMDWorkitemsINTEL */,IR(0, 0),IR(107, 1),IR(108, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {5903,IR(0, 1),IR(20182, 28)/* SchedulerTargetFmaxMhzINTEL */,IR(0, 0),IR(107, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {6023,IR(0, 0),IR(20210, 24)/* MaximallyReconvergesKHR */,IR(0, 0),IR(3, 1),IR(164, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {6028,IR(36, 2),IR(20234, 18)/* FPFastMathDefault */,IR(0, 0),IR(172, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {6154,IR(0, 1),IR(20252, 24)/* StreamingInterfaceINTEL */,IR(0, 0),IR(107, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {6160,IR(0, 1),IR(20276, 26)/* RegisterMapInterfaceINTEL */,IR(0, 0),IR(173, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {6417,IR(0, 1),IR(20302, 23)/* NamedBarrierCountINTEL */,IR(0, 0),IR(128, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {6461,IR(0, 1),IR(20325, 22)/* MaximumRegistersINTEL */,IR(0, 0),IR(174, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {6462,IR(10, 1),IR(20347, 24)/* MaximumRegistersIdINTEL */,IR(0, 0),IR(174, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {6463,IR(38, 1),IR(20422, 27)/* NamedMaximumRegistersINTEL */,IR(0, 0),IR(174, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODE + {0,IR(0, 0),IR(20449, 7)/* Vertex */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {1,IR(0, 0),IR(20456, 20)/* TessellationControl */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {2,IR(0, 0),IR(20476, 23)/* TessellationEvaluation */,IR(0, 0),IR(24, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {3,IR(0, 0),IR(4875, 9)/* Geometry */,IR(0, 0),IR(69, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {4,IR(0, 0),IR(14627, 9)/* Fragment */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {5,IR(0, 0),IR(20499, 10)/* GLCompute */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {6,IR(0, 0),IR(4642, 7)/* Kernel */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {5267,IR(0, 0),IR(20509, 7)/* TaskNV */,IR(0, 0),IR(50, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {5268,IR(0, 0),IR(20516, 7)/* MeshNV */,IR(0, 0),IR(50, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {5313,IR(0, 0),IR(20523, 17)/* RayGenerationKHR */,IR(63, 1),IR(54, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {5314,IR(0, 0),IR(20556, 16)/* IntersectionKHR */,IR(64, 1),IR(54, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {5315,IR(0, 0),IR(20587, 10)/* AnyHitKHR */,IR(65, 1),IR(54, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {5316,IR(0, 0),IR(20606, 14)/* ClosestHitKHR */,IR(66, 1),IR(54, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {5317,IR(0, 0),IR(20633, 8)/* MissKHR */,IR(67, 1),IR(54, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {5318,IR(0, 0),IR(20648, 12)/* CallableKHR */,IR(68, 1),IR(54, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {5364,IR(0, 0),IR(20671, 8)/* TaskEXT */,IR(0, 0),IR(53, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {5365,IR(0, 0),IR(20679, 8)/* MeshEXT */,IR(0, 0),IR(53, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_EXECUTION_MODEL + {0,IR(0, 0),IR(20687, 9)/* Preserve */,IR(0, 0),IR(131, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPDENORM_MODE + {1,IR(0, 0),IR(20696, 12)/* FlushToZero */,IR(0, 0),IR(131, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPDENORM_MODE + {0,IR(0, 0),IR(20708, 12)/* BFloat16KHR */,IR(0, 0),IR(89, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPENCODING + {4214,IR(0, 0),IR(20720, 14)/* Float8E4M3EXT */,IR(0, 0),IR(121, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPENCODING + {4215,IR(0, 0),IR(20734, 14)/* Float8E5M2EXT */,IR(0, 0),IR(121, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPENCODING + {0,IR(0, 0),IR(20748, 5)/* IEEE */,IR(0, 0),IR(131, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPOPERATION_MODE + {1,IR(0, 0),IR(20753, 4)/* ALT */,IR(0, 0),IR(131, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FPOPERATION_MODE + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {1,IR(0, 0),IR(20757, 7)/* NotNaN */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {2,IR(0, 0),IR(20764, 7)/* NotInf */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {4,IR(0, 0),IR(20771, 4)/* NSZ */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {8,IR(0, 0),IR(20775, 11)/* AllowRecip */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {16,IR(0, 0),IR(20786, 5)/* Fast */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {65536,IR(0, 0),IR(20791, 14)/* AllowContract */,IR(69, 1),IR(175, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {131072,IR(0, 0),IR(20828, 13)/* AllowReassoc */,IR(70, 1),IR(175, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {262144,IR(0, 0),IR(20859, 15)/* AllowTransform */,IR(0, 0),IR(172, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {0,IR(0, 0),IR(20874, 4)/* RTE */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_ROUNDING_MODE + {1,IR(0, 0),IR(20878, 4)/* RTZ */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_ROUNDING_MODE + {2,IR(0, 0),IR(20882, 4)/* RTP */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_ROUNDING_MODE + {3,IR(0, 0),IR(20886, 4)/* RTN */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FP_ROUNDING_MODE + {1,IR(0, 0),IR(20890, 16)/* Vertical2Pixels */,IR(0, 0),IR(38, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE + {2,IR(0, 0),IR(20906, 16)/* Vertical4Pixels */,IR(0, 0),IR(38, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE + {4,IR(0, 0),IR(20922, 18)/* Horizontal2Pixels */,IR(0, 0),IR(38, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE + {8,IR(0, 0),IR(20940, 18)/* Horizontal4Pixels */,IR(0, 0),IR(38, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_CONTROL + {1,IR(0, 0),IR(20958, 7)/* Inline */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_CONTROL + {2,IR(0, 0),IR(20965, 11)/* DontInline */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_CONTROL + {4,IR(0, 0),IR(20976, 5)/* Pure */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_CONTROL + {8,IR(0, 0),IR(20981, 6)/* Const */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_CONTROL + {65536,IR(0, 0),IR(13369, 11)/* OptNoneEXT */,IR(50, 1),IR(177, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_CONTROL + {0,IR(0, 0),IR(20987, 5)/* Zext */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {1,IR(0, 0),IR(20992, 5)/* Sext */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {2,IR(0, 0),IR(20997, 6)/* ByVal */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {3,IR(0, 0),IR(21003, 5)/* Sret */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {4,IR(0, 0),IR(21008, 8)/* NoAlias */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {5,IR(0, 0),IR(21016, 10)/* NoCapture */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {6,IR(0, 0),IR(21026, 8)/* NoWrite */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {7,IR(0, 0),IR(21034, 12)/* NoReadWrite */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {5940,IR(0, 0),IR(21046, 20)/* RuntimeAlignedINTEL */,IR(0, 0),IR(178, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {0,IR(0, 0),IR(21066, 7)/* Reduce */,IR(0, 0),IR(179, 3),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION + {1,IR(0, 0),IR(21073, 14)/* InclusiveScan */,IR(0, 0),IR(179, 3),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION + {2,IR(0, 0),IR(21087, 14)/* ExclusiveScan */,IR(0, 0),IR(179, 3),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION + {3,IR(0, 0),IR(21101, 16)/* ClusteredReduce */,IR(0, 0),IR(182, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION + {6,IR(0, 0),IR(21117, 20)/* PartitionedReduceNV */,IR(0, 0),IR(183, 1),IR(75, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION + {7,IR(0, 0),IR(21137, 27)/* PartitionedInclusiveScanNV */,IR(0, 0),IR(183, 1),IR(75, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION + {8,IR(0, 0),IR(21164, 27)/* PartitionedExclusiveScanNV */,IR(0, 0),IR(183, 1),IR(75, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_GROUP_OPERATION + {0,IR(0, 0),IR(21191, 10)/* NoneINTEL */,IR(0, 0),IR(144, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER + {1,IR(0, 0),IR(21201, 10)/* ReadINTEL */,IR(0, 0),IR(144, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER + {2,IR(0, 0),IR(21211, 11)/* WriteINTEL */,IR(0, 0),IR(144, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER + {3,IR(0, 0),IR(21222, 15)/* ReadWriteINTEL */,IR(0, 0),IR(144, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {1,IR(10, 1),IR(21237, 5)/* Bias */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {2,IR(10, 1),IR(21242, 4)/* Lod */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {4,IR(36, 2),IR(21246, 5)/* Grad */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {8,IR(10, 1),IR(21251, 12)/* ConstOffset */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {16,IR(10, 1),IR(15630, 7)/* Offset */,IR(0, 0),IR(184, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {32,IR(10, 1),IR(21263, 13)/* ConstOffsets */,IR(0, 0),IR(184, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {64,IR(10, 1),IR(15427, 7)/* Sample */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {128,IR(10, 1),IR(8426, 7)/* MinLod */,IR(0, 0),IR(185, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {256,IR(4, 1),IR(21276, 19)/* MakeTexelAvailable */,IR(71, 1),IR(186, 1),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {512,IR(4, 1),IR(21317, 17)/* MakeTexelVisible */,IR(72, 1),IR(186, 1),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {1024,IR(0, 0),IR(21354, 16)/* NonPrivateTexel */,IR(73, 1),IR(186, 1),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {2048,IR(0, 0),IR(21389, 14)/* VolatileTexel */,IR(74, 1),IR(186, 1),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {4096,IR(0, 0),IR(21420, 11)/* SignExtend */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {8192,IR(0, 0),IR(21431, 11)/* ZeroExtend */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {16384,IR(0, 0),IR(21442, 12)/* Nontemporal */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {65536,IR(10, 1),IR(21454, 8)/* Offsets */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE + {0,IR(0, 0),IR(21462, 10)/* SnormInt8 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {1,IR(0, 0),IR(21472, 11)/* SnormInt16 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {2,IR(0, 0),IR(21483, 10)/* UnormInt8 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {3,IR(0, 0),IR(21493, 11)/* UnormInt16 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {4,IR(0, 0),IR(21504, 14)/* UnormShort565 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {5,IR(0, 0),IR(21518, 14)/* UnormShort555 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {6,IR(0, 0),IR(21532, 15)/* UnormInt101010 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {7,IR(0, 0),IR(21547, 11)/* SignedInt8 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {8,IR(0, 0),IR(21558, 12)/* SignedInt16 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {9,IR(0, 0),IR(21570, 12)/* SignedInt32 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {10,IR(0, 0),IR(21582, 13)/* UnsignedInt8 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {11,IR(0, 0),IR(21595, 14)/* UnsignedInt16 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {12,IR(0, 0),IR(21609, 14)/* UnsignedInt32 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {13,IR(0, 0),IR(21623, 10)/* HalfFloat */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {14,IR(0, 0),IR(14120, 6)/* Float */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {15,IR(0, 0),IR(21633, 11)/* UnormInt24 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {16,IR(0, 0),IR(21644, 17)/* UnormInt101010_2 */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {17,IR(0, 0),IR(21661, 16)/* UnormInt10X6EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {19,IR(0, 0),IR(21677, 20)/* UnsignedIntRaw10EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {20,IR(0, 0),IR(21697, 20)/* UnsignedIntRaw12EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {21,IR(0, 0),IR(21717, 20)/* UnormInt2_101010EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {22,IR(0, 0),IR(21737, 19)/* UnsignedInt10X6EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {23,IR(0, 0),IR(21756, 19)/* UnsignedInt12X4EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {24,IR(0, 0),IR(21775, 19)/* UnsignedInt14X2EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {25,IR(0, 0),IR(21794, 16)/* UnormInt12X4EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {26,IR(0, 0),IR(21810, 16)/* UnormInt14X2EXT */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {0,IR(0, 0),IR(21826, 2)/* R */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {1,IR(0, 0),IR(21828, 2)/* A */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {2,IR(0, 0),IR(21830, 3)/* RG */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {3,IR(0, 0),IR(21833, 3)/* RA */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {4,IR(0, 0),IR(21836, 4)/* RGB */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {5,IR(0, 0),IR(21840, 5)/* RGBA */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {6,IR(0, 0),IR(21845, 5)/* BGRA */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {7,IR(0, 0),IR(21850, 5)/* ARGB */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {8,IR(0, 0),IR(21855, 10)/* Intensity */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {9,IR(0, 0),IR(21865, 10)/* Luminance */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {10,IR(0, 0),IR(21875, 3)/* Rx */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {11,IR(0, 0),IR(21878, 4)/* RGx */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {12,IR(0, 0),IR(21882, 5)/* RGBx */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {13,IR(0, 0),IR(21887, 6)/* Depth */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {14,IR(0, 0),IR(21893, 13)/* DepthStencil */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {15,IR(0, 0),IR(21906, 5)/* sRGB */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {16,IR(0, 0),IR(21911, 6)/* sRGBx */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {17,IR(0, 0),IR(21917, 6)/* sRGBA */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {18,IR(0, 0),IR(21923, 6)/* sBGRA */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {19,IR(0, 0),IR(21929, 5)/* ABGR */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {0,IR(0, 0),IR(21934, 27)/* InitOnDeviceReprogramINTEL */,IR(0, 0),IR(145, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER + {1,IR(0, 0),IR(21961, 23)/* InitOnDeviceResetINTEL */,IR(0, 0),IR(145, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER + {0,IR(0, 0),IR(21984, 7)/* NoWait */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS + {1,IR(0, 0),IR(21991, 11)/* WaitKernel */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS + {2,IR(0, 0),IR(22002, 14)/* WaitWorkGroup */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO + {1,IR(0, 0),IR(22016, 12)/* CmdExecTime */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_PROPERTY_FLAGS + {1,IR(0, 0),IR(22028, 13)/* MayUsePrintf */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_KERNEL_PROPERTY_FLAGS + {0,IR(0, 0),IR(22041, 7)/* Export */,IR(0, 0),IR(120, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_LINKAGE_TYPE + {1,IR(0, 0),IR(22048, 7)/* Import */,IR(0, 0),IR(120, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_LINKAGE_TYPE + {2,IR(0, 0),IR(22055, 12)/* LinkOnceODR */,IR(0, 0),IR(120, 1),IR(165, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LINKAGE_TYPE + {0,IR(0, 0),IR(22067, 14)/* UncachedINTEL */,IR(0, 0),IR(146, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL + {1,IR(0, 0),IR(22081, 12)/* CachedINTEL */,IR(0, 0),IR(146, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL + {2,IR(0, 0),IR(22093, 15)/* StreamingINTEL */,IR(0, 0),IR(146, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL + {3,IR(0, 0),IR(22108, 25)/* InvalidateAfterReadINTEL */,IR(0, 0),IR(146, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL + {4,IR(0, 0),IR(22133, 17)/* ConstCachedINTEL */,IR(0, 0),IR(146, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {1,IR(0, 0),IR(22150, 7)/* Unroll */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {2,IR(0, 0),IR(22157, 11)/* DontUnroll */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {4,IR(0, 0),IR(22168, 19)/* DependencyInfinite */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {8,IR(0, 1),IR(22187, 17)/* DependencyLength */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,1),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {16,IR(0, 1),IR(22204, 14)/* MinIterations */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {32,IR(0, 1),IR(22218, 14)/* MaxIterations */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {64,IR(0, 1),IR(22232, 18)/* IterationMultiple */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {128,IR(0, 1),IR(22250, 10)/* PeelCount */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {256,IR(0, 1),IR(22260, 13)/* PartialCount */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {65536,IR(0, 1),IR(17497, 24)/* InitiationIntervalINTEL */,IR(0, 0),IR(187, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {131072,IR(0, 1),IR(17521, 20)/* MaxConcurrencyINTEL */,IR(0, 0),IR(187, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {262144,IR(0, 1),IR(22273, 21)/* DependencyArrayINTEL */,IR(0, 0),IR(187, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {524288,IR(0, 1),IR(17541, 20)/* PipelineEnableINTEL */,IR(0, 0),IR(187, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {1048576,IR(0, 1),IR(22294, 18)/* LoopCoalesceINTEL */,IR(0, 0),IR(187, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {2097152,IR(0, 1),IR(22312, 21)/* MaxInterleavingINTEL */,IR(0, 0),IR(187, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {4194304,IR(0, 1),IR(22333, 26)/* SpeculatedIterationsINTEL */,IR(0, 0),IR(187, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {8388608,IR(0, 0),IR(22359, 14)/* NoFusionINTEL */,IR(0, 0),IR(187, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {16777216,IR(0, 1),IR(22373, 15)/* LoopCountINTEL */,IR(0, 0),IR(187, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {33554432,IR(0, 1),IR(22388, 26)/* MaxReinvocationDelayINTEL */,IR(0, 0),IR(187, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_LOOP_CONTROL + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {1,IR(0, 0),IR(22414, 29)/* MatrixASignedComponentsINTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {2,IR(0, 0),IR(22443, 29)/* MatrixBSignedComponentsINTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {4,IR(0, 0),IR(22472, 21)/* MatrixCBFloat16INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {8,IR(0, 0),IR(22493, 26)/* MatrixResultBFloat16INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {16,IR(0, 0),IR(22519, 23)/* MatrixAPackedInt8INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {32,IR(0, 0),IR(22542, 23)/* MatrixBPackedInt8INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {64,IR(0, 0),IR(22565, 23)/* MatrixAPackedInt4INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {128,IR(0, 0),IR(22588, 23)/* MatrixBPackedInt4INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {256,IR(0, 0),IR(22611, 17)/* MatrixATF32INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {512,IR(0, 0),IR(22628, 17)/* MatrixBTF32INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {1024,IR(0, 0),IR(22645, 26)/* MatrixAPackedFloat16INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {2048,IR(0, 0),IR(22671, 26)/* MatrixBPackedFloat16INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {4096,IR(0, 0),IR(22697, 27)/* MatrixAPackedBFloat16INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {8192,IR(0, 0),IR(22724, 27)/* MatrixBPackedBFloat16INTEL */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS + {1,IR(0, 0),IR(15461, 9)/* Volatile */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS + {2,IR(0, 1),IR(22751, 8)/* Aligned */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS + {4,IR(0, 0),IR(21442, 12)/* Nontemporal */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS + {8,IR(4, 1),IR(22759, 21)/* MakePointerAvailable */,IR(75, 1),IR(186, 1),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS + {16,IR(4, 1),IR(22804, 19)/* MakePointerVisible */,IR(76, 1),IR(186, 1),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS + {32,IR(0, 0),IR(22845, 18)/* NonPrivatePointer */,IR(77, 1),IR(186, 1),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS + {65536,IR(10, 1),IR(22884, 20)/* AliasScopeINTELMask */,IR(0, 0),IR(136, 1),IR(113, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS + {131072,IR(10, 1),IR(22904, 17)/* NoAliasINTELMask */,IR(0, 0),IR(136, 1),IR(113, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_ACCESS + {0,IR(0, 0),IR(22921, 7)/* Simple */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_MODEL + {1,IR(0, 0),IR(22928, 8)/* GLSL450 */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_MODEL + {2,IR(0, 0),IR(22936, 7)/* OpenCL */,IR(0, 0),IR(0, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_MODEL + {3,IR(0, 0),IR(22943, 7)/* Vulkan */,IR(78, 1),IR(186, 1),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_MODEL + {0,IR(0, 0),IR(22960, 8)/* Relaxed */,IR(79, 1),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {2,IR(0, 0),IR(22968, 8)/* Acquire */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {4,IR(0, 0),IR(22976, 8)/* Release */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {8,IR(0, 0),IR(22984, 15)/* AcquireRelease */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {16,IR(0, 0),IR(22999, 23)/* SequentiallyConsistent */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {64,IR(0, 0),IR(23022, 14)/* UniformMemory */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {128,IR(0, 0),IR(23036, 15)/* SubgroupMemory */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {256,IR(0, 0),IR(23051, 16)/* WorkgroupMemory */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {512,IR(0, 0),IR(23067, 21)/* CrossWorkgroupMemory */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {1024,IR(0, 0),IR(23088, 20)/* AtomicCounterMemory */,IR(0, 0),IR(82, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {2048,IR(0, 0),IR(23108, 12)/* ImageMemory */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {4096,IR(0, 0),IR(23120, 13)/* OutputMemory */,IR(80, 1),IR(186, 1),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {8192,IR(0, 0),IR(23149, 14)/* MakeAvailable */,IR(81, 1),IR(186, 1),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {16384,IR(0, 0),IR(23180, 12)/* MakeVisible */,IR(82, 1),IR(186, 1),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {32768,IR(0, 0),IR(15461, 9)/* Volatile */,IR(0, 0),IR(186, 1),IR(78, 1),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {0,IR(0, 0),IR(23207, 10)/* AutoINTEL */,IR(0, 0),IR(174, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS + {0,IR(0, 0),IR(23217, 5)/* WRAP */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_OVERFLOW_MODES + {1,IR(0, 0),IR(23222, 4)/* SAT */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_OVERFLOW_MODES + {2,IR(0, 0),IR(23226, 9)/* SAT_ZERO */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_OVERFLOW_MODES + {3,IR(0, 0),IR(23235, 8)/* SAT_SYM */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_OVERFLOW_MODES + {0,IR(0, 0),IR(23243, 25)/* PackedVectorFormat4x8Bit */,IR(83, 1),IR(1, 0),IR(122, 1),SPV_SPIRV_VERSION_WORD(1,6),0xffffffffu}, // SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT + {0,IR(0, 0),IR(23296, 4)/* TRN */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES + {1,IR(0, 0),IR(23300, 9)/* TRN_ZERO */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES + {2,IR(0, 0),IR(23309, 4)/* RND */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES + {3,IR(0, 0),IR(23313, 9)/* RND_ZERO */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES + {4,IR(0, 0),IR(23322, 8)/* RND_INF */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES + {5,IR(0, 0),IR(23330, 12)/* RND_MIN_INF */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES + {6,IR(0, 0),IR(23342, 9)/* RND_CONV */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES + {7,IR(0, 0),IR(23351, 13)/* RND_CONV_ODD */,IR(0, 0),IR(188, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_QUANTIZATION_MODES + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS + {1,IR(0, 0),IR(23364, 25)/* RobustnessPerComponentNV */,IR(0, 0),IR(189, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS + {2,IR(0, 0),IR(23389, 23)/* RobustnessPerElementNV */,IR(0, 0),IR(189, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS + {0,IR(0, 0),IR(14975, 8)/* NoneKHR */,IR(0, 0),IR(84, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS + {1,IR(0, 0),IR(23412, 10)/* OpaqueKHR */,IR(0, 0),IR(84, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS + {2,IR(0, 0),IR(23422, 12)/* NoOpaqueKHR */,IR(0, 0),IR(84, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS + {4,IR(0, 0),IR(23434, 23)/* TerminateOnFirstHitKHR */,IR(0, 0),IR(84, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS + {8,IR(0, 0),IR(23457, 24)/* SkipClosestHitShaderKHR */,IR(0, 0),IR(84, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS + {16,IR(0, 0),IR(23481, 27)/* CullBackFacingTrianglesKHR */,IR(0, 0),IR(84, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS + {32,IR(0, 0),IR(23508, 28)/* CullFrontFacingTrianglesKHR */,IR(0, 0),IR(84, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS + {64,IR(0, 0),IR(23536, 14)/* CullOpaqueKHR */,IR(0, 0),IR(84, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS + {128,IR(0, 0),IR(23550, 16)/* CullNoOpaqueKHR */,IR(0, 0),IR(84, 2),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS + {256,IR(0, 0),IR(23566, 17)/* SkipTrianglesKHR */,IR(84, 1),IR(190, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS + {512,IR(0, 0),IR(23607, 13)/* SkipAABBsKHR */,IR(0, 0),IR(190, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS + {1024,IR(0, 0),IR(23620, 30)/* ForceOpacityMicromap2StateEXT */,IR(0, 0),IR(191, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_FLAGS + {0,IR(0, 0),IR(23650, 41)/* RayQueryCandidateIntersectionTriangleKHR */,IR(0, 0),IR(192, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE + {1,IR(0, 0),IR(23691, 37)/* RayQueryCandidateIntersectionAABBKHR */,IR(0, 0),IR(192, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE + {0,IR(0, 0),IR(23728, 37)/* RayQueryCommittedIntersectionNoneKHR */,IR(0, 0),IR(192, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE + {1,IR(0, 0),IR(23765, 41)/* RayQueryCommittedIntersectionTriangleKHR */,IR(0, 0),IR(192, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE + {2,IR(0, 0),IR(23806, 42)/* RayQueryCommittedIntersectionGeneratedKHR */,IR(0, 0),IR(192, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE + {0,IR(0, 0),IR(23848, 33)/* RayQueryCandidateIntersectionKHR */,IR(0, 0),IR(192, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION + {1,IR(0, 0),IR(23881, 33)/* RayQueryCommittedIntersectionKHR */,IR(0, 0),IR(192, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE + {1,IR(0, 0),IR(23914, 12)/* ClampToEdge */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE + {2,IR(0, 0),IR(23926, 6)/* Clamp */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE + {3,IR(0, 0),IR(23932, 7)/* Repeat */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE + {4,IR(0, 0),IR(23939, 15)/* RepeatMirrored */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE + {0,IR(0, 0),IR(23954, 8)/* Nearest */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE + {1,IR(0, 0),IR(23962, 7)/* Linear */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE + {0,IR(0, 0),IR(23969, 8)/* Unknown */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {1,IR(0, 0),IR(23977, 8)/* Rgba32f */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {2,IR(0, 0),IR(23985, 8)/* Rgba16f */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {3,IR(0, 0),IR(23993, 5)/* R32f */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {4,IR(0, 0),IR(23998, 6)/* Rgba8 */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {5,IR(0, 0),IR(24004, 11)/* Rgba8Snorm */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {6,IR(0, 0),IR(24015, 6)/* Rg32f */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {7,IR(0, 0),IR(24021, 6)/* Rg16f */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {8,IR(0, 0),IR(24027, 13)/* R11fG11fB10f */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {9,IR(0, 0),IR(24040, 5)/* R16f */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {10,IR(0, 0),IR(24045, 7)/* Rgba16 */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {11,IR(0, 0),IR(24052, 8)/* Rgb10A2 */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {12,IR(0, 0),IR(24060, 5)/* Rg16 */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {13,IR(0, 0),IR(24065, 4)/* Rg8 */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {14,IR(0, 0),IR(24069, 4)/* R16 */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {15,IR(0, 0),IR(24073, 3)/* R8 */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {16,IR(0, 0),IR(24076, 12)/* Rgba16Snorm */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {17,IR(0, 0),IR(24088, 10)/* Rg16Snorm */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {18,IR(0, 0),IR(24098, 9)/* Rg8Snorm */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {19,IR(0, 0),IR(24107, 9)/* R16Snorm */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {20,IR(0, 0),IR(24116, 8)/* R8Snorm */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {21,IR(0, 0),IR(24124, 8)/* Rgba32i */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {22,IR(0, 0),IR(24132, 8)/* Rgba16i */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {23,IR(0, 0),IR(24140, 7)/* Rgba8i */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {24,IR(0, 0),IR(24147, 5)/* R32i */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {25,IR(0, 0),IR(24152, 6)/* Rg32i */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {26,IR(0, 0),IR(24158, 6)/* Rg16i */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {27,IR(0, 0),IR(24164, 5)/* Rg8i */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {28,IR(0, 0),IR(24169, 5)/* R16i */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {29,IR(0, 0),IR(24174, 4)/* R8i */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {30,IR(0, 0),IR(24178, 9)/* Rgba32ui */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {31,IR(0, 0),IR(24187, 9)/* Rgba16ui */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {32,IR(0, 0),IR(24196, 8)/* Rgba8ui */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {33,IR(0, 0),IR(24204, 6)/* R32ui */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {34,IR(0, 0),IR(24210, 10)/* Rgb10a2ui */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {35,IR(0, 0),IR(24220, 7)/* Rg32ui */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {36,IR(0, 0),IR(24227, 7)/* Rg16ui */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {37,IR(0, 0),IR(24234, 6)/* Rg8ui */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {38,IR(0, 0),IR(24240, 6)/* R16ui */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {39,IR(0, 0),IR(24246, 5)/* R8ui */,IR(0, 0),IR(193, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {40,IR(0, 0),IR(24251, 6)/* R64ui */,IR(0, 0),IR(194, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {41,IR(0, 0),IR(24257, 5)/* R64i */,IR(0, 0),IR(194, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {0,IR(0, 0),IR(24262, 12)/* CrossDevice */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID + {1,IR(0, 0),IR(24274, 7)/* Device */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID + {2,IR(0, 0),IR(24281, 10)/* Workgroup */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID + {3,IR(0, 0),IR(24291, 9)/* Subgroup */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID + {4,IR(0, 0),IR(24300, 11)/* Invocation */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID + {5,IR(0, 0),IR(24311, 12)/* QueueFamily */,IR(85, 1),IR(186, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID + {6,IR(0, 0),IR(24338, 14)/* ShaderCallKHR */,IR(0, 0),IR(60, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_SCOPE_ID + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SELECTION_CONTROL + {1,IR(0, 0),IR(24352, 8)/* Flatten */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SELECTION_CONTROL + {2,IR(0, 0),IR(24360, 12)/* DontFlatten */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SELECTION_CONTROL + {1,IR(0, 0),IR(24372, 29)/* IdentifierPossibleDuplicates */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_BUILD_IDENTIFIER_FLAGS + {0,IR(0, 0),IR(14092, 12)/* Unspecified */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {1,IR(0, 0),IR(14104, 8)/* Address */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {2,IR(0, 0),IR(14112, 8)/* Boolean */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {3,IR(0, 0),IR(14120, 6)/* Float */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {4,IR(0, 0),IR(14126, 7)/* Signed */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {5,IR(0, 0),IR(14133, 11)/* SignedChar */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {6,IR(0, 0),IR(14144, 9)/* Unsigned */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {7,IR(0, 0),IR(14153, 13)/* UnsignedChar */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {0,IR(0, 0),IR(14166, 6)/* Class */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE + {1,IR(0, 0),IR(14172, 10)/* Structure */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE + {2,IR(0, 0),IR(14182, 6)/* Union */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE + {0,IR(0, 0),IR(14188, 15)/* ImportedModule */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_IMPORTED_ENTITY + {1,IR(0, 0),IR(14203, 20)/* ImportedDeclaration */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_IMPORTED_ENTITY + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {1,IR(0, 0),IR(14228, 16)/* FlagIsProtected */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {2,IR(0, 0),IR(14244, 14)/* FlagIsPrivate */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {3,IR(0, 0),IR(14258, 13)/* FlagIsPublic */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {4,IR(0, 0),IR(14271, 12)/* FlagIsLocal */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {8,IR(0, 0),IR(14283, 17)/* FlagIsDefinition */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {16,IR(0, 0),IR(14300, 12)/* FlagFwdDecl */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {32,IR(0, 0),IR(14312, 15)/* FlagArtificial */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {64,IR(0, 0),IR(14327, 13)/* FlagExplicit */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {128,IR(0, 0),IR(14340, 15)/* FlagPrototyped */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {256,IR(0, 0),IR(14355, 18)/* FlagObjectPointer */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {512,IR(0, 0),IR(14373, 17)/* FlagStaticMember */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {1024,IR(0, 0),IR(14390, 21)/* FlagIndirectVariable */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {2048,IR(0, 0),IR(14411, 20)/* FlagLValueReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {4096,IR(0, 0),IR(14431, 20)/* FlagRValueReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {8192,IR(0, 0),IR(14451, 16)/* FlagIsOptimized */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {16384,IR(0, 0),IR(14467, 16)/* FlagIsEnumClass */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {32768,IR(0, 0),IR(14483, 20)/* FlagTypePassByValue */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {65536,IR(0, 0),IR(14503, 24)/* FlagTypePassByReference */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {131072,IR(0, 0),IR(24401, 26)/* FlagUnknownPhysicalLayout */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {0,IR(0, 0),IR(14527, 6)/* Deref */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {1,IR(0, 0),IR(14533, 5)/* Plus */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {2,IR(0, 0),IR(14538, 6)/* Minus */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {3,IR(10, 1),IR(14577, 11)/* PlusUconst */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {4,IR(36, 2),IR(14588, 9)/* BitPiece */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {5,IR(0, 0),IR(14597, 5)/* Swap */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {6,IR(0, 0),IR(14602, 7)/* Xderef */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {7,IR(0, 0),IR(14609, 11)/* StackValue */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {8,IR(10, 1),IR(14620, 7)/* Constu */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {9,IR(36, 2),IR(14627, 9)/* Fragment */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {0,IR(0, 0),IR(14636, 10)/* ConstType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER + {1,IR(0, 0),IR(14646, 13)/* VolatileType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER + {2,IR(0, 0),IR(14659, 13)/* RestrictType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER + {3,IR(0, 0),IR(14672, 11)/* AtomicType */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1, 0),0xffffffffu}, // SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER + {0,IR(0, 0),IR(23969, 8)/* Unknown */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {1,IR(0, 0),IR(24427, 5)/* ESSL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {2,IR(0, 0),IR(24432, 5)/* GLSL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {3,IR(0, 0),IR(24437, 9)/* OpenCL_C */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {4,IR(0, 0),IR(24446, 11)/* OpenCL_CPP */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {5,IR(0, 0),IR(24457, 5)/* HLSL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {6,IR(0, 0),IR(24462, 15)/* CPP_for_OpenCL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {7,IR(0, 0),IR(24477, 5)/* SYCL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {8,IR(0, 0),IR(24482, 7)/* HERO_C */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {9,IR(0, 0),IR(24489, 5)/* NZSL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {10,IR(0, 0),IR(24494, 5)/* WGSL */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {11,IR(0, 0),IR(24499, 6)/* Slang */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {12,IR(0, 0),IR(24505, 4)/* Zig */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {13,IR(0, 0),IR(24509, 5)/* Rust */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {0,IR(0, 0),IR(24514, 16)/* UniformConstant */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {1,IR(0, 0),IR(24530, 6)/* Input */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {2,IR(0, 0),IR(15512, 8)/* Uniform */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {3,IR(0, 0),IR(24536, 7)/* Output */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {4,IR(0, 0),IR(24281, 10)/* Workgroup */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5,IR(0, 0),IR(24543, 15)/* CrossWorkgroup */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {6,IR(0, 0),IR(24558, 8)/* Private */,IR(0, 0),IR(195, 2),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {7,IR(0, 0),IR(24566, 9)/* Function */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {8,IR(0, 0),IR(24575, 8)/* Generic */,IR(0, 0),IR(197, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {9,IR(0, 0),IR(24583, 13)/* PushConstant */,IR(0, 0),IR(3, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {10,IR(0, 0),IR(24596, 14)/* AtomicCounter */,IR(0, 0),IR(82, 1),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {11,IR(0, 0),IR(24610, 6)/* Image */,IR(0, 0),IR(1, 0),IR(0, 0),SPV_SPIRV_VERSION_WORD(1,0),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {12,IR(0, 0),IR(24616, 14)/* StorageBuffer */,IR(0, 0),IR(3, 1),IR(166, 2),SPV_SPIRV_VERSION_WORD(1,3),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {4172,IR(0, 0),IR(24630, 13)/* TileImageEXT */,IR(0, 0),IR(147, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {4491,IR(0, 0),IR(24643, 19)/* TileAttachmentQCOM */,IR(0, 0),IR(41, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5068,IR(0, 0),IR(24662, 16)/* NodePayloadAMDX */,IR(0, 0),IR(43, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5328,IR(0, 0),IR(24678, 16)/* CallableDataKHR */,IR(86, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5329,IR(0, 0),IR(24709, 24)/* IncomingCallableDataKHR */,IR(87, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5338,IR(0, 0),IR(24756, 14)/* RayPayloadKHR */,IR(88, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5339,IR(0, 0),IR(24783, 16)/* HitAttributeKHR */,IR(89, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5342,IR(0, 0),IR(24814, 22)/* IncomingRayPayloadKHR */,IR(90, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5343,IR(0, 0),IR(24857, 22)/* ShaderRecordBufferKHR */,IR(91, 1),IR(54, 2),IR(24, 2),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5349,IR(0, 0),IR(24900, 22)/* PhysicalStorageBuffer */,IR(92, 1),IR(2, 1),IR(0, 2),SPV_SPIRV_VERSION_WORD(1,5),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5385,IR(0, 0),IR(24947, 21)/* HitObjectAttributeNV */,IR(0, 0),IR(126, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5402,IR(0, 0),IR(24968, 24)/* TaskPayloadWorkgroupEXT */,IR(0, 0),IR(53, 1),IR(23, 1),SPV_SPIRV_VERSION_WORD(1,4),0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5605,IR(0, 0),IR(24992, 17)/* CodeSectionINTEL */,IR(0, 0),IR(198, 1),IR(95, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5936,IR(0, 0),IR(25009, 16)/* DeviceOnlyINTEL */,IR(0, 0),IR(199, 1),IR(117, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {5937,IR(0, 0),IR(25025, 14)/* HostOnlyINTEL */,IR(0, 0),IR(199, 1),IR(117, 1),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORAGE_CLASS + {0,IR(0, 0),IR(22067, 14)/* UncachedINTEL */,IR(0, 0),IR(146, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORE_CACHE_CONTROL + {1,IR(0, 0),IR(25039, 18)/* WriteThroughINTEL */,IR(0, 0),IR(146, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORE_CACHE_CONTROL + {2,IR(0, 0),IR(25057, 15)/* WriteBackINTEL */,IR(0, 0),IR(146, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORE_CACHE_CONTROL + {3,IR(0, 0),IR(22093, 15)/* StreamingINTEL */,IR(0, 0),IR(146, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_STORE_CACHE_CONTROL + {0,IR(0, 0),IR(14223, 5)/* None */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS + {1,IR(10, 1),IR(25072, 11)/* TensorView */,IR(0, 0),IR(200, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS + {2,IR(10, 1),IR(25083, 11)/* DecodeFunc */,IR(0, 0),IR(201, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS + {0,IR(0, 0),IR(25094, 10)/* Undefined */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE + {1,IR(0, 0),IR(15470, 9)/* Constant */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE + {2,IR(0, 0),IR(23914, 12)/* ClampToEdge */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE + {3,IR(0, 0),IR(23932, 7)/* Repeat */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE + {4,IR(0, 0),IR(23939, 15)/* RepeatMirrored */,IR(0, 0),IR(1, 0),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE + {0,IR(0, 0),IR(25104, 8)/* NoneARM */,IR(0, 0),IR(202, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_OPERANDS + {1,IR(0, 0),IR(25112, 15)/* NontemporalARM */,IR(0, 0),IR(202, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_OPERANDS + {2,IR(10, 1),IR(25127, 20)/* OutOfBoundsValueARM */,IR(0, 0),IR(202, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_OPERANDS + {4,IR(10, 1),IR(25147, 24)/* MakeElementAvailableARM */,IR(0, 0),IR(202, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_OPERANDS + {8,IR(10, 1),IR(25171, 22)/* MakeElementVisibleARM */,IR(0, 0),IR(202, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_OPERANDS + {16,IR(0, 0),IR(25193, 21)/* NonPrivateElementARM */,IR(0, 0),IR(202, 1),IR(0, 0),0xffffffffu,0xffffffffu}, // SPV_OPERAND_TYPE_TENSOR_OPERANDS }}; // Maps an operand kind to possible operands for that kind. @@ -1532,88 +1547,89 @@ IndexRange OperandByValueRangeForKind(spv_operand_type_t type) { case SPV_OPERAND_TYPE_ACCESS_QUALIFIER: return IR(0, 3); case SPV_OPERAND_TYPE_ADDRESSING_MODEL: return IR(3, 4); case SPV_OPERAND_TYPE_BUILT_IN: return IR(7, 126); - case SPV_OPERAND_TYPE_CAPABILITY: return IR(133, 269); - case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return IR(402, 8); - case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE: return IR(410, 3); - case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY: return IR(413, 2); - case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS: return IR(415, 19); - case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION: return IR(434, 10); - case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER: return IR(444, 4); - case SPV_OPERAND_TYPE_COMPONENT_TYPE: return IR(448, 15); - case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT: return IR(463, 4); - case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS: return IR(467, 6); - case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE: return IR(473, 3); - case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE: return IR(476, 3); - case SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT: return IR(479, 4); - case SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return IR(483, 8); - case SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE: return IR(491, 3); - case SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS: return IR(494, 16); - case SPV_OPERAND_TYPE_DEBUG_OPERATION: return IR(510, 9); - case SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER: return IR(519, 3); - case SPV_OPERAND_TYPE_DECORATION: return IR(522, 143); - case SPV_OPERAND_TYPE_DIMENSIONALITY: return IR(665, 8); - case SPV_OPERAND_TYPE_EXECUTION_MODE: return IR(673, 96); - case SPV_OPERAND_TYPE_EXECUTION_MODEL: return IR(769, 17); - case SPV_OPERAND_TYPE_FPDENORM_MODE: return IR(786, 2); - case SPV_OPERAND_TYPE_FPENCODING: return IR(788, 3); - case SPV_OPERAND_TYPE_FPOPERATION_MODE: return IR(791, 2); - case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE: return IR(793, 9); - case SPV_OPERAND_TYPE_FP_ROUNDING_MODE: return IR(802, 4); - case SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE: return IR(806, 4); - case SPV_OPERAND_TYPE_FUNCTION_CONTROL: return IR(810, 6); - case SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE: return IR(816, 9); - case SPV_OPERAND_TYPE_GROUP_OPERATION: return IR(825, 7); - case SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER: return IR(832, 4); - case SPV_OPERAND_TYPE_IMAGE: return IR(836, 17); - case SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE: return IR(853, 26); - case SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER: return IR(879, 20); - case SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER: return IR(899, 2); - case SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS: return IR(901, 3); - case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO: return IR(904, 2); - case SPV_OPERAND_TYPE_KERNEL_PROPERTY_FLAGS: return IR(906, 2); - case SPV_OPERAND_TYPE_LINKAGE_TYPE: return IR(908, 3); - case SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL: return IR(911, 5); - case SPV_OPERAND_TYPE_LOOP_CONTROL: return IR(916, 20); - case SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: return IR(936, 15); - case SPV_OPERAND_TYPE_MEMORY_ACCESS: return IR(951, 9); - case SPV_OPERAND_TYPE_MEMORY_MODEL: return IR(960, 4); - case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: return IR(964, 15); - case SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS: return IR(979, 1); - case SPV_OPERAND_TYPE_OVERFLOW_MODES: return IR(980, 4); - case SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT: return IR(984, 1); - case SPV_OPERAND_TYPE_QUANTIZATION_MODES: return IR(985, 8); - case SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS: return IR(993, 3); - case SPV_OPERAND_TYPE_RAY_FLAGS: return IR(996, 12); - case SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE: return IR(1008, 2); - case SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE: return IR(1010, 3); - case SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION: return IR(1013, 2); - case SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE: return IR(1015, 5); - case SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE: return IR(1020, 2); - case SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT: return IR(1022, 42); - case SPV_OPERAND_TYPE_SCOPE_ID: return IR(1064, 7); - case SPV_OPERAND_TYPE_SELECTION_CONTROL: return IR(1071, 3); - case SPV_OPERAND_TYPE_SHDEBUG100_BUILD_IDENTIFIER_FLAGS: return IR(1074, 1); - case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return IR(1075, 8); - case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE: return IR(1083, 3); - case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_IMPORTED_ENTITY: return IR(1086, 2); - case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS: return IR(1088, 20); - case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION: return IR(1108, 10); - case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER: return IR(1118, 4); - case SPV_OPERAND_TYPE_SOURCE_LANGUAGE: return IR(1122, 14); - case SPV_OPERAND_TYPE_STORAGE_CLASS: return IR(1136, 28); - case SPV_OPERAND_TYPE_STORE_CACHE_CONTROL: return IR(1164, 4); - case SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS: return IR(1168, 3); - case SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE: return IR(1171, 5); - case SPV_OPERAND_TYPE_TENSOR_OPERANDS: return IR(1176, 6); - case SPV_OPERAND_TYPE_OPTIONAL_IMAGE: return IR(836, 17); + case SPV_OPERAND_TYPE_CAPABILITY: return IR(133, 275); + case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return IR(408, 8); + case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE: return IR(416, 3); + case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY: return IR(419, 2); + case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS: return IR(421, 19); + case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION: return IR(440, 10); + case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER: return IR(450, 4); + case SPV_OPERAND_TYPE_COMPONENT_TYPE: return IR(454, 15); + case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT: return IR(469, 4); + case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS: return IR(473, 6); + case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE: return IR(479, 3); + case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE: return IR(482, 3); + case SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT: return IR(485, 4); + case SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return IR(489, 8); + case SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE: return IR(497, 3); + case SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS: return IR(500, 16); + case SPV_OPERAND_TYPE_DEBUG_OPERATION: return IR(516, 9); + case SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER: return IR(525, 3); + case SPV_OPERAND_TYPE_DECORATION: return IR(528, 144); + case SPV_OPERAND_TYPE_DIMENSIONALITY: return IR(672, 8); + case SPV_OPERAND_TYPE_EXECUTION_MODE: return IR(680, 96); + case SPV_OPERAND_TYPE_EXECUTION_MODEL: return IR(776, 17); + case SPV_OPERAND_TYPE_FPDENORM_MODE: return IR(793, 2); + case SPV_OPERAND_TYPE_FPENCODING: return IR(795, 3); + case SPV_OPERAND_TYPE_FPOPERATION_MODE: return IR(798, 2); + case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE: return IR(800, 9); + case SPV_OPERAND_TYPE_FP_ROUNDING_MODE: return IR(809, 4); + case SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE: return IR(813, 4); + case SPV_OPERAND_TYPE_FUNCTION_CONTROL: return IR(817, 6); + case SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE: return IR(823, 9); + case SPV_OPERAND_TYPE_GROUP_OPERATION: return IR(832, 7); + case SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER: return IR(839, 4); + case SPV_OPERAND_TYPE_IMAGE: return IR(843, 17); + case SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE: return IR(860, 26); + case SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER: return IR(886, 20); + case SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER: return IR(906, 2); + case SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS: return IR(908, 3); + case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO: return IR(911, 2); + case SPV_OPERAND_TYPE_KERNEL_PROPERTY_FLAGS: return IR(913, 2); + case SPV_OPERAND_TYPE_LINKAGE_TYPE: return IR(915, 3); + case SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL: return IR(918, 5); + case SPV_OPERAND_TYPE_LOOP_CONTROL: return IR(923, 20); + case SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: return IR(943, 15); + case SPV_OPERAND_TYPE_MEMORY_ACCESS: return IR(958, 9); + case SPV_OPERAND_TYPE_MEMORY_MODEL: return IR(967, 4); + case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: return IR(971, 15); + case SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS: return IR(986, 1); + case SPV_OPERAND_TYPE_OVERFLOW_MODES: return IR(987, 4); + case SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT: return IR(991, 1); + case SPV_OPERAND_TYPE_QUANTIZATION_MODES: return IR(992, 8); + case SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS: return IR(1000, 3); + case SPV_OPERAND_TYPE_RAY_FLAGS: return IR(1003, 12); + case SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE: return IR(1015, 2); + case SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE: return IR(1017, 3); + case SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION: return IR(1020, 2); + case SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE: return IR(1022, 5); + case SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE: return IR(1027, 2); + case SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT: return IR(1029, 42); + case SPV_OPERAND_TYPE_SCOPE_ID: return IR(1071, 7); + case SPV_OPERAND_TYPE_SELECTION_CONTROL: return IR(1078, 3); + case SPV_OPERAND_TYPE_SHDEBUG100_BUILD_IDENTIFIER_FLAGS: return IR(1081, 1); + case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return IR(1082, 8); + case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE: return IR(1090, 3); + case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_IMPORTED_ENTITY: return IR(1093, 2); + case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS: return IR(1095, 20); + case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION: return IR(1115, 10); + case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER: return IR(1125, 4); + case SPV_OPERAND_TYPE_SOURCE_LANGUAGE: return IR(1129, 14); + case SPV_OPERAND_TYPE_STORAGE_CLASS: return IR(1143, 28); + case SPV_OPERAND_TYPE_STORE_CACHE_CONTROL: return IR(1171, 4); + case SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS: return IR(1175, 3); + case SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE: return IR(1178, 5); + case SPV_OPERAND_TYPE_TENSOR_OPERANDS: return IR(1183, 6); + case SPV_OPERAND_TYPE_OPTIONAL_IMAGE: return IR(843, 17); case SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER: return IR(0, 3); - case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS: return IR(951, 9); - case SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT: return IR(984, 1); - case SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS: return IR(467, 6); - case SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: return IR(936, 15); - case SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS: return IR(993, 3); - case SPV_OPERAND_TYPE_OPTIONAL_FPENCODING: return IR(788, 3); - case SPV_OPERAND_TYPE_OPTIONAL_TENSOR_OPERANDS: return IR(1176, 6); + case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS: return IR(958, 9); + case SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT: return IR(991, 1); + case SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS: return IR(473, 6); + case SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: return IR(943, 15); + case SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS: return IR(1000, 3); + case SPV_OPERAND_TYPE_OPTIONAL_FPENCODING: return IR(795, 3); + case SPV_OPERAND_TYPE_OPTIONAL_TENSOR_OPERANDS: return IR(1183, 6); + case SPV_OPERAND_TYPE_OPTIONAL_CAPABILITY: return IR(133, 275); default: break; } return IR(0,0); @@ -1623,1283 +1639,1290 @@ IndexRange OperandByValueRangeForKind(spv_operand_type_t type) { // The fields in order are: // name, either the primary name or an alias, indexing into kStrings // index into the kOperandsByValue array -static const std::array kOperandNames{{ - {IR(4540, 9), 0}, // 0 ReadOnly in SPV_OPERAND_TYPE_ACCESS_QUALIFIER - {IR(4566, 10), 2}, // 1 ReadWrite in SPV_OPERAND_TYPE_ACCESS_QUALIFIER - {IR(4556, 10), 1}, // 2 WriteOnly in SPV_OPERAND_TYPE_ACCESS_QUALIFIER - {IR(4576, 8), 3}, // 3 Logical in SPV_OPERAND_TYPE_ADDRESSING_MODEL - {IR(4584, 11), 4}, // 4 Physical32 in SPV_OPERAND_TYPE_ADDRESSING_MODEL - {IR(4605, 11), 5}, // 5 Physical64 in SPV_OPERAND_TYPE_ADDRESSING_MODEL - {IR(4616, 24), 6}, // 6 PhysicalStorageBuffer64 in SPV_OPERAND_TYPE_ADDRESSING_MODEL - {IR(4640, 27), 6}, // 7 PhysicalStorageBuffer64EXT in SPV_OPERAND_TYPE_ADDRESSING_MODEL - {IR(6550, 13), 92}, // 8 BaryCoordKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(6563, 12), 92}, // 9 BaryCoordNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(5945, 20), 68}, // 10 BaryCoordNoPerspAMD in SPV_OPERAND_TYPE_BUILT_IN - {IR(5965, 28), 69}, // 11 BaryCoordNoPerspCentroidAMD in SPV_OPERAND_TYPE_BUILT_IN - {IR(6598, 20), 93}, // 12 BaryCoordNoPerspKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(6618, 19), 93}, // 13 BaryCoordNoPerspNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(5993, 26), 70}, // 14 BaryCoordNoPerspSampleAMD in SPV_OPERAND_TYPE_BUILT_IN - {IR(6090, 22), 74}, // 15 BaryCoordPullModelAMD in SPV_OPERAND_TYPE_BUILT_IN - {IR(6019, 19), 71}, // 16 BaryCoordSmoothAMD in SPV_OPERAND_TYPE_BUILT_IN - {IR(6038, 27), 72}, // 17 BaryCoordSmoothCentroidAMD in SPV_OPERAND_TYPE_BUILT_IN - {IR(6065, 25), 73}, // 18 BaryCoordSmoothSampleAMD in SPV_OPERAND_TYPE_BUILT_IN - {IR(5749, 13), 59}, // 19 BaseInstance in SPV_OPERAND_TYPE_BUILT_IN - {IR(5723, 11), 58}, // 20 BaseVertex in SPV_OPERAND_TYPE_BUILT_IN - {IR(4724, 13), 9}, // 21 ClipDistance in SPV_OPERAND_TYPE_BUILT_IN - {IR(6457, 22), 87}, // 22 ClipDistancePerViewNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7756, 12), 131}, // 23 ClusterIDNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(5487, 13), 49}, // 24 CoreCountARM in SPV_OPERAND_TYPE_BUILT_IN - {IR(5461, 10), 48}, // 25 CoreIDARM in SPV_OPERAND_TYPE_BUILT_IN - {IR(5500, 13), 50}, // 26 CoreMaxIDARM in SPV_OPERAND_TYPE_BUILT_IN - {IR(4737, 13), 10}, // 27 CullDistance in SPV_OPERAND_TYPE_BUILT_IN - {IR(6479, 22), 88}, // 28 CullDistancePerViewNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7809, 12), 132}, // 29 CullMaskKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(6805, 17), 99}, // 30 CullPrimitiveEXT in SPV_OPERAND_TYPE_BUILT_IN - {IR(7209, 17), 113}, // 31 CurrentRayTimeNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(5819, 12), 62}, // 32 DeviceIndex in SPV_OPERAND_TYPE_BUILT_IN - {IR(5762, 10), 60}, // 33 DrawIndex in SPV_OPERAND_TYPE_BUILT_IN - {IR(5251, 22), 37}, // 34 EnqueuedWorkgroupSize in SPV_OPERAND_TYPE_BUILT_IN - {IR(5021, 10), 21}, // 35 FragCoord in SPV_OPERAND_TYPE_BUILT_IN - {IR(5107, 10), 27}, // 36 FragDepth in SPV_OPERAND_TYPE_BUILT_IN - {IR(6683, 23), 95}, // 37 FragInvocationCountEXT in SPV_OPERAND_TYPE_BUILT_IN - {IR(6637, 12), 94}, // 38 FragSizeEXT in SPV_OPERAND_TYPE_BUILT_IN - {IR(6112, 18), 75}, // 39 FragStencilRefEXT in SPV_OPERAND_TYPE_BUILT_IN - {IR(6649, 15), 94}, // 40 FragmentSizeNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(5042, 12), 23}, // 41 FrontFacing in SPV_OPERAND_TYPE_BUILT_IN - {IR(6369, 16), 83}, // 42 FullyCoveredEXT in SPV_OPERAND_TYPE_BUILT_IN - {IR(5192, 19), 33}, // 43 GlobalInvocationId in SPV_OPERAND_TYPE_BUILT_IN - {IR(5286, 15), 39}, // 44 GlobalLinearId in SPV_OPERAND_TYPE_BUILT_IN - {IR(5273, 13), 38}, // 45 GlobalOffset in SPV_OPERAND_TYPE_BUILT_IN - {IR(5240, 11), 36}, // 46 GlobalSize in SPV_OPERAND_TYPE_BUILT_IN - {IR(5117, 17), 28}, // 47 HelperInvocation in SPV_OPERAND_TYPE_BUILT_IN - {IR(7511, 11), 120}, // 48 HitIsLSSNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7469, 14), 119}, // 49 HitIsSphereNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7691, 33), 128}, // 50 HitKindBackFacingMicroTriangleNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7657, 34), 127}, // 51 HitKindFrontFacingMicroTriangleNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7188, 11), 112}, // 52 HitKindKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(7199, 10), 112}, // 53 HitKindNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7639, 18), 126}, // 54 HitLSSPositionsNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7742, 14), 130}, // 55 HitLSSRadiiNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7373, 37), 116}, // 56 HitMicroTriangleVertexBarycentricsNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7306, 34), 115}, // 57 HitMicroTriangleVertexPositionsNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7561, 20), 121}, // 58 HitSpherePositionNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7724, 18), 129}, // 59 HitSphereRadiusNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7181, 7), 111}, // 60 HitTNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7249, 30), 114}, // 61 HitTriangleVertexPositionsKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(7410, 20), 117}, // 62 IncomingRayFlagsKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(7430, 19), 117}, // 63 IncomingRayFlagsNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7070, 23), 108}, // 64 InstanceCustomIndexKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(7093, 22), 108}, // 65 InstanceCustomIndexNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(4759, 11), 12}, // 66 InstanceId in SPV_OPERAND_TYPE_BUILT_IN - {IR(5447, 14), 47}, // 67 InstanceIndex in SPV_OPERAND_TYPE_BUILT_IN - {IR(4860, 13), 14}, // 68 InvocationId in SPV_OPERAND_TYPE_BUILT_IN - {IR(6706, 22), 95}, // 69 InvocationsPerPixelNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(6822, 12), 100}, // 70 LaunchIdKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(6834, 11), 100}, // 71 LaunchIdNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(6845, 14), 101}, // 72 LaunchSizeKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(6859, 13), 101}, // 73 LaunchSizeNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(4873, 6), 15}, // 74 Layer in SPV_OPERAND_TYPE_BUILT_IN - {IR(6501, 15), 89}, // 75 LayerPerViewNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(5174, 18), 32}, // 76 LocalInvocationId in SPV_OPERAND_TYPE_BUILT_IN - {IR(5211, 21), 34}, // 77 LocalInvocationIndex in SPV_OPERAND_TYPE_BUILT_IN - {IR(6516, 16), 90}, // 78 MeshViewCountNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(6532, 18), 91}, // 79 MeshViewIndicesNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(5377, 21), 43}, // 80 NumEnqueuedSubgroups in SPV_OPERAND_TYPE_BUILT_IN - {IR(5364, 13), 42}, // 81 NumSubgroups in SPV_OPERAND_TYPE_BUILT_IN - {IR(5134, 14), 29}, // 82 NumWorkgroups in SPV_OPERAND_TYPE_BUILT_IN - {IR(6985, 22), 105}, // 83 ObjectRayDirectionKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(7007, 21), 105}, // 84 ObjectRayDirectionNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(6948, 19), 104}, // 85 ObjectRayOriginKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(6967, 18), 104}, // 86 ObjectRayOriginNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7115, 17), 109}, // 87 ObjectToWorldKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(7132, 16), 109}, // 88 ObjectToWorldNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(5007, 14), 20}, // 89 PatchVertices in SPV_OPERAND_TYPE_BUILT_IN - {IR(5031, 11), 22}, // 90 PointCoord in SPV_OPERAND_TYPE_BUILT_IN - {IR(4714, 10), 8}, // 91 PointSize in SPV_OPERAND_TYPE_BUILT_IN - {IR(4698, 9), 7}, // 92 Position in SPV_OPERAND_TYPE_BUILT_IN - {IR(6309, 18), 81}, // 93 PositionPerViewNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(6421, 17), 85}, // 94 PrimitiveCountNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(4770, 12), 13}, // 95 PrimitiveId in SPV_OPERAND_TYPE_BUILT_IN - {IR(6438, 19), 86}, // 96 PrimitiveIndicesNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(6753, 24), 97}, // 97 PrimitiveLineIndicesEXT in SPV_OPERAND_TYPE_BUILT_IN - {IR(6728, 25), 96}, // 98 PrimitivePointIndicesEXT in SPV_OPERAND_TYPE_BUILT_IN - {IR(5772, 24), 61}, // 99 PrimitiveShadingRateKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(6777, 28), 98}, // 100 PrimitiveTriangleIndicesEXT in SPV_OPERAND_TYPE_BUILT_IN - {IR(7449, 20), 118}, // 101 RayGeometryIndexKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(7049, 11), 107}, // 102 RayTmaxKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(7060, 10), 107}, // 103 RayTmaxNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7028, 11), 106}, // 104 RayTminKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(7039, 10), 106}, // 105 RayTminNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(6147, 29), 76}, // 106 RemainingRecursionLevelsAMDX in SPV_OPERAND_TYPE_BUILT_IN - {IR(7613, 10), 123}, // 107 SMCountNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7632, 7), 125}, // 108 SMIDNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(5054, 9), 24}, // 109 SampleId in SPV_OPERAND_TYPE_BUILT_IN - {IR(5096, 11), 26}, // 110 SampleMask in SPV_OPERAND_TYPE_BUILT_IN - {IR(5081, 15), 25}, // 111 SamplePosition in SPV_OPERAND_TYPE_BUILT_IN - {IR(6246, 20), 79}, // 112 SecondaryPositionNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(6285, 24), 80}, // 113 SecondaryViewportMaskNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(6194, 16), 77}, // 114 ShaderIndexAMDX in SPV_OPERAND_TYPE_BUILT_IN - {IR(5863, 15), 64}, // 115 ShadingRateKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(5536, 15), 53}, // 116 SubgroupEqMask in SPV_OPERAND_TYPE_BUILT_IN - {IR(5551, 18), 53}, // 117 SubgroupEqMaskKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(5591, 15), 54}, // 118 SubgroupGeMask in SPV_OPERAND_TYPE_BUILT_IN - {IR(5606, 18), 54}, // 119 SubgroupGeMaskKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(5624, 15), 55}, // 120 SubgroupGtMask in SPV_OPERAND_TYPE_BUILT_IN - {IR(5639, 18), 55}, // 121 SubgroupGtMaskKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(5398, 11), 44}, // 122 SubgroupId in SPV_OPERAND_TYPE_BUILT_IN - {IR(5657, 15), 56}, // 123 SubgroupLeMask in SPV_OPERAND_TYPE_BUILT_IN - {IR(5672, 18), 56}, // 124 SubgroupLeMaskKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(5409, 26), 45}, // 125 SubgroupLocalInvocationId in SPV_OPERAND_TYPE_BUILT_IN - {IR(5690, 15), 57}, // 126 SubgroupLtMask in SPV_OPERAND_TYPE_BUILT_IN - {IR(5705, 18), 57}, // 127 SubgroupLtMaskKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(5348, 16), 41}, // 128 SubgroupMaxSize in SPV_OPERAND_TYPE_BUILT_IN - {IR(5301, 13), 40}, // 129 SubgroupSize in SPV_OPERAND_TYPE_BUILT_IN - {IR(6409, 12), 84}, // 130 TaskCountNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(4997, 10), 19}, // 131 TessCoord in SPV_OPERAND_TYPE_BUILT_IN - {IR(4982, 15), 18}, // 132 TessLevelInner in SPV_OPERAND_TYPE_BUILT_IN - {IR(4967, 15), 17}, // 133 TessLevelOuter in SPV_OPERAND_TYPE_BUILT_IN - {IR(5927, 18), 67}, // 134 TileApronSizeQCOM in SPV_OPERAND_TYPE_BUILT_IN - {IR(5909, 18), 66}, // 135 TileDimensionQCOM in SPV_OPERAND_TYPE_BUILT_IN - {IR(5878, 15), 65}, // 136 TileOffsetQCOM in SPV_OPERAND_TYPE_BUILT_IN - {IR(4750, 9), 11}, // 137 VertexId in SPV_OPERAND_TYPE_BUILT_IN - {IR(5435, 12), 46}, // 138 VertexIndex in SPV_OPERAND_TYPE_BUILT_IN - {IR(5843, 10), 63}, // 139 ViewIndex in SPV_OPERAND_TYPE_BUILT_IN - {IR(4919, 14), 16}, // 140 ViewportIndex in SPV_OPERAND_TYPE_BUILT_IN - {IR(6210, 15), 78}, // 141 ViewportMaskNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(6347, 22), 82}, // 142 ViewportMaskPerViewNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(5513, 10), 51}, // 143 WarpIDARM in SPV_OPERAND_TYPE_BUILT_IN - {IR(7623, 9), 124}, // 144 WarpIDNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(5523, 13), 52}, // 145 WarpMaxIDARM in SPV_OPERAND_TYPE_BUILT_IN - {IR(7581, 13), 122}, // 146 WarpsPerSMNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(5232, 8), 35}, // 147 WorkDim in SPV_OPERAND_TYPE_BUILT_IN - {IR(5162, 12), 31}, // 148 WorkgroupId in SPV_OPERAND_TYPE_BUILT_IN - {IR(5148, 14), 30}, // 149 WorkgroupSize in SPV_OPERAND_TYPE_BUILT_IN - {IR(6907, 21), 103}, // 150 WorldRayDirectionKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(6928, 20), 103}, // 151 WorldRayDirectionNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(6872, 18), 102}, // 152 WorldRayOriginKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(6890, 17), 102}, // 153 WorldRayOriginNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(7148, 17), 110}, // 154 WorldToObjectKHR in SPV_OPERAND_TYPE_BUILT_IN - {IR(7165, 16), 110}, // 155 WorldToObjectNV in SPV_OPERAND_TYPE_BUILT_IN - {IR(4595, 10), 137}, // 156 Addresses in SPV_OPERAND_TYPE_CAPABILITY - {IR(12785, 34), 357}, // 157 ArbitraryPrecisionFixedPointINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12473, 37), 345}, // 158 ArbitraryPrecisionFloatingPointINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12441, 32), 344}, // 159 ArbitraryPrecisionIntegersINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13335, 19), 381}, // 160 ArithmeticFenceEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(12106, 9), 330}, // 161 AsmINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13252, 20), 377}, // 162 AtomicFloat16AddEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(12161, 23), 333}, // 163 AtomicFloat16MinMaxEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(11634, 22), 308}, // 164 AtomicFloat16VectorNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(13168, 20), 373}, // 165 AtomicFloat32AddEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(12115, 23), 331}, // 166 AtomicFloat32MinMaxEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(13188, 20), 374}, // 167 AtomicFloat64AddEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(12138, 23), 332}, // 168 AtomicFloat64MinMaxEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(7989, 14), 153}, // 169 AtomicStorage in SPV_OPERAND_TYPE_CAPABILITY - {IR(9346, 17), 228}, // 170 AtomicStorageOps in SPV_OPERAND_TYPE_CAPABILITY - {IR(13293, 24), 379}, // 171 BFloat16ConversionINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(9957, 29), 261}, // 172 BFloat16CooperativeMatrixKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(9935, 22), 260}, // 173 BFloat16DotProductKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(9919, 16), 259}, // 174 BFloat16TypeKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(13856, 20), 401}, // 175 BindlessImagesINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(11571, 18), 305}, // 176 BindlessTextureNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(13112, 16), 370}, // 177 BitInstructions in SPV_OPERAND_TYPE_CAPABILITY - {IR(12884, 19), 361}, // 178 BlockingPipesINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13817, 19), 399}, // 179 CacheControlsINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(4724, 13), 163}, // 180 ClipDistance in SPV_OPERAND_TYPE_CAPABILITY - {IR(11229, 32), 294}, // 181 ComputeDerivativeGroupLinearKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(11261, 31), 294}, // 182 ComputeDerivativeGroupLinearNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(10109, 31), 273}, // 183 ComputeDerivativeGroupQuadsKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(10140, 30), 273}, // 184 ComputeDerivativeGroupQuadsNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(11811, 30), 317}, // 185 CooperativeMatrixBlockLoadsNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(11704, 31), 314}, // 186 CooperativeMatrixConversionsNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(9898, 21), 368}, // 187 CooperativeMatrixKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(8950, 28), 210}, // 188 CooperativeMatrixLayoutsARM in SPV_OPERAND_TYPE_CAPABILITY - {IR(11317, 20), 296}, // 189 CooperativeMatrixNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(11735, 40), 315}, // 190 CooperativeMatrixPerElementOperationsNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(11674, 30), 313}, // 191 CooperativeMatrixReductionsNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(11775, 36), 316}, // 192 CooperativeMatrixTensorAddressingNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(11614, 20), 307}, // 193 CooperativeVectorNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(11841, 28), 318}, // 194 CooperativeVectorTrainingNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(5471, 16), 203}, // 195 CoreBuiltinsARM in SPV_OPERAND_TYPE_CAPABILITY - {IR(4737, 13), 164}, // 196 CullDistance in SPV_OPERAND_TYPE_CAPABILITY - {IR(13272, 21), 378}, // 197 DebugInfoModuleINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(11440, 25), 301}, // 198 DemoteToHelperInvocation in SPV_OPERAND_TYPE_CAPABILITY - {IR(11465, 28), 301}, // 199 DemoteToHelperInvocationEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(9485, 18), 234}, // 200 DenormFlushToZero in SPV_OPERAND_TYPE_CAPABILITY - {IR(9470, 15), 233}, // 201 DenormPreserve in SPV_OPERAND_TYPE_CAPABILITY - {IR(8436, 18), 182}, // 202 DerivativeControl in SPV_OPERAND_TYPE_CAPABILITY - {IR(7960, 14), 151}, // 203 DeviceEnqueue in SPV_OPERAND_TYPE_CAPABILITY - {IR(5831, 12), 224}, // 204 DeviceGroup in SPV_OPERAND_TYPE_CAPABILITY - {IR(11493, 23), 302}, // 205 DisplacementMicromapNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(13063, 11), 366}, // 206 DotProduct in SPV_OPERAND_TYPE_CAPABILITY - {IR(12957, 22), 364}, // 207 DotProductInput4x8Bit in SPV_OPERAND_TYPE_CAPABILITY - {IR(12979, 25), 364}, // 208 DotProductInput4x8BitKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(13004, 28), 365}, // 209 DotProductInput4x8BitPacked in SPV_OPERAND_TYPE_CAPABILITY - {IR(13032, 31), 365}, // 210 DotProductInput4x8BitPackedKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(12916, 19), 363}, // 211 DotProductInputAll in SPV_OPERAND_TYPE_CAPABILITY - {IR(12935, 22), 363}, // 212 DotProductInputAllKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(13074, 14), 366}, // 213 DotProductKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(5734, 15), 215}, // 214 DrawParameters in SPV_OPERAND_TYPE_CAPABILITY - {IR(12218, 16), 336}, // 215 ExpectAssumeKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(12421, 20), 343}, // 216 FPFastMathModeINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13469, 28), 387}, // 217 FPGAArgumentInterfacesINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12761, 24), 356}, // 218 FPGABufferLocationINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12634, 27), 351}, // 219 FPGAClusterAttributesINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13354, 29), 382}, // 220 FPGAClusterAttributesV2INTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12675, 20), 353}, // 221 FPGADSPControlINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12721, 40), 355}, // 222 FPGAInvocationPipeliningAttributesINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12584, 26), 349}, // 223 FPGAKernelAttributesINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13383, 28), 383}, // 224 FPGAKernelAttributesv2INTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13445, 24), 386}, // 225 FPGALatencyControlINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12540, 22), 347}, // 226 FPGALoopControlsINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12610, 24), 350}, // 227 FPGAMemoryAccessesINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12395, 26), 342}, // 228 FPGAMemoryAttributesINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12903, 13), 362}, // 229 FPGARegINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13429, 16), 385}, // 230 FPMaxErrorINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(7874, 8), 142}, // 231 Float16 in SPV_OPERAND_TYPE_CAPABILITY - {IR(7860, 14), 141}, // 232 Float16Buffer in SPV_OPERAND_TYPE_CAPABILITY - {IR(9738, 16), 248}, // 233 Float16ImageAMD in SPV_OPERAND_TYPE_CAPABILITY - {IR(7882, 8), 143}, // 234 Float64 in SPV_OPERAND_TYPE_CAPABILITY - {IR(8988, 27), 212}, // 235 Float8CooperativeMatrixEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(8978, 10), 211}, // 236 Float8EXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(13153, 15), 372}, // 237 FloatControls2 in SPV_OPERAND_TYPE_CAPABILITY - {IR(12014, 23), 326}, // 238 FloatingPointModeINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(6575, 23), 272}, // 239 FragmentBarycentricKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(10087, 22), 272}, // 240 FragmentBarycentricNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(6664, 19), 274}, // 241 FragmentDensityEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(6385, 24), 268}, // 242 FragmentFullyCoveredEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(9776, 16), 250}, // 243 FragmentMaskAMD in SPV_OPERAND_TYPE_CAPABILITY - {IR(11408, 32), 300}, // 244 FragmentShaderPixelInterlockEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(11337, 33), 297}, // 245 FragmentShaderSampleInterlockEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(11370, 38), 298}, // 246 FragmentShaderShadingRateInterlockEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(5796, 23), 213}, // 247 FragmentShadingRateKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(12369, 26), 341}, // 248 FunctionFloatControlINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12060, 22), 328}, // 249 FunctionPointersINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(8281, 15), 169}, // 250 GenericPointer in SPV_OPERAND_TYPE_CAPABILITY - {IR(4782, 9), 135}, // 251 Geometry in SPV_OPERAND_TYPE_CAPABILITY - {IR(8031, 18), 156}, // 252 GeometryPointSize in SPV_OPERAND_TYPE_CAPABILITY - {IR(10015, 28), 263}, // 253 GeometryShaderPassthroughNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(8494, 16), 185}, // 254 GeometryStreams in SPV_OPERAND_TYPE_CAPABILITY - {IR(13527, 35), 389}, // 255 GlobalVariableFPGADecorationsINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13497, 30), 388}, // 256 GlobalVariableHostAccessINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(5314, 16), 192}, // 257 GroupNonUniform in SPV_OPERAND_TYPE_CAPABILITY - {IR(8633, 26), 194}, // 258 GroupNonUniformArithmetic in SPV_OPERAND_TYPE_CAPABILITY - {IR(5569, 22), 195}, // 259 GroupNonUniformBallot in SPV_OPERAND_TYPE_CAPABILITY - {IR(8713, 25), 198}, // 260 GroupNonUniformClustered in SPV_OPERAND_TYPE_CAPABILITY - {IR(10184, 29), 275}, // 261 GroupNonUniformPartitionedNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(8738, 20), 199}, // 262 GroupNonUniformQuad in SPV_OPERAND_TYPE_CAPABILITY - {IR(13128, 25), 371}, // 263 GroupNonUniformRotateKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(8659, 23), 196}, // 264 GroupNonUniformShuffle in SPV_OPERAND_TYPE_CAPABILITY - {IR(8682, 31), 197}, // 265 GroupNonUniformShuffleRelative in SPV_OPERAND_TYPE_CAPABILITY - {IR(8613, 20), 193}, // 266 GroupNonUniformVote in SPV_OPERAND_TYPE_CAPABILITY - {IR(13739, 26), 396}, // 267 GroupUniformArithmeticKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(7953, 7), 150}, // 268 Groups in SPV_OPERAND_TYPE_CAPABILITY - {IR(12871, 13), 360}, // 269 IOPipesINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(8350, 8), 175}, // 270 Image1D in SPV_OPERAND_TYPE_CAPABILITY - {IR(7909, 11), 146}, // 271 ImageBasic in SPV_OPERAND_TYPE_CAPABILITY - {IR(8372, 12), 178}, // 272 ImageBuffer in SPV_OPERAND_TYPE_CAPABILITY - {IR(8227, 15), 165}, // 273 ImageCubeArray in SPV_OPERAND_TYPE_CAPABILITY - {IR(10070, 17), 270}, // 274 ImageFootprintNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(9754, 22), 249}, // 275 ImageGatherBiasLodAMD in SPV_OPERAND_TYPE_CAPABILITY - {IR(8049, 20), 157}, // 276 ImageGatherExtended in SPV_OPERAND_TYPE_CAPABILITY - {IR(8384, 13), 179}, // 277 ImageMSArray in SPV_OPERAND_TYPE_CAPABILITY - {IR(7935, 12), 148}, // 278 ImageMipmap in SPV_OPERAND_TYPE_CAPABILITY - {IR(8425, 11), 181}, // 279 ImageQuery in SPV_OPERAND_TYPE_CAPABILITY - {IR(7920, 15), 147}, // 280 ImageReadWrite in SPV_OPERAND_TYPE_CAPABILITY - {IR(9792, 21), 252}, // 281 ImageReadWriteLodAMD in SPV_OPERAND_TYPE_CAPABILITY - {IR(8259, 10), 167}, // 282 ImageRect in SPV_OPERAND_TYPE_CAPABILITY - {IR(12082, 24), 329}, // 283 IndirectReferencesINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(8301, 16), 171}, // 284 InputAttachment in SPV_OPERAND_TYPE_CAPABILITY - {IR(10299, 36), 278}, // 285 InputAttachmentArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(10335, 39), 278}, // 286 InputAttachmentArrayDynamicIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(10840, 39), 285}, // 287 InputAttachmentArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(10879, 42), 285}, // 288 InputAttachmentArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(8003, 6), 154}, // 289 Int16 in SPV_OPERAND_TYPE_CAPABILITY - {IR(9871, 27), 258}, // 290 Int4CooperativeMatrixINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(9857, 14), 257}, // 291 Int4TypeINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(7890, 6), 144}, // 292 Int64 in SPV_OPERAND_TYPE_CAPABILITY - {IR(7896, 13), 145}, // 293 Int64Atomics in SPV_OPERAND_TYPE_CAPABILITY - {IR(9813, 14), 253}, // 294 Int64ImageEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(8296, 5), 170}, // 295 Int8 in SPV_OPERAND_TYPE_CAPABILITY - {IR(12037, 23), 327}, // 296 IntegerFunctions2INTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(8454, 22), 183}, // 297 InterpolationFunction in SPV_OPERAND_TYPE_CAPABILITY - {IR(4549, 7), 139}, // 298 Kernel in SPV_OPERAND_TYPE_CAPABILITY - {IR(12562, 22), 348}, // 299 KernelAttributesINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(7843, 8), 138}, // 300 Linkage in SPV_OPERAND_TYPE_CAPABILITY - {IR(7974, 15), 152}, // 301 LiteralSampler in SPV_OPERAND_TYPE_CAPABILITY - {IR(13208, 20), 375}, // 302 LongCompositesINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12661, 14), 352}, // 303 LoopFuseINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13792, 25), 398}, // 304 MaskedGatherScatterINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(7836, 7), 133}, // 305 Matrix in SPV_OPERAND_TYPE_CAPABILITY - {IR(12695, 26), 354}, // 306 MemoryAccessAliasingINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(4845, 15), 271}, // 307 MeshShadingEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(4831, 14), 269}, // 308 MeshShadingNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(8333, 7), 173}, // 309 MinLod in SPV_OPERAND_TYPE_CAPABILITY - {IR(5853, 10), 225}, // 310 MultiView in SPV_OPERAND_TYPE_CAPABILITY - {IR(4933, 14), 188}, // 311 MultiViewport in SPV_OPERAND_TYPE_CAPABILITY - {IR(8588, 13), 190}, // 312 NamedBarrier in SPV_OPERAND_TYPE_CAPABILITY - {IR(13228, 11), 376}, // 313 OptNoneEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(13239, 13), 376}, // 314 OptNoneINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(6327, 20), 267}, // 315 PerViewAttributesNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(4667, 31), 293}, // 316 PhysicalStorageBufferAddresses in SPV_OPERAND_TYPE_CAPABILITY - {IR(11195, 34), 293}, // 317 PhysicalStorageBufferAddressesEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(8601, 12), 191}, // 318 PipeStorage in SPV_OPERAND_TYPE_CAPABILITY - {IR(7947, 6), 149}, // 319 Pipes in SPV_OPERAND_TYPE_CAPABILITY - {IR(9842, 15), 256}, // 320 QuadControlKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(11656, 18), 310}, // 321 RawAccessChainsNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(7821, 15), 367}, // 322 RayCullMaskKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(9583, 12), 239}, // 323 RayQueryKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(11589, 25), 306}, // 324 RayQueryPositionFetchKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(9560, 23), 238}, // 325 RayQueryProvisionalKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(7768, 41), 319}, // 326 RayTracingClusterAccelerationStructureNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(7340, 33), 309}, // 327 RayTracingDisplacementMicromapNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(4817, 14), 242}, // 328 RayTracingKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(7522, 39), 312}, // 329 RayTracingLinearSweptSpheresGeometryNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(7226, 23), 290}, // 330 RayTracingMotionBlurNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(4804, 13), 289}, // 331 RayTracingNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(11516, 29), 303}, // 332 RayTracingOpacityMicromapEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(7279, 27), 288}, // 333 RayTracingPositionFetchKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(11292, 25), 295}, // 334 RayTracingProvisionalKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(7483, 28), 311}, // 335 RayTracingSpheresGeometryNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(9614, 32), 241}, // 336 RayTraversalPrimitiveCullingKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(13836, 20), 400}, // 337 RegisterLimitsINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13088, 24), 369}, // 338 ReplicatedCompositesEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(11993, 21), 325}, // 339 RoundToInfinityINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(9528, 16), 236}, // 340 RoundingModeRTE in SPV_OPERAND_TYPE_CAPABILITY - {IR(9544, 16), 237}, // 341 RoundingModeRTZ in SPV_OPERAND_TYPE_CAPABILITY - {IR(12842, 29), 359}, // 342 RuntimeAlignedAttributeINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(10250, 23), 277}, // 343 RuntimeDescriptorArray in SPV_OPERAND_TYPE_CAPABILITY - {IR(10273, 26), 277}, // 344 RuntimeDescriptorArrayEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(9986, 29), 262}, // 345 SampleMaskOverrideCoverageNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(9363, 28), 229}, // 346 SampleMaskPostDepthCoverage in SPV_OPERAND_TYPE_CAPABILITY - {IR(5063, 18), 166}, // 347 SampleRateShading in SPV_OPERAND_TYPE_CAPABILITY - {IR(8340, 10), 174}, // 348 Sampled1D in SPV_OPERAND_TYPE_CAPABILITY - {IR(8358, 14), 177}, // 349 SampledBuffer in SPV_OPERAND_TYPE_CAPABILITY - {IR(8242, 17), 176}, // 350 SampledCubeArray in SPV_OPERAND_TYPE_CAPABILITY - {IR(8127, 33), 160}, // 351 SampledImageArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(10613, 36), 282}, // 352 SampledImageArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(10649, 39), 282}, // 353 SampledImageArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(8269, 12), 168}, // 354 SampledRect in SPV_OPERAND_TYPE_CAPABILITY - {IR(4707, 7), 134}, // 355 Shader in SPV_OPERAND_TYPE_CAPABILITY - {IR(9827, 15), 254}, // 356 ShaderClockKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(6176, 18), 255}, // 357 ShaderEnqueueAMDX in SPV_OPERAND_TYPE_CAPABILITY - {IR(11545, 26), 304}, // 358 ShaderInvocationReorderNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(4879, 12), 200}, // 359 ShaderLayer in SPV_OPERAND_TYPE_CAPABILITY - {IR(10213, 17), 276}, // 360 ShaderNonUniform in SPV_OPERAND_TYPE_CAPABILITY - {IR(10230, 20), 276}, // 361 ShaderNonUniformEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(7594, 19), 299}, // 362 ShaderSMBuiltinsNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(6266, 19), 266}, // 363 ShaderStereoViewNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(4947, 20), 201}, // 364 ShaderViewportIndex in SPV_OPERAND_TYPE_CAPABILITY - {IR(4891, 28), 264}, // 365 ShaderViewportIndexLayerEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(10043, 27), 264}, // 366 ShaderViewportIndexLayerNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(6225, 21), 265}, // 367 ShaderViewportMaskNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(10170, 14), 274}, // 368 ShadingRateNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(9503, 25), 235}, // 369 SignedZeroInfNanPreserve in SPV_OPERAND_TYPE_CAPABILITY - {IR(8317, 16), 172}, // 370 SparseResidency in SPV_OPERAND_TYPE_CAPABILITY - {IR(13317, 18), 380}, // 371 SplitBarrierINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(6130, 17), 251}, // 372 StencilExportEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(9151, 25), 220}, // 373 StorageBuffer16BitAccess in SPV_OPERAND_TYPE_CAPABILITY - {IR(9391, 24), 230}, // 374 StorageBuffer8BitAccess in SPV_OPERAND_TYPE_CAPABILITY - {IR(8160, 34), 161}, // 375 StorageBufferArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(10688, 37), 283}, // 376 StorageBufferArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(10725, 40), 283}, // 377 StorageBufferArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(8194, 33), 162}, // 378 StorageImageArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(10765, 36), 284}, // 379 StorageImageArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(10801, 39), 284}, // 380 StorageImageArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(8397, 28), 180}, // 381 StorageImageExtendedFormats in SPV_OPERAND_TYPE_CAPABILITY - {IR(8069, 24), 158}, // 382 StorageImageMultisample in SPV_OPERAND_TYPE_CAPABILITY - {IR(8510, 30), 186}, // 383 StorageImageReadWithoutFormat in SPV_OPERAND_TYPE_CAPABILITY - {IR(8540, 31), 187}, // 384 StorageImageWriteWithoutFormat in SPV_OPERAND_TYPE_CAPABILITY - {IR(9278, 21), 223}, // 385 StorageInputOutput16 in SPV_OPERAND_TYPE_CAPABILITY - {IR(9256, 22), 222}, // 386 StoragePushConstant16 in SPV_OPERAND_TYPE_CAPABILITY - {IR(9449, 21), 232}, // 387 StoragePushConstant8 in SPV_OPERAND_TYPE_CAPABILITY - {IR(8873, 37), 208}, // 388 StorageTensorArrayDynamicIndexingARM in SPV_OPERAND_TYPE_CAPABILITY - {IR(8910, 40), 209}, // 389 StorageTensorArrayNonUniformIndexingARM in SPV_OPERAND_TYPE_CAPABILITY - {IR(10455, 39), 280}, // 390 StorageTexelBufferArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(10494, 42), 280}, // 391 StorageTexelBufferArrayDynamicIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(11008, 42), 287}, // 392 StorageTexelBufferArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(11050, 45), 287}, // 393 StorageTexelBufferArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(9239, 17), 221}, // 394 StorageUniform16 in SPV_OPERAND_TYPE_CAPABILITY - {IR(9176, 28), 220}, // 395 StorageUniformBufferBlock16 in SPV_OPERAND_TYPE_CAPABILITY - {IR(13590, 23), 391}, // 396 Subgroup2DBlockIOINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13613, 30), 392}, // 397 Subgroup2DBlockTransformINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13643, 30), 393}, // 398 Subgroup2DBlockTransposeINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12305, 39), 339}, // 399 SubgroupAvcMotionEstimationChromaINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12234, 33), 337}, // 400 SubgroupAvcMotionEstimationINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12267, 38), 338}, // 401 SubgroupAvcMotionEstimationIntraINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(5330, 18), 214}, // 402 SubgroupBallotKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(11909, 27), 322}, // 403 SubgroupBufferBlockIOINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13562, 28), 390}, // 404 SubgroupBufferPrefetchINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(8571, 17), 189}, // 405 SubgroupDispatch in SPV_OPERAND_TYPE_CAPABILITY - {IR(11936, 26), 323}, // 406 SubgroupImageBlockIOINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(11962, 31), 324}, // 407 SubgroupImageMediaBlockIOINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(13673, 38), 394}, // 408 SubgroupMatrixMultiplyAccumulateINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(11888, 21), 321}, // 409 SubgroupShuffleINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(9135, 16), 219}, // 410 SubgroupVoteKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(13411, 18), 384}, // 411 TaskSequenceINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(11869, 19), 320}, // 412 TensorAddressingNV in SPV_OPERAND_TYPE_CAPABILITY - {IR(13765, 27), 397}, // 413 TensorFloat32RoundingINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(8862, 11), 207}, // 414 TensorsARM in SPV_OPERAND_TYPE_CAPABILITY - {IR(13711, 28), 395}, // 415 TernaryBitwiseFunctionINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(4791, 13), 136}, // 416 Tessellation in SPV_OPERAND_TYPE_CAPABILITY - {IR(8009, 22), 155}, // 417 TessellationPointSize in SPV_OPERAND_TYPE_CAPABILITY - {IR(9715, 23), 247}, // 418 TextureBlockMatch2QCOM in SPV_OPERAND_TYPE_CAPABILITY - {IR(9693, 22), 245}, // 419 TextureBlockMatchQCOM in SPV_OPERAND_TYPE_CAPABILITY - {IR(9672, 21), 244}, // 420 TextureBoxFilterQCOM in SPV_OPERAND_TYPE_CAPABILITY - {IR(9646, 26), 243}, // 421 TextureSampleWeightedQCOM in SPV_OPERAND_TYPE_CAPABILITY - {IR(8776, 28), 204}, // 422 TileImageColorReadAccessEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(8804, 28), 205}, // 423 TileImageDepthReadAccessEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(8832, 30), 206}, // 424 TileImageStencilReadAccessEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(5893, 16), 246}, // 425 TileShadingQCOM in SPV_OPERAND_TYPE_CAPABILITY - {IR(8476, 18), 184}, // 426 TransformFeedback in SPV_OPERAND_TYPE_CAPABILITY - {IR(12819, 23), 358}, // 427 USMStorageClassesINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(9204, 35), 221}, // 428 UniformAndStorageBuffer16BitAccess in SPV_OPERAND_TYPE_CAPABILITY - {IR(9415, 34), 231}, // 429 UniformAndStorageBuffer8BitAccess in SPV_OPERAND_TYPE_CAPABILITY - {IR(8093, 34), 159}, // 430 UniformBufferArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(10536, 37), 281}, // 431 UniformBufferArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(10573, 40), 281}, // 432 UniformBufferArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(8758, 18), 202}, // 433 UniformDecoration in SPV_OPERAND_TYPE_CAPABILITY - {IR(10374, 39), 279}, // 434 UniformTexelBufferArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(10413, 42), 279}, // 435 UniformTexelBufferArrayDynamicIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(10921, 42), 286}, // 436 UniformTexelBufferArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY - {IR(10963, 45), 286}, // 437 UniformTexelBufferArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY - {IR(12510, 30), 346}, // 438 UnstructuredLoopControlsINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(9595, 19), 240}, // 439 UntypedPointersKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(12344, 25), 340}, // 440 VariableLengthArrayINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(9329, 17), 227}, // 441 VariablePointers in SPV_OPERAND_TYPE_CAPABILITY - {IR(9299, 30), 226}, // 442 VariablePointersStorageBuffer in SPV_OPERAND_TYPE_CAPABILITY - {IR(7851, 9), 140}, // 443 Vector16 in SPV_OPERAND_TYPE_CAPABILITY - {IR(12203, 15), 335}, // 444 VectorAnyINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(12184, 19), 334}, // 445 VectorComputeINTEL in SPV_OPERAND_TYPE_CAPABILITY - {IR(11095, 18), 291}, // 446 VulkanMemoryModel in SPV_OPERAND_TYPE_CAPABILITY - {IR(11134, 29), 292}, // 447 VulkanMemoryModelDeviceScope in SPV_OPERAND_TYPE_CAPABILITY - {IR(11163, 32), 292}, // 448 VulkanMemoryModelDeviceScopeKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(11113, 21), 291}, // 449 VulkanMemoryModelKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(9091, 44), 218}, // 450 WorkgroupMemoryExplicitLayout16BitAccessKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(9048, 43), 217}, // 451 WorkgroupMemoryExplicitLayout8BitAccessKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(9015, 33), 216}, // 452 WorkgroupMemoryExplicitLayoutKHR in SPV_OPERAND_TYPE_CAPABILITY - {IR(13888, 8), 403}, // 453 Address in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13896, 8), 404}, // 454 Boolean in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13904, 6), 405}, // 455 Float in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13910, 7), 406}, // 456 Signed in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13917, 11), 407}, // 457 SignedChar in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13928, 9), 408}, // 458 Unsigned in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13937, 13), 409}, // 459 UnsignedChar in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13876, 12), 402}, // 460 Unspecified in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13950, 6), 410}, // 461 Class in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE - {IR(13956, 10), 411}, // 462 Structure in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE - {IR(13966, 6), 412}, // 463 Union in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE - {IR(13987, 20), 414}, // 464 ImportedDeclaration in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY - {IR(13972, 15), 413}, // 465 ImportedModule in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY - {IR(14096, 15), 422}, // 466 FlagArtificial in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14111, 13), 423}, // 467 FlagExplicit in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14084, 12), 421}, // 468 FlagFwdDecl in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14174, 21), 427}, // 469 FlagIndirectVariable in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14067, 17), 420}, // 470 FlagIsDefinition in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14251, 16), 431}, // 471 FlagIsEnumClass in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14055, 12), 419}, // 472 FlagIsLocal in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14235, 16), 430}, // 473 FlagIsOptimized in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14028, 14), 417}, // 474 FlagIsPrivate in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14012, 16), 416}, // 475 FlagIsProtected in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14042, 13), 418}, // 476 FlagIsPublic in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14195, 20), 428}, // 477 FlagLValueReference in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14139, 18), 425}, // 478 FlagObjectPointer in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14124, 15), 424}, // 479 FlagPrototyped in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14215, 20), 429}, // 480 FlagRValueReference in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14157, 17), 426}, // 481 FlagStaticMember in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14287, 24), 433}, // 482 FlagTypePassByReference in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14267, 20), 432}, // 483 FlagTypePassByValue in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14007, 5), 415}, // 484 None in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS - {IR(14372, 9), 438}, // 485 BitPiece in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {IR(14404, 7), 442}, // 486 Constu in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {IR(14311, 6), 434}, // 487 Deref in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {IR(14411, 9), 443}, // 488 Fragment in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {IR(14322, 6), 436}, // 489 Minus in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {IR(14317, 5), 435}, // 490 Plus in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {IR(14361, 11), 437}, // 491 PlusUconst in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {IR(14393, 11), 441}, // 492 StackValue in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {IR(14381, 5), 439}, // 493 Swap in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {IR(14386, 7), 440}, // 494 Xderef in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION - {IR(14456, 11), 447}, // 495 AtomicType in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER - {IR(14420, 10), 444}, // 496 ConstType in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER - {IR(14443, 13), 446}, // 497 RestrictType in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER - {IR(14430, 13), 445}, // 498 VolatileType in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER - {IR(14467, 10), 448}, // 499 Float16NV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14477, 10), 449}, // 500 Float32NV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14487, 10), 450}, // 501 Float64NV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14655, 12), 461}, // 502 FloatE4M3NV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14667, 12), 462}, // 503 FloatE5M2NV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14510, 14), 452}, // 504 SignedInt16NV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14524, 14), 453}, // 505 SignedInt32NV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14538, 14), 454}, // 506 SignedInt64NV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14497, 13), 451}, // 507 SignedInt8NV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14615, 19), 459}, // 508 SignedInt8PackedNV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14567, 16), 456}, // 509 UnsignedInt16NV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14583, 16), 457}, // 510 UnsignedInt32NV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14599, 16), 458}, // 511 UnsignedInt64NV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14552, 15), 455}, // 512 UnsignedInt8NV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14634, 21), 460}, // 513 UnsignedInt8PackedNV in SPV_OPERAND_TYPE_COMPONENT_TYPE - {IR(14731, 28), 466}, // 514 ColumnBlockedInterleavedARM in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT - {IR(14691, 15), 464}, // 515 ColumnMajorKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT - {IR(14706, 25), 465}, // 516 RowBlockedInterleavedARM in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT - {IR(14679, 12), 463}, // 517 RowMajorKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT - {IR(14767, 27), 468}, // 518 MatrixASignedComponentsKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS - {IR(14794, 27), 469}, // 519 MatrixBSignedComponentsKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS - {IR(14821, 27), 470}, // 520 MatrixCSignedComponentsKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS - {IR(14848, 32), 471}, // 521 MatrixResultSignedComponentsKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS - {IR(14759, 8), 467}, // 522 NoneKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS - {IR(14880, 26), 472}, // 523 SaturatingAccumulationKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS - {IR(14917, 4), 475}, // 524 2x2 in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE - {IR(14910, 7), 474}, // 525 Column in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE - {IR(14906, 4), 473}, // 526 Row in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE - {IR(14921, 11), 476}, // 527 MatrixAKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE - {IR(14943, 21), 478}, // 528 MatrixAccumulatorKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE - {IR(14932, 11), 477}, // 529 MatrixBKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE - {IR(14975, 14), 480}, // 530 ColumnMajorNV in SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT - {IR(14989, 21), 481}, // 531 InferencingOptimalNV in SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT - {IR(14964, 11), 479}, // 532 RowMajorNV in SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT - {IR(15010, 18), 482}, // 533 TrainingOptimalNV in SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT - {IR(13888, 8), 484}, // 534 Address in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13896, 8), 485}, // 535 Boolean in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13904, 6), 486}, // 536 Float in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13910, 7), 487}, // 537 Signed in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13917, 11), 488}, // 538 SignedChar in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13928, 9), 489}, // 539 Unsigned in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13937, 13), 490}, // 540 UnsignedChar in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13876, 12), 483}, // 541 Unspecified in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13950, 6), 491}, // 542 Class in SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE - {IR(13956, 10), 492}, // 543 Structure in SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE - {IR(13966, 6), 493}, // 544 Union in SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE - {IR(14096, 15), 501}, // 545 FlagArtificial in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14111, 13), 502}, // 546 FlagExplicit in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14084, 12), 500}, // 547 FlagFwdDecl in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14174, 21), 506}, // 548 FlagIndirectVariable in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14067, 17), 499}, // 549 FlagIsDefinition in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14055, 12), 498}, // 550 FlagIsLocal in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14235, 16), 509}, // 551 FlagIsOptimized in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14028, 14), 496}, // 552 FlagIsPrivate in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14012, 16), 495}, // 553 FlagIsProtected in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14042, 13), 497}, // 554 FlagIsPublic in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14195, 20), 507}, // 555 FlagLValueReference in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14139, 18), 504}, // 556 FlagObjectPointer in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14124, 15), 503}, // 557 FlagPrototyped in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14215, 20), 508}, // 558 FlagRValueReference in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14157, 17), 505}, // 559 FlagStaticMember in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14007, 5), 494}, // 560 None in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS - {IR(14372, 9), 514}, // 561 BitPiece in SPV_OPERAND_TYPE_DEBUG_OPERATION - {IR(14404, 7), 518}, // 562 Constu in SPV_OPERAND_TYPE_DEBUG_OPERATION - {IR(14311, 6), 510}, // 563 Deref in SPV_OPERAND_TYPE_DEBUG_OPERATION - {IR(14322, 6), 512}, // 564 Minus in SPV_OPERAND_TYPE_DEBUG_OPERATION - {IR(14317, 5), 511}, // 565 Plus in SPV_OPERAND_TYPE_DEBUG_OPERATION - {IR(14361, 11), 513}, // 566 PlusUconst in SPV_OPERAND_TYPE_DEBUG_OPERATION - {IR(14393, 11), 517}, // 567 StackValue in SPV_OPERAND_TYPE_DEBUG_OPERATION - {IR(14381, 5), 515}, // 568 Swap in SPV_OPERAND_TYPE_DEBUG_OPERATION - {IR(14386, 7), 516}, // 569 Xderef in SPV_OPERAND_TYPE_DEBUG_OPERATION - {IR(14420, 10), 519}, // 570 ConstType in SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER - {IR(14443, 13), 521}, // 571 RestrictType in SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER - {IR(14430, 13), 520}, // 572 VolatileType in SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER - {IR(17252, 16), 636}, // 573 AliasScopeINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15237, 8), 541}, // 574 Aliased in SPV_OPERAND_TYPE_DECORATION - {IR(16355, 15), 594}, // 575 AliasedPointer in SPV_OPERAND_TYPE_DECORATION - {IR(16370, 18), 594}, // 576 AliasedPointerEXT in SPV_OPERAND_TYPE_DECORATION - {IR(15715, 10), 565}, // 577 Alignment in SPV_OPERAND_TYPE_DECORATION - {IR(15759, 12), 567}, // 578 AlignmentId in SPV_OPERAND_TYPE_DECORATION - {IR(15088, 12), 528}, // 579 ArrayStride in SPV_OPERAND_TYPE_DECORATION - {IR(17033, 14), 624}, // 580 BankBitsINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16872, 15), 617}, // 581 BankwidthINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15392, 8), 554}, // 582 Binding in SPV_OPERAND_TYPE_DECORATION - {IR(16436, 16), 597}, // 583 BindlessImageNV in SPV_OPERAND_TYPE_DECORATION - {IR(16418, 18), 596}, // 584 BindlessSamplerNV in SPV_OPERAND_TYPE_DECORATION - {IR(15052, 6), 524}, // 585 Block in SPV_OPERAND_TYPE_DECORATION - {IR(15899, 22), 574}, // 586 BlockMatchSamplerQCOM in SPV_OPERAND_TYPE_DECORATION - {IR(15877, 22), 573}, // 587 BlockMatchTextureQCOM in SPV_OPERAND_TYPE_DECORATION - {IR(16467, 13), 599}, // 588 BoundImageNV in SPV_OPERAND_TYPE_DECORATION - {IR(16452, 15), 598}, // 589 BoundSamplerNV in SPV_OPERAND_TYPE_DECORATION - {IR(15058, 12), 525}, // 590 BufferBlock in SPV_OPERAND_TYPE_DECORATION - {IR(17345, 20), 641}, // 591 BufferLocationINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15169, 8), 533}, // 592 BuiltIn in SPV_OPERAND_TYPE_DECORATION - {IR(17115, 19), 629}, // 593 BurstCoalesceINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15135, 8), 532}, // 594 CPacked in SPV_OPERAND_TYPE_DECORATION - {IR(18138, 22), 663}, // 595 CacheControlLoadINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(18197, 23), 664}, // 596 CacheControlStoreINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17134, 15), 630}, // 597 CacheSizeINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15202, 9), 537}, // 598 Centroid in SPV_OPERAND_TYPE_DECORATION - {IR(16520, 13), 602}, // 599 ClobberINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15263, 9), 544}, // 600 Coherent in SPV_OPERAND_TYPE_DECORATION - {IR(15079, 9), 527}, // 601 ColMajor in SPV_OPERAND_TYPE_DECORATION - {IR(15376, 10), 552}, // 602 Component in SPV_OPERAND_TYPE_DECORATION - {IR(17654, 27), 651}, // 603 ConduitKernelArgumentINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15254, 9), 543}, // 604 Constant in SPV_OPERAND_TYPE_DECORATION - {IR(16666, 14), 609}, // 605 CounterBuffer in SPV_OPERAND_TYPE_DECORATION - {IR(15400, 14), 555}, // 606 DescriptorSet in SPV_OPERAND_TYPE_DECORATION - {IR(17149, 28), 631}, // 607 DontStaticallyCoalesceINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16925, 16), 620}, // 608 DoublepumpINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15921, 18), 575}, // 609 ExplicitInterpAMD in SPV_OPERAND_TYPE_DECORATION - {IR(15585, 15), 561}, // 610 FPFastMathMode in SPV_OPERAND_TYPE_DECORATION - {IR(17573, 26), 648}, // 611 FPMaxErrorDecorationINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15535, 15), 560}, // 612 FPRoundingMode in SPV_OPERAND_TYPE_DECORATION - {IR(15191, 5), 535}, // 613 Flat in SPV_OPERAND_TYPE_DECORATION - {IR(17047, 20), 625}, // 614 ForcePow2DepthINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15487, 14), 559}, // 615 FuncParamAttr in SPV_OPERAND_TYPE_DECORATION - {IR(16577, 21), 605}, // 616 FuncParamIOKindINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16808, 24), 613}, // 617 FunctionDenormModeINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17418, 31), 643}, // 618 FunctionFloatingPointModeINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16751, 26), 612}, // 619 FunctionRoundingModeINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17208, 25), 634}, // 620 FuseLoopsInFunctionINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15124, 11), 531}, // 621 GLSLPacked in SPV_OPERAND_TYPE_DECORATION - {IR(15113, 11), 530}, // 622 GLSLShared in SPV_OPERAND_TYPE_DECORATION - {IR(16640, 26), 608}, // 623 GlobalVariableOffsetINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16388, 30), 595}, // 624 HitObjectShaderRecordBufferNV in SPV_OPERAND_TYPE_DECORATION - {IR(16680, 24), 609}, // 625 HlslCounterBufferGOOGLE in SPV_OPERAND_TYPE_DECORATION - {IR(16717, 19), 610}, // 626 HlslSemanticGOOGLE in SPV_OPERAND_TYPE_DECORATION - {IR(17997, 16), 660}, // 627 HostAccessINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17365, 19), 642}, // 628 IOPipeStorageINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(18074, 28), 662}, // 629 ImplementInRegisterMapINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15386, 6), 553}, // 630 Index in SPV_OPERAND_TYPE_DECORATION - {IR(18060, 14), 661}, // 631 InitModeINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17281, 24), 638}, // 632 InitiationIntervalINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15694, 21), 564}, // 633 InputAttachmentIndex in SPV_OPERAND_TYPE_DECORATION - {IR(15218, 10), 539}, // 634 Invariant in SPV_OPERAND_TYPE_DECORATION - {IR(17624, 30), 650}, // 635 LatencyControlConstraintINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17599, 25), 649}, // 636 LatencyControlLabelINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15662, 18), 562}, // 637 LinkageAttributes in SPV_OPERAND_TYPE_DECORATION - {IR(15367, 9), 551}, // 638 Location in SPV_OPERAND_TYPE_DECORATION - {IR(17712, 33), 653}, // 639 MMHostInterfaceAddressWidthINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17745, 30), 654}, // 640 MMHostInterfaceDataWidthINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17775, 28), 655}, // 641 MMHostInterfaceLatencyINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17871, 29), 657}, // 642 MMHostInterfaceMaxBurstINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17837, 34), 656}, // 643 MMHostInterfaceReadWriteModeINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17900, 32), 658}, // 644 MMHostInterfaceWaitRequestINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17233, 19), 635}, // 645 MathOpDSPModeINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15100, 13), 529}, // 646 MatrixStride in SPV_OPERAND_TYPE_DECORATION - {IR(15725, 14), 566}, // 647 MaxByteOffset in SPV_OPERAND_TYPE_DECORATION - {IR(15771, 16), 568}, // 648 MaxByteOffsetId in SPV_OPERAND_TYPE_DECORATION - {IR(17305, 20), 639}, // 649 MaxConcurrencyINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16887, 22), 618}, // 650 MaxPrivateCopiesINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16941, 19), 621}, // 651 MaxReplicatesINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17509, 18), 646}, // 652 MediaBlockIOINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16846, 12), 615}, // 653 MemoryINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16980, 11), 623}, // 654 MergeINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17268, 13), 637}, // 655 NoAliasINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15680, 14), 563}, // 656 NoContraction in SPV_OPERAND_TYPE_DECORATION - {IR(15177, 14), 534}, // 657 NoPerspective in SPV_OPERAND_TYPE_DECORATION - {IR(15831, 13), 570}, // 658 NoSignedWrap in SPV_OPERAND_TYPE_DECORATION - {IR(15844, 15), 571}, // 659 NoUnsignedWrap in SPV_OPERAND_TYPE_DECORATION - {IR(15971, 20), 577}, // 660 NodeMaxPayloadsAMDX in SPV_OPERAND_TYPE_DECORATION - {IR(15939, 32), 576}, // 661 NodeSharesPayloadLimitsWithAMDX in SPV_OPERAND_TYPE_DECORATION - {IR(15284, 12), 546}, // 662 NonReadable in SPV_OPERAND_TYPE_DECORATION - {IR(16295, 11), 592}, // 663 NonUniform in SPV_OPERAND_TYPE_DECORATION - {IR(16306, 14), 592}, // 664 NonUniformEXT in SPV_OPERAND_TYPE_DECORATION - {IR(15272, 12), 545}, // 665 NonWritable in SPV_OPERAND_TYPE_DECORATION - {IR(16858, 14), 616}, // 666 NumbanksINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15414, 7), 556}, // 667 Offset in SPV_OPERAND_TYPE_DECORATION - {IR(16139, 19), 584}, // 668 OverrideCoverageNV in SPV_OPERAND_TYPE_DECORATION - {IR(16158, 14), 585}, // 669 PassthroughNV in SPV_OPERAND_TYPE_DECORATION - {IR(15196, 6), 536}, // 670 Patch in SPV_OPERAND_TYPE_DECORATION - {IR(16111, 28), 583}, // 671 PayloadDispatchIndirectAMDX in SPV_OPERAND_TYPE_DECORATION - {IR(16086, 25), 582}, // 672 PayloadNodeArraySizeAMDX in SPV_OPERAND_TYPE_DECORATION - {IR(16034, 25), 580}, // 673 PayloadNodeBaseIndexAMDX in SPV_OPERAND_TYPE_DECORATION - {IR(16014, 20), 579}, // 674 PayloadNodeNameAMDX in SPV_OPERAND_TYPE_DECORATION - {IR(16059, 27), 581}, // 675 PayloadNodeSparseArrayAMDX in SPV_OPERAND_TYPE_DECORATION - {IR(16219, 16), 588}, // 676 PerPrimitiveEXT in SPV_OPERAND_TYPE_DECORATION - {IR(16235, 15), 588}, // 677 PerPrimitiveNV in SPV_OPERAND_TYPE_DECORATION - {IR(16260, 10), 590}, // 678 PerTaskNV in SPV_OPERAND_TYPE_DECORATION - {IR(16270, 13), 591}, // 679 PerVertexKHR in SPV_OPERAND_TYPE_DECORATION - {IR(16283, 12), 591}, // 680 PerVertexNV in SPV_OPERAND_TYPE_DECORATION - {IR(16250, 10), 589}, // 681 PerViewNV in SPV_OPERAND_TYPE_DECORATION - {IR(17325, 20), 640}, // 682 PipelineEnableINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17177, 14), 632}, // 683 PrefetchINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16494, 26), 601}, // 684 ReferencedIndirectlyINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16832, 14), 614}, // 685 RegisterINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17681, 31), 652}, // 686 RegisterMapKernelArgumentINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15028, 17), 522}, // 687 RelaxedPrecision in SPV_OPERAND_TYPE_DECORATION - {IR(15228, 9), 540}, // 688 Restrict in SPV_OPERAND_TYPE_DECORATION - {IR(16320, 16), 593}, // 689 RestrictPointer in SPV_OPERAND_TYPE_DECORATION - {IR(16336, 19), 593}, // 690 RestrictPointerEXT in SPV_OPERAND_TYPE_DECORATION - {IR(15070, 9), 526}, // 691 RowMajor in SPV_OPERAND_TYPE_DECORATION - {IR(16480, 14), 600}, // 692 SIMTCallINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15211, 7), 538}, // 693 Sample in SPV_OPERAND_TYPE_DECORATION - {IR(15340, 20), 549}, // 694 SaturatedConversion in SPV_OPERAND_TYPE_DECORATION - {IR(15787, 44), 569}, // 695 SaturatedToLargestFloat8NormalConversionEXT in SPV_OPERAND_TYPE_DECORATION - {IR(16191, 28), 587}, // 696 SecondaryViewportRelativeNV in SPV_OPERAND_TYPE_DECORATION - {IR(16533, 17), 603}, // 697 SideEffectsINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16960, 20), 622}, // 698 SimpleDualPortINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17449, 25), 644}, // 699 SingleElementVectorINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16909, 16), 619}, // 700 SinglepumpINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15045, 7), 523}, // 701 SpecId in SPV_OPERAND_TYPE_DECORATION - {IR(17932, 26), 659}, // 702 StableKernelArgumentINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16625, 15), 607}, // 703 StackCallINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17191, 17), 633}, // 704 StallEnableINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(17527, 15), 647}, // 705 StallFreeINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15360, 7), 550}, // 706 Stream in SPV_OPERAND_TYPE_DECORATION - {IR(17067, 16), 626}, // 707 StridesizeINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15991, 23), 578}, // 708 TrackFinishWritingAMDX in SPV_OPERAND_TYPE_DECORATION - {IR(17097, 18), 628}, // 709 TrueDualPortINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15296, 8), 547}, // 710 Uniform in SPV_OPERAND_TYPE_DECORATION - {IR(15330, 10), 548}, // 711 UniformId in SPV_OPERAND_TYPE_DECORATION - {IR(16704, 13), 610}, // 712 UserSemantic in SPV_OPERAND_TYPE_DECORATION - {IR(16736, 15), 611}, // 713 UserTypeGOOGLE in SPV_OPERAND_TYPE_DECORATION - {IR(17474, 35), 645}, // 714 VectorComputeCallableFunctionINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16598, 27), 606}, // 715 VectorComputeFunctionINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16550, 27), 604}, // 716 VectorComputeVariableINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(16172, 19), 586}, // 717 ViewportRelativeNV in SPV_OPERAND_TYPE_DECORATION - {IR(15245, 9), 542}, // 718 Volatile in SPV_OPERAND_TYPE_DECORATION - {IR(15859, 18), 572}, // 719 WeightTextureQCOM in SPV_OPERAND_TYPE_DECORATION - {IR(17083, 14), 627}, // 720 WordsizeINTEL in SPV_OPERAND_TYPE_DECORATION - {IR(15421, 10), 557}, // 721 XfbBuffer in SPV_OPERAND_TYPE_DECORATION - {IR(15431, 10), 558}, // 722 XfbStride in SPV_OPERAND_TYPE_DECORATION - {IR(18220, 3), 665}, // 723 1D in SPV_OPERAND_TYPE_DIMENSIONALITY - {IR(18223, 3), 666}, // 724 2D in SPV_OPERAND_TYPE_DIMENSIONALITY - {IR(18226, 3), 667}, // 725 3D in SPV_OPERAND_TYPE_DIMENSIONALITY - {IR(18239, 7), 670}, // 726 Buffer in SPV_OPERAND_TYPE_DIMENSIONALITY - {IR(18229, 5), 668}, // 727 Cube in SPV_OPERAND_TYPE_DIMENSIONALITY - {IR(18234, 5), 669}, // 728 Rect in SPV_OPERAND_TYPE_DIMENSIONALITY - {IR(18246, 12), 671}, // 729 SubpassData in SPV_OPERAND_TYPE_DIMENSIONALITY - {IR(18258, 17), 672}, // 730 TileImageDataEXT in SPV_OPERAND_TYPE_DIMENSIONALITY - {IR(19070, 15), 725}, // 731 CoalescingAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18701, 15), 703}, // 732 ContractionOff in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(9485, 18), 717}, // 733 DenormFlushToZero in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(9470, 15), 716}, // 734 DenormPreserve in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18471, 13), 686}, // 735 DepthGreater in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18484, 10), 687}, // 736 DepthLess in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18456, 15), 685}, // 737 DepthReplacing in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18494, 15), 688}, // 738 DepthUnchanged in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19491, 25), 743}, // 739 DerivativeGroupLinearKHR in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19516, 24), 743}, // 740 DerivativeGroupLinearNV in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19444, 24), 742}, // 741 DerivativeGroupQuadsKHR in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19468, 23), 742}, // 742 DerivativeGroupQuadsNV in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19018, 29), 723}, // 743 EarlyAndLateFragmentTestsAMD in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18423, 19), 682}, // 744 EarlyFragmentTests in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(20001, 18), 762}, // 745 FPFastMathDefault in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18728, 10), 705}, // 746 Finalizer in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19816, 26), 754}, // 747 FloatingPointModeALTINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19842, 27), 755}, // 748 FloatingPointModeIEEEINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18716, 12), 704}, // 749 Initializer in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18545, 11), 692}, // 750 InputLines in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18556, 20), 693}, // 751 InputLinesAdjacency in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18533, 12), 691}, // 752 InputPoints in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18586, 24), 695}, // 753 InputTrianglesAdjacency in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18275, 12), 673}, // 754 Invocations in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19085, 15), 726}, // 755 IsApiEntryAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18616, 9), 697}, // 756 Isolines in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18509, 10), 689}, // 757 LocalSize in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18519, 14), 690}, // 758 LocalSizeHint in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18796, 16), 710}, // 759 LocalSizeHintId in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18784, 12), 709}, // 760 LocalSizeId in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19100, 21), 727}, // 761 MaxNodeRecursionAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19145, 21), 730}, // 762 MaxNumWorkgroupsAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19891, 16), 757}, // 763 MaxWorkDimINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19869, 22), 756}, // 764 MaxWorkgroupSizeINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19977, 24), 761}, // 765 MaximallyReconvergesKHR in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(20092, 22), 766}, // 766 MaximumRegistersINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(20114, 24), 767}, // 767 MaximumRegistersIdINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(20069, 23), 765}, // 768 NamedBarrierCountINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(20189, 27), 768}, // 769 NamedMaximumRegistersINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19907, 20), 758}, // 770 NoGlobalOffsetINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18812, 34), 711}, // 771 NonCoherentColorAttachmentReadEXT in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18846, 34), 712}, // 772 NonCoherentDepthAttachmentReadEXT in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18880, 36), 713}, // 773 NonCoherentStencilAttachmentReadEXT in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18964, 34), 721}, // 774 NonCoherentTileAttachmentReadQCOM in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19927, 22), 759}, // 775 NumSIMDWorkitemsINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18407, 16), 681}, // 776 OriginLowerLeft in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18391, 16), 680}, // 777 OriginUpperLeft in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18653, 16), 700}, // 778 OutputLineStrip in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19376, 15), 740}, // 779 OutputLinesEXT in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19391, 14), 740}, // 780 OutputLinesNV in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18640, 13), 699}, // 781 OutputPoints in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19405, 20), 741}, // 782 OutputPrimitivesEXT in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19425, 19), 741}, // 783 OutputPrimitivesNV in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18669, 20), 701}, // 784 OutputTriangleStrip in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19540, 19), 744}, // 785 OutputTrianglesEXT in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19559, 18), 744}, // 786 OutputTrianglesNV in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18625, 15), 698}, // 787 OutputVertices in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18372, 19), 679}, // 788 PixelCenterInteger in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19577, 25), 745}, // 789 PixelInterlockOrderedEXT in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19602, 27), 746}, // 790 PixelInterlockUnorderedEXT in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18442, 10), 683}, // 791 PointMode in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18946, 18), 715}, // 792 PostDepthCoverage in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19317, 19), 737}, // 793 QuadDerivativesKHR in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18610, 6), 696}, // 794 Quads in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(20043, 26), 764}, // 795 RegisterMapInterfaceINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19336, 20), 738}, // 796 RequireFullQuadsKHR in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(9528, 16), 719}, // 797 RoundingModeRTE in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19795, 21), 753}, // 798 RoundingModeRTNINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19774, 21), 752}, // 799 RoundingModeRTPINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(9544, 16), 720}, // 800 RoundingModeRTZ in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19629, 26), 747}, // 801 SampleInterlockOrderedEXT in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19655, 28), 748}, // 802 SampleInterlockUnorderedEXT in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19949, 28), 760}, // 803 SchedulerTargetFmaxMhzINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(6194, 16), 729}, // 804 ShaderIndexAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19683, 31), 749}, // 805 ShadingRateInterlockOrderedEXT in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19714, 33), 750}, // 806 ShadingRateInterlockUnorderedEXT in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19747, 27), 751}, // 807 SharedLocalMemorySizeINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19356, 20), 739}, // 808 SharesInputWithAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(9503, 25), 718}, // 809 SignedZeroInfNanPreserve in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18287, 13), 674}, // 810 SpacingEqual in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18300, 22), 675}, // 811 SpacingFractionalEven in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18322, 21), 676}, // 812 SpacingFractionalOdd in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19121, 24), 728}, // 813 StaticNumWorkgroupsAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19270, 25), 735}, // 814 StencilRefGreaterBackAMD in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19194, 26), 732}, // 815 StencilRefGreaterFrontAMD in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19295, 22), 736}, // 816 StencilRefLessBackAMD in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19220, 23), 733}, // 817 StencilRefLessFrontAMD in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19047, 23), 724}, // 818 StencilRefReplacingEXT in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19243, 27), 734}, // 819 StencilRefUnchangedBackAMD in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(19166, 28), 731}, // 820 StencilRefUnchangedFrontAMD in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(20019, 24), 763}, // 821 StreamingInterfaceINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(5301, 13), 706}, // 822 SubgroupSize in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18916, 30), 714}, // 823 SubgroupUniformControlFlowKHR in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18738, 22), 707}, // 824 SubgroupsPerWorkgroup in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18760, 24), 708}, // 825 SubgroupsPerWorkgroupId in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18998, 20), 722}, // 826 TileShadingRateQCOM in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18576, 10), 694}, // 827 Triangles in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18689, 12), 702}, // 828 VecTypeHint in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18357, 15), 678}, // 829 VertexOrderCcw in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18343, 14), 677}, // 830 VertexOrderCw in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(18452, 4), 684}, // 831 Xfb in SPV_OPERAND_TYPE_EXECUTION_MODE - {IR(20354, 10), 780}, // 832 AnyHitKHR in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20364, 9), 780}, // 833 AnyHitNV in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20415, 12), 783}, // 834 CallableKHR in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20427, 11), 783}, // 835 CallableNV in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20373, 14), 781}, // 836 ClosestHitKHR in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20387, 13), 781}, // 837 ClosestHitNV in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(14411, 9), 773}, // 838 Fragment in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20266, 10), 774}, // 839 GLCompute in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(4782, 9), 772}, // 840 Geometry in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20323, 16), 779}, // 841 IntersectionKHR in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20339, 15), 779}, // 842 IntersectionNV in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(4549, 7), 775}, // 843 Kernel in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20446, 8), 785}, // 844 MeshEXT in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20283, 7), 777}, // 845 MeshNV in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20400, 8), 782}, // 846 MissKHR in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20408, 7), 782}, // 847 MissNV in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20290, 17), 778}, // 848 RayGenerationKHR in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20307, 16), 778}, // 849 RayGenerationNV in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20438, 8), 784}, // 850 TaskEXT in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20276, 7), 776}, // 851 TaskNV in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20223, 20), 770}, // 852 TessellationControl in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20243, 23), 771}, // 853 TessellationEvaluation in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20216, 7), 769}, // 854 Vertex in SPV_OPERAND_TYPE_EXECUTION_MODEL - {IR(20463, 12), 787}, // 855 FlushToZero in SPV_OPERAND_TYPE_FPDENORM_MODE - {IR(20454, 9), 786}, // 856 Preserve in SPV_OPERAND_TYPE_FPDENORM_MODE - {IR(20475, 12), 788}, // 857 BFloat16KHR in SPV_OPERAND_TYPE_FPENCODING - {IR(20487, 14), 789}, // 858 Float8E4M3EXT in SPV_OPERAND_TYPE_FPENCODING - {IR(20501, 14), 790}, // 859 Float8E5M2EXT in SPV_OPERAND_TYPE_FPENCODING - {IR(20520, 4), 792}, // 860 ALT in SPV_OPERAND_TYPE_FPOPERATION_MODE - {IR(20515, 5), 791}, // 861 IEEE in SPV_OPERAND_TYPE_FPOPERATION_MODE - {IR(20558, 14), 799}, // 862 AllowContract in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {IR(20572, 23), 799}, // 863 AllowContractFastINTEL in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {IR(20595, 13), 800}, // 864 AllowReassoc in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {IR(20608, 18), 800}, // 865 AllowReassocINTEL in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {IR(20542, 11), 797}, // 866 AllowRecip in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {IR(20626, 15), 801}, // 867 AllowTransform in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {IR(20553, 5), 798}, // 868 Fast in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {IR(20538, 4), 796}, // 869 NSZ in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {IR(14007, 5), 793}, // 870 None in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {IR(20531, 7), 795}, // 871 NotInf in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {IR(20524, 7), 794}, // 872 NotNaN in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE - {IR(20641, 4), 802}, // 873 RTE in SPV_OPERAND_TYPE_FP_ROUNDING_MODE - {IR(20653, 4), 805}, // 874 RTN in SPV_OPERAND_TYPE_FP_ROUNDING_MODE - {IR(20649, 4), 804}, // 875 RTP in SPV_OPERAND_TYPE_FP_ROUNDING_MODE - {IR(20645, 4), 803}, // 876 RTZ in SPV_OPERAND_TYPE_FP_ROUNDING_MODE - {IR(20689, 18), 808}, // 877 Horizontal2Pixels in SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE - {IR(20707, 18), 809}, // 878 Horizontal4Pixels in SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE - {IR(20657, 16), 806}, // 879 Vertical2Pixels in SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE - {IR(20673, 16), 807}, // 880 Vertical4Pixels in SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE - {IR(20748, 6), 814}, // 881 Const in SPV_OPERAND_TYPE_FUNCTION_CONTROL - {IR(20732, 11), 812}, // 882 DontInline in SPV_OPERAND_TYPE_FUNCTION_CONTROL - {IR(20725, 7), 811}, // 883 Inline in SPV_OPERAND_TYPE_FUNCTION_CONTROL - {IR(14007, 5), 810}, // 884 None in SPV_OPERAND_TYPE_FUNCTION_CONTROL - {IR(13228, 11), 815}, // 885 OptNoneEXT in SPV_OPERAND_TYPE_FUNCTION_CONTROL - {IR(13239, 13), 815}, // 886 OptNoneINTEL in SPV_OPERAND_TYPE_FUNCTION_CONTROL - {IR(20743, 5), 813}, // 887 Pure in SPV_OPERAND_TYPE_FUNCTION_CONTROL - {IR(20764, 6), 818}, // 888 ByVal in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {IR(20775, 8), 820}, // 889 NoAlias in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {IR(20783, 10), 821}, // 890 NoCapture in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {IR(20801, 12), 823}, // 891 NoReadWrite in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {IR(20793, 8), 822}, // 892 NoWrite in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {IR(20813, 20), 824}, // 893 RuntimeAlignedINTEL in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {IR(20759, 5), 817}, // 894 Sext in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {IR(20770, 5), 819}, // 895 Sret in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {IR(20754, 5), 816}, // 896 Zext in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE - {IR(20868, 16), 828}, // 897 ClusteredReduce in SPV_OPERAND_TYPE_GROUP_OPERATION - {IR(20854, 14), 827}, // 898 ExclusiveScan in SPV_OPERAND_TYPE_GROUP_OPERATION - {IR(20840, 14), 826}, // 899 InclusiveScan in SPV_OPERAND_TYPE_GROUP_OPERATION - {IR(20931, 27), 831}, // 900 PartitionedExclusiveScanNV in SPV_OPERAND_TYPE_GROUP_OPERATION - {IR(20904, 27), 830}, // 901 PartitionedInclusiveScanNV in SPV_OPERAND_TYPE_GROUP_OPERATION - {IR(20884, 20), 829}, // 902 PartitionedReduceNV in SPV_OPERAND_TYPE_GROUP_OPERATION - {IR(20833, 7), 825}, // 903 Reduce in SPV_OPERAND_TYPE_GROUP_OPERATION - {IR(20958, 10), 832}, // 904 NoneINTEL in SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER - {IR(20968, 10), 833}, // 905 ReadINTEL in SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER - {IR(20989, 15), 835}, // 906 ReadWriteINTEL in SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER - {IR(20978, 11), 834}, // 907 WriteINTEL in SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER - {IR(21004, 5), 837}, // 908 Bias in SPV_OPERAND_TYPE_IMAGE - {IR(21018, 12), 840}, // 909 ConstOffset in SPV_OPERAND_TYPE_IMAGE - {IR(21030, 13), 842}, // 910 ConstOffsets in SPV_OPERAND_TYPE_IMAGE - {IR(21013, 5), 839}, // 911 Grad in SPV_OPERAND_TYPE_IMAGE - {IR(21009, 4), 838}, // 912 Lod in SPV_OPERAND_TYPE_IMAGE - {IR(21043, 19), 845}, // 913 MakeTexelAvailable in SPV_OPERAND_TYPE_IMAGE - {IR(21062, 22), 845}, // 914 MakeTexelAvailableKHR in SPV_OPERAND_TYPE_IMAGE - {IR(21084, 17), 846}, // 915 MakeTexelVisible in SPV_OPERAND_TYPE_IMAGE - {IR(21101, 20), 846}, // 916 MakeTexelVisibleKHR in SPV_OPERAND_TYPE_IMAGE - {IR(8333, 7), 844}, // 917 MinLod in SPV_OPERAND_TYPE_IMAGE - {IR(21121, 16), 847}, // 918 NonPrivateTexel in SPV_OPERAND_TYPE_IMAGE - {IR(21137, 19), 847}, // 919 NonPrivateTexelKHR in SPV_OPERAND_TYPE_IMAGE - {IR(14007, 5), 836}, // 920 None in SPV_OPERAND_TYPE_IMAGE - {IR(21209, 12), 851}, // 921 Nontemporal in SPV_OPERAND_TYPE_IMAGE - {IR(15414, 7), 841}, // 922 Offset in SPV_OPERAND_TYPE_IMAGE - {IR(21221, 8), 852}, // 923 Offsets in SPV_OPERAND_TYPE_IMAGE - {IR(15211, 7), 843}, // 924 Sample in SPV_OPERAND_TYPE_IMAGE - {IR(21187, 11), 849}, // 925 SignExtend in SPV_OPERAND_TYPE_IMAGE - {IR(21156, 14), 848}, // 926 VolatileTexel in SPV_OPERAND_TYPE_IMAGE - {IR(21170, 17), 848}, // 927 VolatileTexelKHR in SPV_OPERAND_TYPE_IMAGE - {IR(21198, 11), 850}, // 928 ZeroExtend in SPV_OPERAND_TYPE_IMAGE - {IR(13904, 6), 867}, // 929 Float in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21390, 10), 866}, // 930 HalfFloat in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21325, 12), 861}, // 931 SignedInt16 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21337, 12), 862}, // 932 SignedInt32 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21314, 11), 860}, // 933 SignedInt8 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21239, 11), 854}, // 934 SnormInt16 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21229, 10), 853}, // 935 SnormInt8 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21299, 15), 859}, // 936 UnormInt101010 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21411, 17), 869}, // 937 UnormInt101010_2 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21428, 16), 870}, // 938 UnormInt10X6EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21561, 16), 877}, // 939 UnormInt12X4EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21577, 16), 878}, // 940 UnormInt14X2EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21260, 11), 856}, // 941 UnormInt16 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21400, 11), 868}, // 942 UnormInt24 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21484, 20), 873}, // 943 UnormInt2_101010EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21250, 10), 855}, // 944 UnormInt8 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21285, 14), 858}, // 945 UnormShort555 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21271, 14), 857}, // 946 UnormShort565 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21504, 19), 874}, // 947 UnsignedInt10X6EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21523, 19), 875}, // 948 UnsignedInt12X4EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21542, 19), 876}, // 949 UnsignedInt14X2EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21362, 14), 864}, // 950 UnsignedInt16 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21376, 14), 865}, // 951 UnsignedInt32 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21349, 13), 863}, // 952 UnsignedInt8 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21444, 20), 871}, // 953 UnsignedIntRaw10EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21464, 20), 872}, // 954 UnsignedIntRaw12EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE - {IR(21595, 2), 880}, // 955 A in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21696, 5), 898}, // 956 ABGR in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21617, 5), 886}, // 957 ARGB in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21612, 5), 885}, // 958 BGRA in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21654, 6), 892}, // 959 Depth in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21660, 13), 893}, // 960 DepthStencil in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21622, 10), 887}, // 961 Intensity in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21632, 10), 888}, // 962 Luminance in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21593, 2), 879}, // 963 R in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21600, 3), 882}, // 964 RA in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21597, 3), 881}, // 965 RG in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21603, 4), 883}, // 966 RGB in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21607, 5), 884}, // 967 RGBA in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21649, 5), 891}, // 968 RGBx in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21645, 4), 890}, // 969 RGx in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21642, 3), 889}, // 970 Rx in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21690, 6), 897}, // 971 sBGRA in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21673, 5), 894}, // 972 sRGB in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21684, 6), 896}, // 973 sRGBA in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21678, 6), 895}, // 974 sRGBx in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER - {IR(21701, 27), 899}, // 975 InitOnDeviceReprogramINTEL in SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER - {IR(21728, 23), 900}, // 976 InitOnDeviceResetINTEL in SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER - {IR(21751, 7), 901}, // 977 NoWait in SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS - {IR(21758, 11), 902}, // 978 WaitKernel in SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS - {IR(21769, 14), 903}, // 979 WaitWorkGroup in SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS - {IR(21783, 12), 905}, // 980 CmdExecTime in SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO - {IR(14007, 5), 904}, // 981 None in SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO - {IR(21795, 13), 907}, // 982 MayUsePrintf in SPV_OPERAND_TYPE_KERNEL_PROPERTY_FLAGS - {IR(14007, 5), 906}, // 983 None in SPV_OPERAND_TYPE_KERNEL_PROPERTY_FLAGS - {IR(21808, 7), 908}, // 984 Export in SPV_OPERAND_TYPE_LINKAGE_TYPE - {IR(21815, 7), 909}, // 985 Import in SPV_OPERAND_TYPE_LINKAGE_TYPE - {IR(21822, 12), 910}, // 986 LinkOnceODR in SPV_OPERAND_TYPE_LINKAGE_TYPE - {IR(21848, 12), 912}, // 987 CachedINTEL in SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL - {IR(21900, 17), 915}, // 988 ConstCachedINTEL in SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL - {IR(21875, 25), 914}, // 989 InvalidateAfterReadINTEL in SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL - {IR(21860, 15), 913}, // 990 StreamingINTEL in SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL - {IR(21834, 14), 911}, // 991 UncachedINTEL in SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL - {IR(22040, 21), 928}, // 992 DependencyArrayINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(21935, 19), 919}, // 993 DependencyInfinite in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(21954, 17), 920}, // 994 DependencyLength in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(21924, 11), 918}, // 995 DontUnroll in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(17281, 24), 926}, // 996 InitiationIntervalINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(21999, 18), 923}, // 997 IterationMultiple in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(22061, 18), 930}, // 998 LoopCoalesceINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(22140, 15), 934}, // 999 LoopCountINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(17305, 20), 927}, // 1000 MaxConcurrencyINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(22079, 21), 931}, // 1001 MaxInterleavingINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(21985, 14), 922}, // 1002 MaxIterations in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(22155, 26), 935}, // 1003 MaxReinvocationDelayINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(21971, 14), 921}, // 1004 MinIterations in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(22126, 14), 933}, // 1005 NoFusionINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(14007, 5), 916}, // 1006 None in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(22027, 13), 925}, // 1007 PartialCount in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(22017, 10), 924}, // 1008 PeelCount in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(17325, 20), 929}, // 1009 PipelineEnableINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(22100, 26), 932}, // 1010 SpeculatedIterationsINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(21917, 7), 917}, // 1011 Unroll in SPV_OPERAND_TYPE_LOOP_CONTROL - {IR(22464, 27), 949}, // 1012 MatrixAPackedBFloat16INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22412, 26), 947}, // 1013 MatrixAPackedFloat16INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22332, 23), 943}, // 1014 MatrixAPackedInt4INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22286, 23), 941}, // 1015 MatrixAPackedInt8INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22181, 29), 937}, // 1016 MatrixASignedComponentsINTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22378, 17), 945}, // 1017 MatrixATF32INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22491, 27), 950}, // 1018 MatrixBPackedBFloat16INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22438, 26), 948}, // 1019 MatrixBPackedFloat16INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22355, 23), 944}, // 1020 MatrixBPackedInt4INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22309, 23), 942}, // 1021 MatrixBPackedInt8INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22210, 29), 938}, // 1022 MatrixBSignedComponentsINTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22395, 17), 946}, // 1023 MatrixBTF32INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22239, 21), 939}, // 1024 MatrixCBFloat16INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22260, 26), 940}, // 1025 MatrixResultBFloat16INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(14007, 5), 936}, // 1026 None in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS - {IR(22651, 20), 958}, // 1027 AliasScopeINTELMask in SPV_OPERAND_TYPE_MEMORY_ACCESS - {IR(22518, 8), 953}, // 1028 Aligned in SPV_OPERAND_TYPE_MEMORY_ACCESS - {IR(22526, 21), 955}, // 1029 MakePointerAvailable in SPV_OPERAND_TYPE_MEMORY_ACCESS - {IR(22547, 24), 955}, // 1030 MakePointerAvailableKHR in SPV_OPERAND_TYPE_MEMORY_ACCESS - {IR(22571, 19), 956}, // 1031 MakePointerVisible in SPV_OPERAND_TYPE_MEMORY_ACCESS - {IR(22590, 22), 956}, // 1032 MakePointerVisibleKHR in SPV_OPERAND_TYPE_MEMORY_ACCESS - {IR(22671, 17), 959}, // 1033 NoAliasINTELMask in SPV_OPERAND_TYPE_MEMORY_ACCESS - {IR(22612, 18), 957}, // 1034 NonPrivatePointer in SPV_OPERAND_TYPE_MEMORY_ACCESS - {IR(22630, 21), 957}, // 1035 NonPrivatePointerKHR in SPV_OPERAND_TYPE_MEMORY_ACCESS - {IR(14007, 5), 951}, // 1036 None in SPV_OPERAND_TYPE_MEMORY_ACCESS - {IR(21209, 12), 954}, // 1037 Nontemporal in SPV_OPERAND_TYPE_MEMORY_ACCESS - {IR(15245, 9), 952}, // 1038 Volatile in SPV_OPERAND_TYPE_MEMORY_ACCESS - {IR(22695, 8), 961}, // 1039 GLSL450 in SPV_OPERAND_TYPE_MEMORY_MODEL - {IR(22703, 7), 962}, // 1040 OpenCL in SPV_OPERAND_TYPE_MEMORY_MODEL - {IR(22688, 7), 960}, // 1041 Simple in SPV_OPERAND_TYPE_MEMORY_MODEL - {IR(22710, 7), 963}, // 1042 Vulkan in SPV_OPERAND_TYPE_MEMORY_MODEL - {IR(22717, 10), 963}, // 1043 VulkanKHR in SPV_OPERAND_TYPE_MEMORY_MODEL - {IR(22735, 8), 965}, // 1044 Acquire in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22751, 15), 967}, // 1045 AcquireRelease in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22855, 20), 973}, // 1046 AtomicCounterMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22834, 21), 972}, // 1047 CrossWorkgroupMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22875, 12), 974}, // 1048 ImageMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22916, 14), 976}, // 1049 MakeAvailable in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22930, 17), 976}, // 1050 MakeAvailableKHR in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22947, 12), 977}, // 1051 MakeVisible in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22959, 15), 977}, // 1052 MakeVisibleKHR in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(14007, 5), 964}, // 1053 None in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22887, 13), 975}, // 1054 OutputMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22900, 16), 975}, // 1055 OutputMemoryKHR in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22727, 8), 964}, // 1056 Relaxed in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22743, 8), 966}, // 1057 Release in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22766, 23), 968}, // 1058 SequentiallyConsistent in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22803, 15), 970}, // 1059 SubgroupMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22789, 14), 969}, // 1060 UniformMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(15245, 9), 978}, // 1061 Volatile in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22818, 16), 971}, // 1062 WorkgroupMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID - {IR(22974, 10), 979}, // 1063 AutoINTEL in SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS - {IR(22989, 4), 981}, // 1064 SAT in SPV_OPERAND_TYPE_OVERFLOW_MODES - {IR(23002, 8), 983}, // 1065 SAT_SYM in SPV_OPERAND_TYPE_OVERFLOW_MODES - {IR(22993, 9), 982}, // 1066 SAT_ZERO in SPV_OPERAND_TYPE_OVERFLOW_MODES - {IR(22984, 5), 980}, // 1067 WRAP in SPV_OPERAND_TYPE_OVERFLOW_MODES - {IR(23010, 25), 984}, // 1068 PackedVectorFormat4x8Bit in SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT - {IR(23035, 28), 984}, // 1069 PackedVectorFormat4x8BitKHR in SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT - {IR(23076, 4), 987}, // 1070 RND in SPV_OPERAND_TYPE_QUANTIZATION_MODES - {IR(23109, 9), 991}, // 1071 RND_CONV in SPV_OPERAND_TYPE_QUANTIZATION_MODES - {IR(23118, 13), 992}, // 1072 RND_CONV_ODD in SPV_OPERAND_TYPE_QUANTIZATION_MODES - {IR(23089, 8), 989}, // 1073 RND_INF in SPV_OPERAND_TYPE_QUANTIZATION_MODES - {IR(23097, 12), 990}, // 1074 RND_MIN_INF in SPV_OPERAND_TYPE_QUANTIZATION_MODES - {IR(23080, 9), 988}, // 1075 RND_ZERO in SPV_OPERAND_TYPE_QUANTIZATION_MODES - {IR(23063, 4), 985}, // 1076 TRN in SPV_OPERAND_TYPE_QUANTIZATION_MODES - {IR(23067, 9), 986}, // 1077 TRN_ZERO in SPV_OPERAND_TYPE_QUANTIZATION_MODES - {IR(14007, 5), 993}, // 1078 None in SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS - {IR(23131, 25), 994}, // 1079 RobustnessPerComponentNV in SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS - {IR(23156, 23), 995}, // 1080 RobustnessPerElementNV in SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS - {IR(23248, 27), 1001}, // 1081 CullBackFacingTrianglesKHR in SPV_OPERAND_TYPE_RAY_FLAGS - {IR(23275, 28), 1002}, // 1082 CullFrontFacingTrianglesKHR in SPV_OPERAND_TYPE_RAY_FLAGS - {IR(23317, 16), 1004}, // 1083 CullNoOpaqueKHR in SPV_OPERAND_TYPE_RAY_FLAGS - {IR(23303, 14), 1003}, // 1084 CullOpaqueKHR in SPV_OPERAND_TYPE_RAY_FLAGS - {IR(23387, 30), 1007}, // 1085 ForceOpacityMicromap2StateEXT in SPV_OPERAND_TYPE_RAY_FLAGS - {IR(23189, 12), 998}, // 1086 NoOpaqueKHR in SPV_OPERAND_TYPE_RAY_FLAGS - {IR(14759, 8), 996}, // 1087 NoneKHR in SPV_OPERAND_TYPE_RAY_FLAGS - {IR(23179, 10), 997}, // 1088 OpaqueKHR in SPV_OPERAND_TYPE_RAY_FLAGS - {IR(23374, 13), 1006}, // 1089 SkipAABBsKHR in SPV_OPERAND_TYPE_RAY_FLAGS - {IR(23350, 24), 1005}, // 1090 SkipBuiltinPrimitivesNV in SPV_OPERAND_TYPE_RAY_FLAGS - {IR(23224, 24), 1000}, // 1091 SkipClosestHitShaderKHR in SPV_OPERAND_TYPE_RAY_FLAGS - {IR(23333, 17), 1005}, // 1092 SkipTrianglesKHR in SPV_OPERAND_TYPE_RAY_FLAGS - {IR(23201, 23), 999}, // 1093 TerminateOnFirstHitKHR in SPV_OPERAND_TYPE_RAY_FLAGS - {IR(23458, 37), 1009}, // 1094 RayQueryCandidateIntersectionAABBKHR in SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE - {IR(23417, 41), 1008}, // 1095 RayQueryCandidateIntersectionTriangleKHR in SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE - {IR(23573, 42), 1012}, // 1096 RayQueryCommittedIntersectionGeneratedKHR in SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE - {IR(23495, 37), 1010}, // 1097 RayQueryCommittedIntersectionNoneKHR in SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE - {IR(23532, 41), 1011}, // 1098 RayQueryCommittedIntersectionTriangleKHR in SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE - {IR(23615, 33), 1013}, // 1099 RayQueryCandidateIntersectionKHR in SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION - {IR(23648, 33), 1014}, // 1100 RayQueryCommittedIntersectionKHR in SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION - {IR(23693, 6), 1017}, // 1101 Clamp in SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE - {IR(23681, 12), 1016}, // 1102 ClampToEdge in SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE - {IR(14007, 5), 1015}, // 1103 None in SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE - {IR(23699, 7), 1018}, // 1104 Repeat in SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE - {IR(23706, 15), 1019}, // 1105 RepeatMirrored in SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE - {IR(23729, 7), 1021}, // 1106 Linear in SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE - {IR(23721, 8), 1020}, // 1107 Nearest in SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE - {IR(23794, 13), 1030}, // 1108 R11fG11fB10f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23836, 4), 1036}, // 1109 R16 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23874, 9), 1041}, // 1110 R16Snorm in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23807, 5), 1031}, // 1111 R16f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23936, 5), 1050}, // 1112 R16i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(24007, 6), 1060}, // 1113 R16ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23760, 5), 1025}, // 1114 R32f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23914, 5), 1046}, // 1115 R32i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23971, 6), 1055}, // 1116 R32ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(24024, 5), 1063}, // 1117 R64i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(24018, 6), 1062}, // 1118 R64ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23840, 3), 1037}, // 1119 R8 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23883, 8), 1042}, // 1120 R8Snorm in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23941, 4), 1051}, // 1121 R8i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(24013, 5), 1061}, // 1122 R8ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23827, 5), 1034}, // 1123 Rg16 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23855, 10), 1039}, // 1124 Rg16Snorm in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23788, 6), 1029}, // 1125 Rg16f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23925, 6), 1048}, // 1126 Rg16i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23994, 7), 1058}, // 1127 Rg16ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23782, 6), 1028}, // 1128 Rg32f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23919, 6), 1047}, // 1129 Rg32i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23987, 7), 1057}, // 1130 Rg32ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23832, 4), 1035}, // 1131 Rg8 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23865, 9), 1040}, // 1132 Rg8Snorm in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23931, 5), 1049}, // 1133 Rg8i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(24001, 6), 1059}, // 1134 Rg8ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23819, 8), 1033}, // 1135 Rgb10A2 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23977, 10), 1056}, // 1136 Rgb10a2ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23812, 7), 1032}, // 1137 Rgba16 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23843, 12), 1038}, // 1138 Rgba16Snorm in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23752, 8), 1024}, // 1139 Rgba16f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23899, 8), 1044}, // 1140 Rgba16i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23954, 9), 1053}, // 1141 Rgba16ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23744, 8), 1023}, // 1142 Rgba32f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23891, 8), 1043}, // 1143 Rgba32i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23945, 9), 1052}, // 1144 Rgba32ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23765, 6), 1026}, // 1145 Rgba8 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23771, 11), 1027}, // 1146 Rgba8Snorm in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23907, 7), 1045}, // 1147 Rgba8i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23963, 8), 1054}, // 1148 Rgba8ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(23736, 8), 1022}, // 1149 Unknown in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT - {IR(24029, 12), 1064}, // 1150 CrossDevice in SPV_OPERAND_TYPE_SCOPE_ID - {IR(24041, 7), 1065}, // 1151 Device in SPV_OPERAND_TYPE_SCOPE_ID - {IR(24067, 11), 1068}, // 1152 Invocation in SPV_OPERAND_TYPE_SCOPE_ID - {IR(24078, 12), 1069}, // 1153 QueueFamily in SPV_OPERAND_TYPE_SCOPE_ID - {IR(24090, 15), 1069}, // 1154 QueueFamilyKHR in SPV_OPERAND_TYPE_SCOPE_ID - {IR(24105, 14), 1070}, // 1155 ShaderCallKHR in SPV_OPERAND_TYPE_SCOPE_ID - {IR(24058, 9), 1067}, // 1156 Subgroup in SPV_OPERAND_TYPE_SCOPE_ID - {IR(24048, 10), 1066}, // 1157 Workgroup in SPV_OPERAND_TYPE_SCOPE_ID - {IR(24127, 12), 1073}, // 1158 DontFlatten in SPV_OPERAND_TYPE_SELECTION_CONTROL - {IR(24119, 8), 1072}, // 1159 Flatten in SPV_OPERAND_TYPE_SELECTION_CONTROL - {IR(14007, 5), 1071}, // 1160 None in SPV_OPERAND_TYPE_SELECTION_CONTROL - {IR(24139, 29), 1074}, // 1161 IdentifierPossibleDuplicates in SPV_OPERAND_TYPE_SHDEBUG100_BUILD_IDENTIFIER_FLAGS - {IR(13888, 8), 1076}, // 1162 Address in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13896, 8), 1077}, // 1163 Boolean in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13904, 6), 1078}, // 1164 Float in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13910, 7), 1079}, // 1165 Signed in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13917, 11), 1080}, // 1166 SignedChar in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13928, 9), 1081}, // 1167 Unsigned in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13937, 13), 1082}, // 1168 UnsignedChar in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13876, 12), 1075}, // 1169 Unspecified in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING - {IR(13950, 6), 1083}, // 1170 Class in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE - {IR(13956, 10), 1084}, // 1171 Structure in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE - {IR(13966, 6), 1085}, // 1172 Union in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE - {IR(13987, 20), 1087}, // 1173 ImportedDeclaration in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_IMPORTED_ENTITY - {IR(13972, 15), 1086}, // 1174 ImportedModule in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_IMPORTED_ENTITY - {IR(14096, 15), 1095}, // 1175 FlagArtificial in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14111, 13), 1096}, // 1176 FlagExplicit in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14084, 12), 1094}, // 1177 FlagFwdDecl in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14174, 21), 1100}, // 1178 FlagIndirectVariable in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14067, 17), 1093}, // 1179 FlagIsDefinition in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14251, 16), 1104}, // 1180 FlagIsEnumClass in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14055, 12), 1092}, // 1181 FlagIsLocal in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14235, 16), 1103}, // 1182 FlagIsOptimized in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14028, 14), 1090}, // 1183 FlagIsPrivate in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14012, 16), 1089}, // 1184 FlagIsProtected in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14042, 13), 1091}, // 1185 FlagIsPublic in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14195, 20), 1101}, // 1186 FlagLValueReference in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14139, 18), 1098}, // 1187 FlagObjectPointer in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14124, 15), 1097}, // 1188 FlagPrototyped in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14215, 20), 1102}, // 1189 FlagRValueReference in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14157, 17), 1099}, // 1190 FlagStaticMember in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14287, 24), 1106}, // 1191 FlagTypePassByReference in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14267, 20), 1105}, // 1192 FlagTypePassByValue in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(24168, 26), 1107}, // 1193 FlagUnknownPhysicalLayout in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14007, 5), 1088}, // 1194 None in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS - {IR(14372, 9), 1112}, // 1195 BitPiece in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {IR(14404, 7), 1116}, // 1196 Constu in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {IR(14311, 6), 1108}, // 1197 Deref in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {IR(14411, 9), 1117}, // 1198 Fragment in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {IR(14322, 6), 1110}, // 1199 Minus in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {IR(14317, 5), 1109}, // 1200 Plus in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {IR(14361, 11), 1111}, // 1201 PlusUconst in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {IR(14393, 11), 1115}, // 1202 StackValue in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {IR(14381, 5), 1113}, // 1203 Swap in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {IR(14386, 7), 1114}, // 1204 Xderef in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION - {IR(14456, 11), 1121}, // 1205 AtomicType in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER - {IR(14420, 10), 1118}, // 1206 ConstType in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER - {IR(14443, 13), 1120}, // 1207 RestrictType in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER - {IR(14430, 13), 1119}, // 1208 VolatileType in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER - {IR(24229, 15), 1128}, // 1209 CPP_for_OpenCL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(24194, 5), 1123}, // 1210 ESSL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(24199, 5), 1124}, // 1211 GLSL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(24249, 7), 1130}, // 1212 HERO_C in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(24224, 5), 1127}, // 1213 HLSL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(24256, 5), 1131}, // 1214 NZSL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(24204, 9), 1125}, // 1215 OpenCL_C in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(24213, 11), 1126}, // 1216 OpenCL_CPP in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(24276, 5), 1135}, // 1217 Rust in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(24244, 5), 1129}, // 1218 SYCL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(24266, 6), 1133}, // 1219 Slang in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(23736, 8), 1122}, // 1220 Unknown in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(24261, 5), 1132}, // 1221 WGSL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(24272, 4), 1134}, // 1222 Zig in SPV_OPERAND_TYPE_SOURCE_LANGUAGE - {IR(24363, 14), 1146}, // 1223 AtomicCounter in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24445, 16), 1152}, // 1224 CallableDataKHR in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24461, 15), 1152}, // 1225 CallableDataNV in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24759, 17), 1161}, // 1226 CodeSectionINTEL in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24310, 15), 1141}, // 1227 CrossWorkgroup in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24776, 16), 1162}, // 1228 DeviceOnlyINTEL in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24333, 9), 1143}, // 1229 Function in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24342, 8), 1144}, // 1230 Generic in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24550, 16), 1155}, // 1231 HitAttributeKHR in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24566, 15), 1155}, // 1232 HitAttributeNV in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24714, 21), 1159}, // 1233 HitObjectAttributeNV in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24792, 14), 1163}, // 1234 HostOnlyINTEL in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24377, 6), 1147}, // 1235 Image in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24476, 24), 1153}, // 1236 IncomingCallableDataKHR in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24500, 23), 1153}, // 1237 IncomingCallableDataNV in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24581, 22), 1156}, // 1238 IncomingRayPayloadKHR in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24603, 21), 1156}, // 1239 IncomingRayPayloadNV in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24297, 6), 1137}, // 1240 Input in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24429, 16), 1151}, // 1241 NodePayloadAMDX in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24303, 7), 1139}, // 1242 Output in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24667, 22), 1158}, // 1243 PhysicalStorageBuffer in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24689, 25), 1158}, // 1244 PhysicalStorageBufferEXT in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24325, 8), 1142}, // 1245 Private in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24350, 13), 1145}, // 1246 PushConstant in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24523, 14), 1154}, // 1247 RayPayloadKHR in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24537, 13), 1154}, // 1248 RayPayloadNV in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24624, 22), 1157}, // 1249 ShaderRecordBufferKHR in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24646, 21), 1157}, // 1250 ShaderRecordBufferNV in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24383, 14), 1148}, // 1251 StorageBuffer in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24735, 24), 1160}, // 1252 TaskPayloadWorkgroupEXT in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24410, 19), 1150}, // 1253 TileAttachmentQCOM in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24397, 13), 1149}, // 1254 TileImageEXT in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(15296, 8), 1138}, // 1255 Uniform in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24281, 16), 1136}, // 1256 UniformConstant in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(24048, 10), 1140}, // 1257 Workgroup in SPV_OPERAND_TYPE_STORAGE_CLASS - {IR(21860, 15), 1167}, // 1258 StreamingINTEL in SPV_OPERAND_TYPE_STORE_CACHE_CONTROL - {IR(21834, 14), 1164}, // 1259 UncachedINTEL in SPV_OPERAND_TYPE_STORE_CACHE_CONTROL - {IR(24824, 15), 1166}, // 1260 WriteBackINTEL in SPV_OPERAND_TYPE_STORE_CACHE_CONTROL - {IR(24806, 18), 1165}, // 1261 WriteThroughINTEL in SPV_OPERAND_TYPE_STORE_CACHE_CONTROL - {IR(24850, 11), 1170}, // 1262 DecodeFunc in SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS - {IR(14007, 5), 1168}, // 1263 None in SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS - {IR(24839, 11), 1169}, // 1264 TensorView in SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS - {IR(23681, 12), 1173}, // 1265 ClampToEdge in SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE - {IR(15254, 9), 1172}, // 1266 Constant in SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE - {IR(23699, 7), 1174}, // 1267 Repeat in SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE - {IR(23706, 15), 1175}, // 1268 RepeatMirrored in SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE - {IR(24861, 10), 1171}, // 1269 Undefined in SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE - {IR(24914, 24), 1179}, // 1270 MakeElementAvailableARM in SPV_OPERAND_TYPE_TENSOR_OPERANDS - {IR(24938, 22), 1180}, // 1271 MakeElementVisibleARM in SPV_OPERAND_TYPE_TENSOR_OPERANDS - {IR(24960, 21), 1181}, // 1272 NonPrivateElementARM in SPV_OPERAND_TYPE_TENSOR_OPERANDS - {IR(24871, 8), 1176}, // 1273 NoneARM in SPV_OPERAND_TYPE_TENSOR_OPERANDS - {IR(24879, 15), 1177}, // 1274 NontemporalARM in SPV_OPERAND_TYPE_TENSOR_OPERANDS - {IR(24894, 20), 1178}, // 1275 OutOfBoundsValueARM in SPV_OPERAND_TYPE_TENSOR_OPERANDS +static const std::array kOperandNames{{ + {IR(4633, 9), 0}, // 0 ReadOnly in SPV_OPERAND_TYPE_ACCESS_QUALIFIER + {IR(4659, 10), 2}, // 1 ReadWrite in SPV_OPERAND_TYPE_ACCESS_QUALIFIER + {IR(4649, 10), 1}, // 2 WriteOnly in SPV_OPERAND_TYPE_ACCESS_QUALIFIER + {IR(4669, 8), 3}, // 3 Logical in SPV_OPERAND_TYPE_ADDRESSING_MODEL + {IR(4677, 11), 4}, // 4 Physical32 in SPV_OPERAND_TYPE_ADDRESSING_MODEL + {IR(4698, 11), 5}, // 5 Physical64 in SPV_OPERAND_TYPE_ADDRESSING_MODEL + {IR(4709, 24), 6}, // 6 PhysicalStorageBuffer64 in SPV_OPERAND_TYPE_ADDRESSING_MODEL + {IR(4733, 27), 6}, // 7 PhysicalStorageBuffer64EXT in SPV_OPERAND_TYPE_ADDRESSING_MODEL + {IR(6643, 13), 92}, // 8 BaryCoordKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(6656, 12), 92}, // 9 BaryCoordNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(6038, 20), 68}, // 10 BaryCoordNoPerspAMD in SPV_OPERAND_TYPE_BUILT_IN + {IR(6058, 28), 69}, // 11 BaryCoordNoPerspCentroidAMD in SPV_OPERAND_TYPE_BUILT_IN + {IR(6691, 20), 93}, // 12 BaryCoordNoPerspKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(6711, 19), 93}, // 13 BaryCoordNoPerspNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(6086, 26), 70}, // 14 BaryCoordNoPerspSampleAMD in SPV_OPERAND_TYPE_BUILT_IN + {IR(6183, 22), 74}, // 15 BaryCoordPullModelAMD in SPV_OPERAND_TYPE_BUILT_IN + {IR(6112, 19), 71}, // 16 BaryCoordSmoothAMD in SPV_OPERAND_TYPE_BUILT_IN + {IR(6131, 27), 72}, // 17 BaryCoordSmoothCentroidAMD in SPV_OPERAND_TYPE_BUILT_IN + {IR(6158, 25), 73}, // 18 BaryCoordSmoothSampleAMD in SPV_OPERAND_TYPE_BUILT_IN + {IR(5842, 13), 59}, // 19 BaseInstance in SPV_OPERAND_TYPE_BUILT_IN + {IR(5816, 11), 58}, // 20 BaseVertex in SPV_OPERAND_TYPE_BUILT_IN + {IR(4817, 13), 9}, // 21 ClipDistance in SPV_OPERAND_TYPE_BUILT_IN + {IR(6550, 22), 87}, // 22 ClipDistancePerViewNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7849, 12), 131}, // 23 ClusterIDNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(5580, 13), 49}, // 24 CoreCountARM in SPV_OPERAND_TYPE_BUILT_IN + {IR(5554, 10), 48}, // 25 CoreIDARM in SPV_OPERAND_TYPE_BUILT_IN + {IR(5593, 13), 50}, // 26 CoreMaxIDARM in SPV_OPERAND_TYPE_BUILT_IN + {IR(4830, 13), 10}, // 27 CullDistance in SPV_OPERAND_TYPE_BUILT_IN + {IR(6572, 22), 88}, // 28 CullDistancePerViewNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7902, 12), 132}, // 29 CullMaskKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(6898, 17), 99}, // 30 CullPrimitiveEXT in SPV_OPERAND_TYPE_BUILT_IN + {IR(7302, 17), 113}, // 31 CurrentRayTimeNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(5912, 12), 62}, // 32 DeviceIndex in SPV_OPERAND_TYPE_BUILT_IN + {IR(5855, 10), 60}, // 33 DrawIndex in SPV_OPERAND_TYPE_BUILT_IN + {IR(5344, 22), 37}, // 34 EnqueuedWorkgroupSize in SPV_OPERAND_TYPE_BUILT_IN + {IR(5114, 10), 21}, // 35 FragCoord in SPV_OPERAND_TYPE_BUILT_IN + {IR(5200, 10), 27}, // 36 FragDepth in SPV_OPERAND_TYPE_BUILT_IN + {IR(6776, 23), 95}, // 37 FragInvocationCountEXT in SPV_OPERAND_TYPE_BUILT_IN + {IR(6730, 12), 94}, // 38 FragSizeEXT in SPV_OPERAND_TYPE_BUILT_IN + {IR(6205, 18), 75}, // 39 FragStencilRefEXT in SPV_OPERAND_TYPE_BUILT_IN + {IR(6742, 15), 94}, // 40 FragmentSizeNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(5135, 12), 23}, // 41 FrontFacing in SPV_OPERAND_TYPE_BUILT_IN + {IR(6462, 16), 83}, // 42 FullyCoveredEXT in SPV_OPERAND_TYPE_BUILT_IN + {IR(5285, 19), 33}, // 43 GlobalInvocationId in SPV_OPERAND_TYPE_BUILT_IN + {IR(5379, 15), 39}, // 44 GlobalLinearId in SPV_OPERAND_TYPE_BUILT_IN + {IR(5366, 13), 38}, // 45 GlobalOffset in SPV_OPERAND_TYPE_BUILT_IN + {IR(5333, 11), 36}, // 46 GlobalSize in SPV_OPERAND_TYPE_BUILT_IN + {IR(5210, 17), 28}, // 47 HelperInvocation in SPV_OPERAND_TYPE_BUILT_IN + {IR(7604, 11), 120}, // 48 HitIsLSSNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7562, 14), 119}, // 49 HitIsSphereNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7784, 33), 128}, // 50 HitKindBackFacingMicroTriangleNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7750, 34), 127}, // 51 HitKindFrontFacingMicroTriangleNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7281, 11), 112}, // 52 HitKindKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(7292, 10), 112}, // 53 HitKindNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7732, 18), 126}, // 54 HitLSSPositionsNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7835, 14), 130}, // 55 HitLSSRadiiNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7466, 37), 116}, // 56 HitMicroTriangleVertexBarycentricsNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7399, 34), 115}, // 57 HitMicroTriangleVertexPositionsNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7654, 20), 121}, // 58 HitSpherePositionNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7817, 18), 129}, // 59 HitSphereRadiusNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7274, 7), 111}, // 60 HitTNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7342, 30), 114}, // 61 HitTriangleVertexPositionsKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(7503, 20), 117}, // 62 IncomingRayFlagsKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(7523, 19), 117}, // 63 IncomingRayFlagsNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7163, 23), 108}, // 64 InstanceCustomIndexKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(7186, 22), 108}, // 65 InstanceCustomIndexNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(4852, 11), 12}, // 66 InstanceId in SPV_OPERAND_TYPE_BUILT_IN + {IR(5540, 14), 47}, // 67 InstanceIndex in SPV_OPERAND_TYPE_BUILT_IN + {IR(4953, 13), 14}, // 68 InvocationId in SPV_OPERAND_TYPE_BUILT_IN + {IR(6799, 22), 95}, // 69 InvocationsPerPixelNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(6915, 12), 100}, // 70 LaunchIdKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(6927, 11), 100}, // 71 LaunchIdNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(6938, 14), 101}, // 72 LaunchSizeKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(6952, 13), 101}, // 73 LaunchSizeNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(4966, 6), 15}, // 74 Layer in SPV_OPERAND_TYPE_BUILT_IN + {IR(6594, 15), 89}, // 75 LayerPerViewNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(5267, 18), 32}, // 76 LocalInvocationId in SPV_OPERAND_TYPE_BUILT_IN + {IR(5304, 21), 34}, // 77 LocalInvocationIndex in SPV_OPERAND_TYPE_BUILT_IN + {IR(6609, 16), 90}, // 78 MeshViewCountNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(6625, 18), 91}, // 79 MeshViewIndicesNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(5470, 21), 43}, // 80 NumEnqueuedSubgroups in SPV_OPERAND_TYPE_BUILT_IN + {IR(5457, 13), 42}, // 81 NumSubgroups in SPV_OPERAND_TYPE_BUILT_IN + {IR(5227, 14), 29}, // 82 NumWorkgroups in SPV_OPERAND_TYPE_BUILT_IN + {IR(7078, 22), 105}, // 83 ObjectRayDirectionKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(7100, 21), 105}, // 84 ObjectRayDirectionNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7041, 19), 104}, // 85 ObjectRayOriginKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(7060, 18), 104}, // 86 ObjectRayOriginNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7208, 17), 109}, // 87 ObjectToWorldKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(7225, 16), 109}, // 88 ObjectToWorldNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(5100, 14), 20}, // 89 PatchVertices in SPV_OPERAND_TYPE_BUILT_IN + {IR(5124, 11), 22}, // 90 PointCoord in SPV_OPERAND_TYPE_BUILT_IN + {IR(4807, 10), 8}, // 91 PointSize in SPV_OPERAND_TYPE_BUILT_IN + {IR(4791, 9), 7}, // 92 Position in SPV_OPERAND_TYPE_BUILT_IN + {IR(6402, 18), 81}, // 93 PositionPerViewNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(6514, 17), 85}, // 94 PrimitiveCountNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(4863, 12), 13}, // 95 PrimitiveId in SPV_OPERAND_TYPE_BUILT_IN + {IR(6531, 19), 86}, // 96 PrimitiveIndicesNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(6846, 24), 97}, // 97 PrimitiveLineIndicesEXT in SPV_OPERAND_TYPE_BUILT_IN + {IR(6821, 25), 96}, // 98 PrimitivePointIndicesEXT in SPV_OPERAND_TYPE_BUILT_IN + {IR(5865, 24), 61}, // 99 PrimitiveShadingRateKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(6870, 28), 98}, // 100 PrimitiveTriangleIndicesEXT in SPV_OPERAND_TYPE_BUILT_IN + {IR(7542, 20), 118}, // 101 RayGeometryIndexKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(7142, 11), 107}, // 102 RayTmaxKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(7153, 10), 107}, // 103 RayTmaxNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7121, 11), 106}, // 104 RayTminKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(7132, 10), 106}, // 105 RayTminNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(6240, 29), 76}, // 106 RemainingRecursionLevelsAMDX in SPV_OPERAND_TYPE_BUILT_IN + {IR(7706, 10), 123}, // 107 SMCountNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7725, 7), 125}, // 108 SMIDNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(5147, 9), 24}, // 109 SampleId in SPV_OPERAND_TYPE_BUILT_IN + {IR(5189, 11), 26}, // 110 SampleMask in SPV_OPERAND_TYPE_BUILT_IN + {IR(5174, 15), 25}, // 111 SamplePosition in SPV_OPERAND_TYPE_BUILT_IN + {IR(6339, 20), 79}, // 112 SecondaryPositionNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(6378, 24), 80}, // 113 SecondaryViewportMaskNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(6287, 16), 77}, // 114 ShaderIndexAMDX in SPV_OPERAND_TYPE_BUILT_IN + {IR(5956, 15), 64}, // 115 ShadingRateKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(5629, 15), 53}, // 116 SubgroupEqMask in SPV_OPERAND_TYPE_BUILT_IN + {IR(5644, 18), 53}, // 117 SubgroupEqMaskKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(5684, 15), 54}, // 118 SubgroupGeMask in SPV_OPERAND_TYPE_BUILT_IN + {IR(5699, 18), 54}, // 119 SubgroupGeMaskKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(5717, 15), 55}, // 120 SubgroupGtMask in SPV_OPERAND_TYPE_BUILT_IN + {IR(5732, 18), 55}, // 121 SubgroupGtMaskKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(5491, 11), 44}, // 122 SubgroupId in SPV_OPERAND_TYPE_BUILT_IN + {IR(5750, 15), 56}, // 123 SubgroupLeMask in SPV_OPERAND_TYPE_BUILT_IN + {IR(5765, 18), 56}, // 124 SubgroupLeMaskKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(5502, 26), 45}, // 125 SubgroupLocalInvocationId in SPV_OPERAND_TYPE_BUILT_IN + {IR(5783, 15), 57}, // 126 SubgroupLtMask in SPV_OPERAND_TYPE_BUILT_IN + {IR(5798, 18), 57}, // 127 SubgroupLtMaskKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(5441, 16), 41}, // 128 SubgroupMaxSize in SPV_OPERAND_TYPE_BUILT_IN + {IR(5394, 13), 40}, // 129 SubgroupSize in SPV_OPERAND_TYPE_BUILT_IN + {IR(6502, 12), 84}, // 130 TaskCountNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(5090, 10), 19}, // 131 TessCoord in SPV_OPERAND_TYPE_BUILT_IN + {IR(5075, 15), 18}, // 132 TessLevelInner in SPV_OPERAND_TYPE_BUILT_IN + {IR(5060, 15), 17}, // 133 TessLevelOuter in SPV_OPERAND_TYPE_BUILT_IN + {IR(6020, 18), 67}, // 134 TileApronSizeQCOM in SPV_OPERAND_TYPE_BUILT_IN + {IR(6002, 18), 66}, // 135 TileDimensionQCOM in SPV_OPERAND_TYPE_BUILT_IN + {IR(5971, 15), 65}, // 136 TileOffsetQCOM in SPV_OPERAND_TYPE_BUILT_IN + {IR(4843, 9), 11}, // 137 VertexId in SPV_OPERAND_TYPE_BUILT_IN + {IR(5528, 12), 46}, // 138 VertexIndex in SPV_OPERAND_TYPE_BUILT_IN + {IR(5936, 10), 63}, // 139 ViewIndex in SPV_OPERAND_TYPE_BUILT_IN + {IR(5012, 14), 16}, // 140 ViewportIndex in SPV_OPERAND_TYPE_BUILT_IN + {IR(6303, 15), 78}, // 141 ViewportMaskNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(6440, 22), 82}, // 142 ViewportMaskPerViewNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(5606, 10), 51}, // 143 WarpIDARM in SPV_OPERAND_TYPE_BUILT_IN + {IR(7716, 9), 124}, // 144 WarpIDNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(5616, 13), 52}, // 145 WarpMaxIDARM in SPV_OPERAND_TYPE_BUILT_IN + {IR(7674, 13), 122}, // 146 WarpsPerSMNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(5325, 8), 35}, // 147 WorkDim in SPV_OPERAND_TYPE_BUILT_IN + {IR(5255, 12), 31}, // 148 WorkgroupId in SPV_OPERAND_TYPE_BUILT_IN + {IR(5241, 14), 30}, // 149 WorkgroupSize in SPV_OPERAND_TYPE_BUILT_IN + {IR(7000, 21), 103}, // 150 WorldRayDirectionKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(7021, 20), 103}, // 151 WorldRayDirectionNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(6965, 18), 102}, // 152 WorldRayOriginKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(6983, 17), 102}, // 153 WorldRayOriginNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(7241, 17), 110}, // 154 WorldToObjectKHR in SPV_OPERAND_TYPE_BUILT_IN + {IR(7258, 16), 110}, // 155 WorldToObjectNV in SPV_OPERAND_TYPE_BUILT_IN + {IR(4688, 10), 137}, // 156 Addresses in SPV_OPERAND_TYPE_CAPABILITY + {IR(12919, 34), 359}, // 157 ArbitraryPrecisionFixedPointINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12607, 37), 347}, // 158 ArbitraryPrecisionFloatingPointINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12575, 32), 346}, // 159 ArbitraryPrecisionIntegersINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13476, 19), 384}, // 160 ArithmeticFenceEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(12240, 9), 332}, // 161 AsmINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13393, 20), 380}, // 162 AtomicFloat16AddEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(12295, 23), 335}, // 163 AtomicFloat16MinMaxEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(11768, 22), 310}, // 164 AtomicFloat16VectorNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(13309, 20), 376}, // 165 AtomicFloat32AddEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(12249, 23), 333}, // 166 AtomicFloat32MinMaxEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(13329, 20), 377}, // 167 AtomicFloat64AddEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(12272, 23), 334}, // 168 AtomicFloat64MinMaxEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(8082, 14), 153}, // 169 AtomicStorage in SPV_OPERAND_TYPE_CAPABILITY + {IR(9469, 17), 229}, // 170 AtomicStorageOps in SPV_OPERAND_TYPE_CAPABILITY + {IR(13434, 24), 382}, // 171 BFloat16ConversionINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(10091, 29), 263}, // 172 BFloat16CooperativeMatrixKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(10069, 22), 262}, // 173 BFloat16DotProductKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(10053, 16), 261}, // 174 BFloat16TypeKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(14072, 20), 407}, // 175 BindlessImagesINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(11705, 18), 307}, // 176 BindlessTextureNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(13246, 16), 372}, // 177 BitInstructions in SPV_OPERAND_TYPE_CAPABILITY + {IR(13018, 19), 363}, // 178 BlockingPipesINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(14033, 19), 405}, // 179 CacheControlsINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(4817, 13), 163}, // 180 ClipDistance in SPV_OPERAND_TYPE_CAPABILITY + {IR(11363, 32), 296}, // 181 ComputeDerivativeGroupLinearKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(11395, 31), 296}, // 182 ComputeDerivativeGroupLinearNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(10243, 31), 275}, // 183 ComputeDerivativeGroupQuadsKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(10274, 30), 275}, // 184 ComputeDerivativeGroupQuadsNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(11945, 30), 319}, // 185 CooperativeMatrixBlockLoadsNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(9838, 32), 248}, // 186 CooperativeMatrixConversionQCOM in SPV_OPERAND_TYPE_CAPABILITY + {IR(11838, 31), 316}, // 187 CooperativeMatrixConversionsNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(9117, 21), 370}, // 188 CooperativeMatrixKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(9052, 28), 211}, // 189 CooperativeMatrixLayoutsARM in SPV_OPERAND_TYPE_CAPABILITY + {IR(11451, 20), 298}, // 190 CooperativeMatrixNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(11869, 40), 317}, // 191 CooperativeMatrixPerElementOperationsNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(11808, 30), 315}, // 192 CooperativeMatrixReductionsNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(11909, 36), 318}, // 193 CooperativeMatrixTensorAddressingNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(11748, 20), 309}, // 194 CooperativeVectorNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(11975, 28), 320}, // 195 CooperativeVectorTrainingNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(5564, 16), 203}, // 196 CoreBuiltinsARM in SPV_OPERAND_TYPE_CAPABILITY + {IR(4830, 13), 164}, // 197 CullDistance in SPV_OPERAND_TYPE_CAPABILITY + {IR(13413, 21), 381}, // 198 DebugInfoModuleINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(11574, 25), 303}, // 199 DemoteToHelperInvocation in SPV_OPERAND_TYPE_CAPABILITY + {IR(11599, 28), 303}, // 200 DemoteToHelperInvocationEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(9608, 18), 235}, // 201 DenormFlushToZero in SPV_OPERAND_TYPE_CAPABILITY + {IR(9593, 15), 234}, // 202 DenormPreserve in SPV_OPERAND_TYPE_CAPABILITY + {IR(8529, 18), 182}, // 203 DerivativeControl in SPV_OPERAND_TYPE_CAPABILITY + {IR(8053, 14), 151}, // 204 DeviceEnqueue in SPV_OPERAND_TYPE_CAPABILITY + {IR(5924, 12), 225}, // 205 DeviceGroup in SPV_OPERAND_TYPE_CAPABILITY + {IR(11627, 23), 304}, // 206 DisplacementMicromapNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(13197, 11), 368}, // 207 DotProduct in SPV_OPERAND_TYPE_CAPABILITY + {IR(13091, 22), 366}, // 208 DotProductInput4x8Bit in SPV_OPERAND_TYPE_CAPABILITY + {IR(13113, 25), 366}, // 209 DotProductInput4x8BitKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(13138, 28), 367}, // 210 DotProductInput4x8BitPacked in SPV_OPERAND_TYPE_CAPABILITY + {IR(13166, 31), 367}, // 211 DotProductInput4x8BitPackedKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(13050, 19), 365}, // 212 DotProductInputAll in SPV_OPERAND_TYPE_CAPABILITY + {IR(13069, 22), 365}, // 213 DotProductInputAllKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(13208, 14), 368}, // 214 DotProductKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(5827, 15), 216}, // 215 DrawParameters in SPV_OPERAND_TYPE_CAPABILITY + {IR(12352, 16), 338}, // 216 ExpectAssumeKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(13302, 7), 375}, // 217 FMAKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(12555, 20), 345}, // 218 FPFastMathModeINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13610, 28), 390}, // 219 FPGAArgumentInterfacesINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12895, 24), 358}, // 220 FPGABufferLocationINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12768, 27), 353}, // 221 FPGAClusterAttributesINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13495, 29), 385}, // 222 FPGAClusterAttributesV2INTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12809, 20), 355}, // 223 FPGADSPControlINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12855, 40), 357}, // 224 FPGAInvocationPipeliningAttributesINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12718, 26), 351}, // 225 FPGAKernelAttributesINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13524, 28), 386}, // 226 FPGAKernelAttributesv2INTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13586, 24), 389}, // 227 FPGALatencyControlINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12674, 22), 349}, // 228 FPGALoopControlsINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12744, 24), 352}, // 229 FPGAMemoryAccessesINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12529, 26), 344}, // 230 FPGAMemoryAttributesINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13037, 13), 364}, // 231 FPGARegINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13570, 16), 388}, // 232 FPMaxErrorINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(7967, 8), 142}, // 233 Float16 in SPV_OPERAND_TYPE_CAPABILITY + {IR(7953, 14), 141}, // 234 Float16Buffer in SPV_OPERAND_TYPE_CAPABILITY + {IR(9893, 16), 250}, // 235 Float16ImageAMD in SPV_OPERAND_TYPE_CAPABILITY + {IR(7975, 8), 143}, // 236 Float64 in SPV_OPERAND_TYPE_CAPABILITY + {IR(9090, 27), 213}, // 237 Float8CooperativeMatrixEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(9080, 10), 212}, // 238 Float8EXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(13287, 15), 374}, // 239 FloatControls2 in SPV_OPERAND_TYPE_CAPABILITY + {IR(12148, 23), 328}, // 240 FloatingPointModeINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(6668, 23), 274}, // 241 FragmentBarycentricKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(10221, 22), 274}, // 242 FragmentBarycentricNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(6757, 19), 276}, // 243 FragmentDensityEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(6478, 24), 270}, // 244 FragmentFullyCoveredEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(9931, 16), 252}, // 245 FragmentMaskAMD in SPV_OPERAND_TYPE_CAPABILITY + {IR(11542, 32), 302}, // 246 FragmentShaderPixelInterlockEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(11471, 33), 299}, // 247 FragmentShaderSampleInterlockEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(11504, 38), 300}, // 248 FragmentShaderShadingRateInterlockEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(5889, 23), 214}, // 249 FragmentShadingRateKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(12503, 26), 343}, // 250 FunctionFloatControlINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12194, 22), 330}, // 251 FunctionPointersINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13933, 22), 401}, // 252 FunctionVariantsINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(8374, 15), 169}, // 253 GenericPointer in SPV_OPERAND_TYPE_CAPABILITY + {IR(4875, 9), 135}, // 254 Geometry in SPV_OPERAND_TYPE_CAPABILITY + {IR(8124, 18), 156}, // 255 GeometryPointSize in SPV_OPERAND_TYPE_CAPABILITY + {IR(10149, 28), 265}, // 256 GeometryShaderPassthroughNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(8587, 16), 185}, // 257 GeometryStreams in SPV_OPERAND_TYPE_CAPABILITY + {IR(13668, 35), 392}, // 258 GlobalVariableFPGADecorationsINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13638, 30), 391}, // 259 GlobalVariableHostAccessINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(9043, 9), 210}, // 260 GraphARM in SPV_OPERAND_TYPE_CAPABILITY + {IR(5407, 16), 192}, // 261 GroupNonUniform in SPV_OPERAND_TYPE_CAPABILITY + {IR(8726, 26), 194}, // 262 GroupNonUniformArithmetic in SPV_OPERAND_TYPE_CAPABILITY + {IR(5662, 22), 195}, // 263 GroupNonUniformBallot in SPV_OPERAND_TYPE_CAPABILITY + {IR(8806, 25), 198}, // 264 GroupNonUniformClustered in SPV_OPERAND_TYPE_CAPABILITY + {IR(10318, 29), 277}, // 265 GroupNonUniformPartitionedNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(8831, 20), 199}, // 266 GroupNonUniformQuad in SPV_OPERAND_TYPE_CAPABILITY + {IR(13262, 25), 373}, // 267 GroupNonUniformRotateKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(8752, 23), 196}, // 268 GroupNonUniformShuffle in SPV_OPERAND_TYPE_CAPABILITY + {IR(8775, 31), 197}, // 269 GroupNonUniformShuffleRelative in SPV_OPERAND_TYPE_CAPABILITY + {IR(8706, 20), 193}, // 270 GroupNonUniformVote in SPV_OPERAND_TYPE_CAPABILITY + {IR(13955, 26), 402}, // 271 GroupUniformArithmeticKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(8046, 7), 150}, // 272 Groups in SPV_OPERAND_TYPE_CAPABILITY + {IR(13005, 13), 362}, // 273 IOPipesINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(8443, 8), 175}, // 274 Image1D in SPV_OPERAND_TYPE_CAPABILITY + {IR(8002, 11), 146}, // 275 ImageBasic in SPV_OPERAND_TYPE_CAPABILITY + {IR(8465, 12), 178}, // 276 ImageBuffer in SPV_OPERAND_TYPE_CAPABILITY + {IR(8320, 15), 165}, // 277 ImageCubeArray in SPV_OPERAND_TYPE_CAPABILITY + {IR(10204, 17), 272}, // 278 ImageFootprintNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(9909, 22), 251}, // 279 ImageGatherBiasLodAMD in SPV_OPERAND_TYPE_CAPABILITY + {IR(8142, 20), 157}, // 280 ImageGatherExtended in SPV_OPERAND_TYPE_CAPABILITY + {IR(8477, 13), 179}, // 281 ImageMSArray in SPV_OPERAND_TYPE_CAPABILITY + {IR(8028, 12), 148}, // 282 ImageMipmap in SPV_OPERAND_TYPE_CAPABILITY + {IR(8518, 11), 181}, // 283 ImageQuery in SPV_OPERAND_TYPE_CAPABILITY + {IR(8013, 15), 147}, // 284 ImageReadWrite in SPV_OPERAND_TYPE_CAPABILITY + {IR(9947, 21), 254}, // 285 ImageReadWriteLodAMD in SPV_OPERAND_TYPE_CAPABILITY + {IR(8352, 10), 167}, // 286 ImageRect in SPV_OPERAND_TYPE_CAPABILITY + {IR(12216, 24), 331}, // 287 IndirectReferencesINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(8394, 16), 171}, // 288 InputAttachment in SPV_OPERAND_TYPE_CAPABILITY + {IR(10433, 36), 280}, // 289 InputAttachmentArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(10469, 39), 280}, // 290 InputAttachmentArrayDynamicIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(10974, 39), 287}, // 291 InputAttachmentArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(11013, 42), 287}, // 292 InputAttachmentArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(8096, 6), 154}, // 293 Int16 in SPV_OPERAND_TYPE_CAPABILITY + {IR(10026, 27), 260}, // 294 Int4CooperativeMatrixINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(10012, 14), 259}, // 295 Int4TypeINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(7983, 6), 144}, // 296 Int64 in SPV_OPERAND_TYPE_CAPABILITY + {IR(7989, 13), 145}, // 297 Int64Atomics in SPV_OPERAND_TYPE_CAPABILITY + {IR(9968, 14), 255}, // 298 Int64ImageEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(8389, 5), 170}, // 299 Int8 in SPV_OPERAND_TYPE_CAPABILITY + {IR(12171, 23), 329}, // 300 IntegerFunctions2INTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(8547, 22), 183}, // 301 InterpolationFunction in SPV_OPERAND_TYPE_CAPABILITY + {IR(4642, 7), 139}, // 302 Kernel in SPV_OPERAND_TYPE_CAPABILITY + {IR(12696, 22), 350}, // 303 KernelAttributesINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(7936, 8), 138}, // 304 Linkage in SPV_OPERAND_TYPE_CAPABILITY + {IR(8067, 15), 152}, // 305 LiteralSampler in SPV_OPERAND_TYPE_CAPABILITY + {IR(13349, 20), 378}, // 306 LongCompositesINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12795, 14), 354}, // 307 LoopFuseINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(14008, 25), 404}, // 308 MaskedGatherScatterINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(7929, 7), 133}, // 309 Matrix in SPV_OPERAND_TYPE_CAPABILITY + {IR(12829, 26), 356}, // 310 MemoryAccessAliasingINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(4938, 15), 273}, // 311 MeshShadingEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(4924, 14), 271}, // 312 MeshShadingNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(8426, 7), 173}, // 313 MinLod in SPV_OPERAND_TYPE_CAPABILITY + {IR(5946, 10), 226}, // 314 MultiView in SPV_OPERAND_TYPE_CAPABILITY + {IR(5026, 14), 188}, // 315 MultiViewport in SPV_OPERAND_TYPE_CAPABILITY + {IR(8681, 13), 190}, // 316 NamedBarrier in SPV_OPERAND_TYPE_CAPABILITY + {IR(13369, 11), 379}, // 317 OptNoneEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(13380, 13), 379}, // 318 OptNoneINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(6420, 20), 269}, // 319 PerViewAttributesNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(4760, 31), 295}, // 320 PhysicalStorageBufferAddresses in SPV_OPERAND_TYPE_CAPABILITY + {IR(11329, 34), 295}, // 321 PhysicalStorageBufferAddressesEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(8694, 12), 191}, // 322 PipeStorage in SPV_OPERAND_TYPE_CAPABILITY + {IR(8040, 6), 149}, // 323 Pipes in SPV_OPERAND_TYPE_CAPABILITY + {IR(9997, 15), 258}, // 324 QuadControlKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(11790, 18), 312}, // 325 RawAccessChainsNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(7914, 15), 369}, // 326 RayCullMaskKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(9706, 12), 240}, // 327 RayQueryKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(11723, 25), 308}, // 328 RayQueryPositionFetchKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(9683, 23), 239}, // 329 RayQueryProvisionalKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(7861, 41), 321}, // 330 RayTracingClusterAccelerationStructureNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(7433, 33), 311}, // 331 RayTracingDisplacementMicromapNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(4910, 14), 243}, // 332 RayTracingKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(7615, 39), 314}, // 333 RayTracingLinearSweptSpheresGeometryNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(7319, 23), 292}, // 334 RayTracingMotionBlurNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(4897, 13), 291}, // 335 RayTracingNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(11650, 29), 305}, // 336 RayTracingOpacityMicromapEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(7372, 27), 290}, // 337 RayTracingPositionFetchKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(11426, 25), 297}, // 338 RayTracingProvisionalKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(7576, 28), 313}, // 339 RayTracingSpheresGeometryNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(9737, 32), 242}, // 340 RayTraversalPrimitiveCullingKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(14052, 20), 406}, // 341 RegisterLimitsINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13222, 24), 371}, // 342 ReplicatedCompositesEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(12127, 21), 327}, // 343 RoundToInfinityINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(9651, 16), 237}, // 344 RoundingModeRTE in SPV_OPERAND_TYPE_CAPABILITY + {IR(9667, 16), 238}, // 345 RoundingModeRTZ in SPV_OPERAND_TYPE_CAPABILITY + {IR(12976, 29), 361}, // 346 RuntimeAlignedAttributeINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(10384, 23), 279}, // 347 RuntimeDescriptorArray in SPV_OPERAND_TYPE_CAPABILITY + {IR(10407, 26), 279}, // 348 RuntimeDescriptorArrayEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(10120, 29), 264}, // 349 SampleMaskOverrideCoverageNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(9486, 28), 230}, // 350 SampleMaskPostDepthCoverage in SPV_OPERAND_TYPE_CAPABILITY + {IR(5156, 18), 166}, // 351 SampleRateShading in SPV_OPERAND_TYPE_CAPABILITY + {IR(8433, 10), 174}, // 352 Sampled1D in SPV_OPERAND_TYPE_CAPABILITY + {IR(8451, 14), 177}, // 353 SampledBuffer in SPV_OPERAND_TYPE_CAPABILITY + {IR(8335, 17), 176}, // 354 SampledCubeArray in SPV_OPERAND_TYPE_CAPABILITY + {IR(8220, 33), 160}, // 355 SampledImageArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(10747, 36), 284}, // 356 SampledImageArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(10783, 39), 284}, // 357 SampledImageArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(8362, 12), 168}, // 358 SampledRect in SPV_OPERAND_TYPE_CAPABILITY + {IR(4800, 7), 134}, // 359 Shader in SPV_OPERAND_TYPE_CAPABILITY + {IR(9982, 15), 256}, // 360 ShaderClockKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(6269, 18), 257}, // 361 ShaderEnqueueAMDX in SPV_OPERAND_TYPE_CAPABILITY + {IR(11679, 26), 306}, // 362 ShaderInvocationReorderNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(4972, 12), 200}, // 363 ShaderLayer in SPV_OPERAND_TYPE_CAPABILITY + {IR(10347, 17), 278}, // 364 ShaderNonUniform in SPV_OPERAND_TYPE_CAPABILITY + {IR(10364, 20), 278}, // 365 ShaderNonUniformEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(7687, 19), 301}, // 366 ShaderSMBuiltinsNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(6359, 19), 268}, // 367 ShaderStereoViewNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(5040, 20), 201}, // 368 ShaderViewportIndex in SPV_OPERAND_TYPE_CAPABILITY + {IR(4984, 28), 266}, // 369 ShaderViewportIndexLayerEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(10177, 27), 266}, // 370 ShaderViewportIndexLayerNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(6318, 21), 267}, // 371 ShaderViewportMaskNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(10304, 14), 276}, // 372 ShadingRateNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(9626, 25), 236}, // 373 SignedZeroInfNanPreserve in SPV_OPERAND_TYPE_CAPABILITY + {IR(8410, 16), 172}, // 374 SparseResidency in SPV_OPERAND_TYPE_CAPABILITY + {IR(13912, 21), 400}, // 375 SpecConditionalINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13458, 18), 383}, // 376 SplitBarrierINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(6223, 17), 253}, // 377 StencilExportEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(9274, 25), 221}, // 378 StorageBuffer16BitAccess in SPV_OPERAND_TYPE_CAPABILITY + {IR(9514, 24), 231}, // 379 StorageBuffer8BitAccess in SPV_OPERAND_TYPE_CAPABILITY + {IR(8253, 34), 161}, // 380 StorageBufferArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(10822, 37), 285}, // 381 StorageBufferArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(10859, 40), 285}, // 382 StorageBufferArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(8287, 33), 162}, // 383 StorageImageArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(10899, 36), 286}, // 384 StorageImageArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(10935, 39), 286}, // 385 StorageImageArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(8490, 28), 180}, // 386 StorageImageExtendedFormats in SPV_OPERAND_TYPE_CAPABILITY + {IR(8162, 24), 158}, // 387 StorageImageMultisample in SPV_OPERAND_TYPE_CAPABILITY + {IR(8603, 30), 186}, // 388 StorageImageReadWithoutFormat in SPV_OPERAND_TYPE_CAPABILITY + {IR(8633, 31), 187}, // 389 StorageImageWriteWithoutFormat in SPV_OPERAND_TYPE_CAPABILITY + {IR(9401, 21), 224}, // 390 StorageInputOutput16 in SPV_OPERAND_TYPE_CAPABILITY + {IR(9379, 22), 223}, // 391 StoragePushConstant16 in SPV_OPERAND_TYPE_CAPABILITY + {IR(9572, 21), 233}, // 392 StoragePushConstant8 in SPV_OPERAND_TYPE_CAPABILITY + {IR(8966, 37), 208}, // 393 StorageTensorArrayDynamicIndexingARM in SPV_OPERAND_TYPE_CAPABILITY + {IR(9003, 40), 209}, // 394 StorageTensorArrayNonUniformIndexingARM in SPV_OPERAND_TYPE_CAPABILITY + {IR(10589, 39), 282}, // 395 StorageTexelBufferArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(10628, 42), 282}, // 396 StorageTexelBufferArrayDynamicIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(11142, 42), 289}, // 397 StorageTexelBufferArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(11184, 45), 289}, // 398 StorageTexelBufferArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(9362, 17), 222}, // 399 StorageUniform16 in SPV_OPERAND_TYPE_CAPABILITY + {IR(9299, 28), 221}, // 400 StorageUniformBufferBlock16 in SPV_OPERAND_TYPE_CAPABILITY + {IR(13731, 23), 394}, // 401 Subgroup2DBlockIOINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13754, 30), 395}, // 402 Subgroup2DBlockTransformINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13784, 30), 396}, // 403 Subgroup2DBlockTransposeINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12439, 39), 341}, // 404 SubgroupAvcMotionEstimationChromaINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12368, 33), 339}, // 405 SubgroupAvcMotionEstimationINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12401, 38), 340}, // 406 SubgroupAvcMotionEstimationIntraINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(5423, 18), 215}, // 407 SubgroupBallotKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(12043, 27), 324}, // 408 SubgroupBufferBlockIOINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13703, 28), 393}, // 409 SubgroupBufferPrefetchINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(8664, 17), 189}, // 410 SubgroupDispatch in SPV_OPERAND_TYPE_CAPABILITY + {IR(12070, 26), 325}, // 411 SubgroupImageBlockIOINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12096, 31), 326}, // 412 SubgroupImageMediaBlockIOINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(13814, 38), 397}, // 413 SubgroupMatrixMultiplyAccumulateINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12022, 21), 323}, // 414 SubgroupShuffleINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(9258, 16), 220}, // 415 SubgroupVoteKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(13552, 18), 387}, // 416 TaskSequenceINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12003, 19), 322}, // 417 TensorAddressingNV in SPV_OPERAND_TYPE_CAPABILITY + {IR(13981, 27), 403}, // 418 TensorFloat32RoundingINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(8955, 11), 207}, // 419 TensorsARM in SPV_OPERAND_TYPE_CAPABILITY + {IR(13852, 28), 398}, // 420 TernaryBitwiseFunctionINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(4884, 13), 136}, // 421 Tessellation in SPV_OPERAND_TYPE_CAPABILITY + {IR(8102, 22), 155}, // 422 TessellationPointSize in SPV_OPERAND_TYPE_CAPABILITY + {IR(9870, 23), 249}, // 423 TextureBlockMatch2QCOM in SPV_OPERAND_TYPE_CAPABILITY + {IR(9816, 22), 246}, // 424 TextureBlockMatchQCOM in SPV_OPERAND_TYPE_CAPABILITY + {IR(9795, 21), 245}, // 425 TextureBoxFilterQCOM in SPV_OPERAND_TYPE_CAPABILITY + {IR(9769, 26), 244}, // 426 TextureSampleWeightedQCOM in SPV_OPERAND_TYPE_CAPABILITY + {IR(8869, 28), 204}, // 427 TileImageColorReadAccessEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(8897, 28), 205}, // 428 TileImageDepthReadAccessEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(8925, 30), 206}, // 429 TileImageStencilReadAccessEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(5986, 16), 247}, // 430 TileShadingQCOM in SPV_OPERAND_TYPE_CAPABILITY + {IR(8569, 18), 184}, // 431 TransformFeedback in SPV_OPERAND_TYPE_CAPABILITY + {IR(12953, 23), 360}, // 432 USMStorageClassesINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(9327, 35), 222}, // 433 UniformAndStorageBuffer16BitAccess in SPV_OPERAND_TYPE_CAPABILITY + {IR(9538, 34), 232}, // 434 UniformAndStorageBuffer8BitAccess in SPV_OPERAND_TYPE_CAPABILITY + {IR(8186, 34), 159}, // 435 UniformBufferArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(10670, 37), 283}, // 436 UniformBufferArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(10707, 40), 283}, // 437 UniformBufferArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(8851, 18), 202}, // 438 UniformDecoration in SPV_OPERAND_TYPE_CAPABILITY + {IR(10508, 39), 281}, // 439 UniformTexelBufferArrayDynamicIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(10547, 42), 281}, // 440 UniformTexelBufferArrayDynamicIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(11055, 42), 288}, // 441 UniformTexelBufferArrayNonUniformIndexing in SPV_OPERAND_TYPE_CAPABILITY + {IR(11097, 45), 288}, // 442 UniformTexelBufferArrayNonUniformIndexingEXT in SPV_OPERAND_TYPE_CAPABILITY + {IR(12644, 30), 348}, // 443 UnstructuredLoopControlsINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(9718, 19), 241}, // 444 UntypedPointersKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(13880, 32), 399}, // 445 UntypedVariableLengthArrayINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12478, 25), 342}, // 446 VariableLengthArrayINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(9452, 17), 228}, // 447 VariablePointers in SPV_OPERAND_TYPE_CAPABILITY + {IR(9422, 30), 227}, // 448 VariablePointersStorageBuffer in SPV_OPERAND_TYPE_CAPABILITY + {IR(7944, 9), 140}, // 449 Vector16 in SPV_OPERAND_TYPE_CAPABILITY + {IR(12337, 15), 337}, // 450 VectorAnyINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(12318, 19), 336}, // 451 VectorComputeINTEL in SPV_OPERAND_TYPE_CAPABILITY + {IR(11229, 18), 293}, // 452 VulkanMemoryModel in SPV_OPERAND_TYPE_CAPABILITY + {IR(11268, 29), 294}, // 453 VulkanMemoryModelDeviceScope in SPV_OPERAND_TYPE_CAPABILITY + {IR(11297, 32), 294}, // 454 VulkanMemoryModelDeviceScopeKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(11247, 21), 293}, // 455 VulkanMemoryModelKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(9214, 44), 219}, // 456 WorkgroupMemoryExplicitLayout16BitAccessKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(9171, 43), 218}, // 457 WorkgroupMemoryExplicitLayout8BitAccessKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(9138, 33), 217}, // 458 WorkgroupMemoryExplicitLayoutKHR in SPV_OPERAND_TYPE_CAPABILITY + {IR(14104, 8), 409}, // 459 Address in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14112, 8), 410}, // 460 Boolean in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14120, 6), 411}, // 461 Float in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14126, 7), 412}, // 462 Signed in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14133, 11), 413}, // 463 SignedChar in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14144, 9), 414}, // 464 Unsigned in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14153, 13), 415}, // 465 UnsignedChar in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14092, 12), 408}, // 466 Unspecified in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14166, 6), 416}, // 467 Class in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE + {IR(14172, 10), 417}, // 468 Structure in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE + {IR(14182, 6), 418}, // 469 Union in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE + {IR(14203, 20), 420}, // 470 ImportedDeclaration in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY + {IR(14188, 15), 419}, // 471 ImportedModule in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY + {IR(14312, 15), 428}, // 472 FlagArtificial in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14327, 13), 429}, // 473 FlagExplicit in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14300, 12), 427}, // 474 FlagFwdDecl in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14390, 21), 433}, // 475 FlagIndirectVariable in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14283, 17), 426}, // 476 FlagIsDefinition in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14467, 16), 437}, // 477 FlagIsEnumClass in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14271, 12), 425}, // 478 FlagIsLocal in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14451, 16), 436}, // 479 FlagIsOptimized in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14244, 14), 423}, // 480 FlagIsPrivate in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14228, 16), 422}, // 481 FlagIsProtected in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14258, 13), 424}, // 482 FlagIsPublic in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14411, 20), 434}, // 483 FlagLValueReference in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14355, 18), 431}, // 484 FlagObjectPointer in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14340, 15), 430}, // 485 FlagPrototyped in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14431, 20), 435}, // 486 FlagRValueReference in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14373, 17), 432}, // 487 FlagStaticMember in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14503, 24), 439}, // 488 FlagTypePassByReference in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14483, 20), 438}, // 489 FlagTypePassByValue in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14223, 5), 421}, // 490 None in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS + {IR(14588, 9), 444}, // 491 BitPiece in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {IR(14620, 7), 448}, // 492 Constu in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {IR(14527, 6), 440}, // 493 Deref in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {IR(14627, 9), 449}, // 494 Fragment in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {IR(14538, 6), 442}, // 495 Minus in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {IR(14533, 5), 441}, // 496 Plus in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {IR(14577, 11), 443}, // 497 PlusUconst in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {IR(14609, 11), 447}, // 498 StackValue in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {IR(14597, 5), 445}, // 499 Swap in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {IR(14602, 7), 446}, // 500 Xderef in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION + {IR(14672, 11), 453}, // 501 AtomicType in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER + {IR(14636, 10), 450}, // 502 ConstType in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER + {IR(14659, 13), 452}, // 503 RestrictType in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER + {IR(14646, 13), 451}, // 504 VolatileType in SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER + {IR(14683, 10), 454}, // 505 Float16NV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14693, 10), 455}, // 506 Float32NV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14703, 10), 456}, // 507 Float64NV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14871, 12), 467}, // 508 FloatE4M3NV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14883, 12), 468}, // 509 FloatE5M2NV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14726, 14), 458}, // 510 SignedInt16NV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14740, 14), 459}, // 511 SignedInt32NV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14754, 14), 460}, // 512 SignedInt64NV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14713, 13), 457}, // 513 SignedInt8NV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14831, 19), 465}, // 514 SignedInt8PackedNV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14783, 16), 462}, // 515 UnsignedInt16NV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14799, 16), 463}, // 516 UnsignedInt32NV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14815, 16), 464}, // 517 UnsignedInt64NV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14768, 15), 461}, // 518 UnsignedInt8NV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14850, 21), 466}, // 519 UnsignedInt8PackedNV in SPV_OPERAND_TYPE_COMPONENT_TYPE + {IR(14947, 28), 472}, // 520 ColumnBlockedInterleavedARM in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT + {IR(14907, 15), 470}, // 521 ColumnMajorKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT + {IR(14922, 25), 471}, // 522 RowBlockedInterleavedARM in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT + {IR(14895, 12), 469}, // 523 RowMajorKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT + {IR(14983, 27), 474}, // 524 MatrixASignedComponentsKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS + {IR(15010, 27), 475}, // 525 MatrixBSignedComponentsKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS + {IR(15037, 27), 476}, // 526 MatrixCSignedComponentsKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS + {IR(15064, 32), 477}, // 527 MatrixResultSignedComponentsKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS + {IR(14975, 8), 473}, // 528 NoneKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS + {IR(15096, 26), 478}, // 529 SaturatingAccumulationKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS + {IR(15133, 4), 481}, // 530 2x2 in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE + {IR(15126, 7), 480}, // 531 Column in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE + {IR(15122, 4), 479}, // 532 Row in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE + {IR(15137, 11), 482}, // 533 MatrixAKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE + {IR(15159, 21), 484}, // 534 MatrixAccumulatorKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE + {IR(15148, 11), 483}, // 535 MatrixBKHR in SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE + {IR(15191, 14), 486}, // 536 ColumnMajorNV in SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT + {IR(15205, 21), 487}, // 537 InferencingOptimalNV in SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT + {IR(15180, 11), 485}, // 538 RowMajorNV in SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT + {IR(15226, 18), 488}, // 539 TrainingOptimalNV in SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT + {IR(14104, 8), 490}, // 540 Address in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14112, 8), 491}, // 541 Boolean in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14120, 6), 492}, // 542 Float in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14126, 7), 493}, // 543 Signed in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14133, 11), 494}, // 544 SignedChar in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14144, 9), 495}, // 545 Unsigned in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14153, 13), 496}, // 546 UnsignedChar in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14092, 12), 489}, // 547 Unspecified in SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14166, 6), 497}, // 548 Class in SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE + {IR(14172, 10), 498}, // 549 Structure in SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE + {IR(14182, 6), 499}, // 550 Union in SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE + {IR(14312, 15), 507}, // 551 FlagArtificial in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14327, 13), 508}, // 552 FlagExplicit in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14300, 12), 506}, // 553 FlagFwdDecl in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14390, 21), 512}, // 554 FlagIndirectVariable in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14283, 17), 505}, // 555 FlagIsDefinition in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14271, 12), 504}, // 556 FlagIsLocal in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14451, 16), 515}, // 557 FlagIsOptimized in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14244, 14), 502}, // 558 FlagIsPrivate in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14228, 16), 501}, // 559 FlagIsProtected in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14258, 13), 503}, // 560 FlagIsPublic in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14411, 20), 513}, // 561 FlagLValueReference in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14355, 18), 510}, // 562 FlagObjectPointer in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14340, 15), 509}, // 563 FlagPrototyped in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14431, 20), 514}, // 564 FlagRValueReference in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14373, 17), 511}, // 565 FlagStaticMember in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14223, 5), 500}, // 566 None in SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS + {IR(14588, 9), 520}, // 567 BitPiece in SPV_OPERAND_TYPE_DEBUG_OPERATION + {IR(14620, 7), 524}, // 568 Constu in SPV_OPERAND_TYPE_DEBUG_OPERATION + {IR(14527, 6), 516}, // 569 Deref in SPV_OPERAND_TYPE_DEBUG_OPERATION + {IR(14538, 6), 518}, // 570 Minus in SPV_OPERAND_TYPE_DEBUG_OPERATION + {IR(14533, 5), 517}, // 571 Plus in SPV_OPERAND_TYPE_DEBUG_OPERATION + {IR(14577, 11), 519}, // 572 PlusUconst in SPV_OPERAND_TYPE_DEBUG_OPERATION + {IR(14609, 11), 523}, // 573 StackValue in SPV_OPERAND_TYPE_DEBUG_OPERATION + {IR(14597, 5), 521}, // 574 Swap in SPV_OPERAND_TYPE_DEBUG_OPERATION + {IR(14602, 7), 522}, // 575 Xderef in SPV_OPERAND_TYPE_DEBUG_OPERATION + {IR(14636, 10), 525}, // 576 ConstType in SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER + {IR(14659, 13), 527}, // 577 RestrictType in SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER + {IR(14646, 13), 526}, // 578 VolatileType in SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER + {IR(17468, 16), 642}, // 579 AliasScopeINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15453, 8), 547}, // 580 Aliased in SPV_OPERAND_TYPE_DECORATION + {IR(16571, 15), 600}, // 581 AliasedPointer in SPV_OPERAND_TYPE_DECORATION + {IR(16586, 18), 600}, // 582 AliasedPointerEXT in SPV_OPERAND_TYPE_DECORATION + {IR(15931, 10), 571}, // 583 Alignment in SPV_OPERAND_TYPE_DECORATION + {IR(15975, 12), 573}, // 584 AlignmentId in SPV_OPERAND_TYPE_DECORATION + {IR(15304, 12), 534}, // 585 ArrayStride in SPV_OPERAND_TYPE_DECORATION + {IR(17249, 14), 630}, // 586 BankBitsINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17088, 15), 623}, // 587 BankwidthINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15608, 8), 560}, // 588 Binding in SPV_OPERAND_TYPE_DECORATION + {IR(16652, 16), 603}, // 589 BindlessImageNV in SPV_OPERAND_TYPE_DECORATION + {IR(16634, 18), 602}, // 590 BindlessSamplerNV in SPV_OPERAND_TYPE_DECORATION + {IR(15268, 6), 530}, // 591 Block in SPV_OPERAND_TYPE_DECORATION + {IR(16115, 22), 580}, // 592 BlockMatchSamplerQCOM in SPV_OPERAND_TYPE_DECORATION + {IR(16093, 22), 579}, // 593 BlockMatchTextureQCOM in SPV_OPERAND_TYPE_DECORATION + {IR(16683, 13), 605}, // 594 BoundImageNV in SPV_OPERAND_TYPE_DECORATION + {IR(16668, 15), 604}, // 595 BoundSamplerNV in SPV_OPERAND_TYPE_DECORATION + {IR(15274, 12), 531}, // 596 BufferBlock in SPV_OPERAND_TYPE_DECORATION + {IR(17561, 20), 647}, // 597 BufferLocationINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15385, 8), 539}, // 598 BuiltIn in SPV_OPERAND_TYPE_DECORATION + {IR(17331, 19), 635}, // 599 BurstCoalesceINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15351, 8), 538}, // 600 CPacked in SPV_OPERAND_TYPE_DECORATION + {IR(18371, 22), 670}, // 601 CacheControlLoadINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(18430, 23), 671}, // 602 CacheControlStoreINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17350, 15), 636}, // 603 CacheSizeINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15418, 9), 543}, // 604 Centroid in SPV_OPERAND_TYPE_DECORATION + {IR(16736, 13), 608}, // 605 ClobberINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15479, 9), 550}, // 606 Coherent in SPV_OPERAND_TYPE_DECORATION + {IR(15295, 9), 533}, // 607 ColMajor in SPV_OPERAND_TYPE_DECORATION + {IR(15592, 10), 558}, // 608 Component in SPV_OPERAND_TYPE_DECORATION + {IR(18318, 17), 669}, // 609 ConditionalINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17870, 27), 657}, // 610 ConduitKernelArgumentINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15470, 9), 549}, // 611 Constant in SPV_OPERAND_TYPE_DECORATION + {IR(16882, 14), 615}, // 612 CounterBuffer in SPV_OPERAND_TYPE_DECORATION + {IR(15616, 14), 561}, // 613 DescriptorSet in SPV_OPERAND_TYPE_DECORATION + {IR(17365, 28), 637}, // 614 DontStaticallyCoalesceINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17141, 16), 626}, // 615 DoublepumpINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(16137, 18), 581}, // 616 ExplicitInterpAMD in SPV_OPERAND_TYPE_DECORATION + {IR(15801, 15), 567}, // 617 FPFastMathMode in SPV_OPERAND_TYPE_DECORATION + {IR(17789, 26), 654}, // 618 FPMaxErrorDecorationINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15751, 15), 566}, // 619 FPRoundingMode in SPV_OPERAND_TYPE_DECORATION + {IR(15407, 5), 541}, // 620 Flat in SPV_OPERAND_TYPE_DECORATION + {IR(17263, 20), 631}, // 621 ForcePow2DepthINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15703, 14), 565}, // 622 FuncParamAttr in SPV_OPERAND_TYPE_DECORATION + {IR(16793, 21), 611}, // 623 FuncParamIOKindINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17024, 24), 619}, // 624 FunctionDenormModeINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17634, 31), 649}, // 625 FunctionFloatingPointModeINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(16967, 26), 618}, // 626 FunctionRoundingModeINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17424, 25), 640}, // 627 FuseLoopsInFunctionINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15340, 11), 537}, // 628 GLSLPacked in SPV_OPERAND_TYPE_DECORATION + {IR(15329, 11), 536}, // 629 GLSLShared in SPV_OPERAND_TYPE_DECORATION + {IR(16856, 26), 614}, // 630 GlobalVariableOffsetINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(16604, 30), 601}, // 631 HitObjectShaderRecordBufferNV in SPV_OPERAND_TYPE_DECORATION + {IR(16896, 24), 615}, // 632 HlslCounterBufferGOOGLE in SPV_OPERAND_TYPE_DECORATION + {IR(16933, 19), 616}, // 633 HlslSemanticGOOGLE in SPV_OPERAND_TYPE_DECORATION + {IR(18213, 16), 666}, // 634 HostAccessINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17581, 19), 648}, // 635 IOPipeStorageINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(18290, 28), 668}, // 636 ImplementInRegisterMapINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15602, 6), 559}, // 637 Index in SPV_OPERAND_TYPE_DECORATION + {IR(18276, 14), 667}, // 638 InitModeINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17497, 24), 644}, // 639 InitiationIntervalINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15910, 21), 570}, // 640 InputAttachmentIndex in SPV_OPERAND_TYPE_DECORATION + {IR(15434, 10), 545}, // 641 Invariant in SPV_OPERAND_TYPE_DECORATION + {IR(17840, 30), 656}, // 642 LatencyControlConstraintINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17815, 25), 655}, // 643 LatencyControlLabelINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15878, 18), 568}, // 644 LinkageAttributes in SPV_OPERAND_TYPE_DECORATION + {IR(15583, 9), 557}, // 645 Location in SPV_OPERAND_TYPE_DECORATION + {IR(17928, 33), 659}, // 646 MMHostInterfaceAddressWidthINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17961, 30), 660}, // 647 MMHostInterfaceDataWidthINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17991, 28), 661}, // 648 MMHostInterfaceLatencyINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(18087, 29), 663}, // 649 MMHostInterfaceMaxBurstINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(18053, 34), 662}, // 650 MMHostInterfaceReadWriteModeINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(18116, 32), 664}, // 651 MMHostInterfaceWaitRequestINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17449, 19), 641}, // 652 MathOpDSPModeINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15316, 13), 535}, // 653 MatrixStride in SPV_OPERAND_TYPE_DECORATION + {IR(15941, 14), 572}, // 654 MaxByteOffset in SPV_OPERAND_TYPE_DECORATION + {IR(15987, 16), 574}, // 655 MaxByteOffsetId in SPV_OPERAND_TYPE_DECORATION + {IR(17521, 20), 645}, // 656 MaxConcurrencyINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17103, 22), 624}, // 657 MaxPrivateCopiesINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17157, 19), 627}, // 658 MaxReplicatesINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17725, 18), 652}, // 659 MediaBlockIOINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17062, 12), 621}, // 660 MemoryINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17196, 11), 629}, // 661 MergeINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17484, 13), 643}, // 662 NoAliasINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15896, 14), 569}, // 663 NoContraction in SPV_OPERAND_TYPE_DECORATION + {IR(15393, 14), 540}, // 664 NoPerspective in SPV_OPERAND_TYPE_DECORATION + {IR(16047, 13), 576}, // 665 NoSignedWrap in SPV_OPERAND_TYPE_DECORATION + {IR(16060, 15), 577}, // 666 NoUnsignedWrap in SPV_OPERAND_TYPE_DECORATION + {IR(16187, 20), 583}, // 667 NodeMaxPayloadsAMDX in SPV_OPERAND_TYPE_DECORATION + {IR(16155, 32), 582}, // 668 NodeSharesPayloadLimitsWithAMDX in SPV_OPERAND_TYPE_DECORATION + {IR(15500, 12), 552}, // 669 NonReadable in SPV_OPERAND_TYPE_DECORATION + {IR(16511, 11), 598}, // 670 NonUniform in SPV_OPERAND_TYPE_DECORATION + {IR(16522, 14), 598}, // 671 NonUniformEXT in SPV_OPERAND_TYPE_DECORATION + {IR(15488, 12), 551}, // 672 NonWritable in SPV_OPERAND_TYPE_DECORATION + {IR(17074, 14), 622}, // 673 NumbanksINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15630, 7), 562}, // 674 Offset in SPV_OPERAND_TYPE_DECORATION + {IR(16355, 19), 590}, // 675 OverrideCoverageNV in SPV_OPERAND_TYPE_DECORATION + {IR(16374, 14), 591}, // 676 PassthroughNV in SPV_OPERAND_TYPE_DECORATION + {IR(15412, 6), 542}, // 677 Patch in SPV_OPERAND_TYPE_DECORATION + {IR(16327, 28), 589}, // 678 PayloadDispatchIndirectAMDX in SPV_OPERAND_TYPE_DECORATION + {IR(16302, 25), 588}, // 679 PayloadNodeArraySizeAMDX in SPV_OPERAND_TYPE_DECORATION + {IR(16250, 25), 586}, // 680 PayloadNodeBaseIndexAMDX in SPV_OPERAND_TYPE_DECORATION + {IR(16230, 20), 585}, // 681 PayloadNodeNameAMDX in SPV_OPERAND_TYPE_DECORATION + {IR(16275, 27), 587}, // 682 PayloadNodeSparseArrayAMDX in SPV_OPERAND_TYPE_DECORATION + {IR(16435, 16), 594}, // 683 PerPrimitiveEXT in SPV_OPERAND_TYPE_DECORATION + {IR(16451, 15), 594}, // 684 PerPrimitiveNV in SPV_OPERAND_TYPE_DECORATION + {IR(16476, 10), 596}, // 685 PerTaskNV in SPV_OPERAND_TYPE_DECORATION + {IR(16486, 13), 597}, // 686 PerVertexKHR in SPV_OPERAND_TYPE_DECORATION + {IR(16499, 12), 597}, // 687 PerVertexNV in SPV_OPERAND_TYPE_DECORATION + {IR(16466, 10), 595}, // 688 PerViewNV in SPV_OPERAND_TYPE_DECORATION + {IR(17541, 20), 646}, // 689 PipelineEnableINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17393, 14), 638}, // 690 PrefetchINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(16710, 26), 607}, // 691 ReferencedIndirectlyINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17048, 14), 620}, // 692 RegisterINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17897, 31), 658}, // 693 RegisterMapKernelArgumentINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15244, 17), 528}, // 694 RelaxedPrecision in SPV_OPERAND_TYPE_DECORATION + {IR(15444, 9), 546}, // 695 Restrict in SPV_OPERAND_TYPE_DECORATION + {IR(16536, 16), 599}, // 696 RestrictPointer in SPV_OPERAND_TYPE_DECORATION + {IR(16552, 19), 599}, // 697 RestrictPointerEXT in SPV_OPERAND_TYPE_DECORATION + {IR(15286, 9), 532}, // 698 RowMajor in SPV_OPERAND_TYPE_DECORATION + {IR(16696, 14), 606}, // 699 SIMTCallINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15427, 7), 544}, // 700 Sample in SPV_OPERAND_TYPE_DECORATION + {IR(15556, 20), 555}, // 701 SaturatedConversion in SPV_OPERAND_TYPE_DECORATION + {IR(16003, 44), 575}, // 702 SaturatedToLargestFloat8NormalConversionEXT in SPV_OPERAND_TYPE_DECORATION + {IR(16407, 28), 593}, // 703 SecondaryViewportRelativeNV in SPV_OPERAND_TYPE_DECORATION + {IR(16749, 17), 609}, // 704 SideEffectsINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17176, 20), 628}, // 705 SimpleDualPortINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17665, 25), 650}, // 706 SingleElementVectorINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17125, 16), 625}, // 707 SinglepumpINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15261, 7), 529}, // 708 SpecId in SPV_OPERAND_TYPE_DECORATION + {IR(18148, 26), 665}, // 709 StableKernelArgumentINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(16841, 15), 613}, // 710 StackCallINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17407, 17), 639}, // 711 StallEnableINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(17743, 15), 653}, // 712 StallFreeINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15576, 7), 556}, // 713 Stream in SPV_OPERAND_TYPE_DECORATION + {IR(17283, 16), 632}, // 714 StridesizeINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(16207, 23), 584}, // 715 TrackFinishWritingAMDX in SPV_OPERAND_TYPE_DECORATION + {IR(17313, 18), 634}, // 716 TrueDualPortINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15512, 8), 553}, // 717 Uniform in SPV_OPERAND_TYPE_DECORATION + {IR(15546, 10), 554}, // 718 UniformId in SPV_OPERAND_TYPE_DECORATION + {IR(16920, 13), 616}, // 719 UserSemantic in SPV_OPERAND_TYPE_DECORATION + {IR(16952, 15), 617}, // 720 UserTypeGOOGLE in SPV_OPERAND_TYPE_DECORATION + {IR(17690, 35), 651}, // 721 VectorComputeCallableFunctionINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(16814, 27), 612}, // 722 VectorComputeFunctionINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(16766, 27), 610}, // 723 VectorComputeVariableINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(16388, 19), 592}, // 724 ViewportRelativeNV in SPV_OPERAND_TYPE_DECORATION + {IR(15461, 9), 548}, // 725 Volatile in SPV_OPERAND_TYPE_DECORATION + {IR(16075, 18), 578}, // 726 WeightTextureQCOM in SPV_OPERAND_TYPE_DECORATION + {IR(17299, 14), 633}, // 727 WordsizeINTEL in SPV_OPERAND_TYPE_DECORATION + {IR(15637, 10), 563}, // 728 XfbBuffer in SPV_OPERAND_TYPE_DECORATION + {IR(15647, 10), 564}, // 729 XfbStride in SPV_OPERAND_TYPE_DECORATION + {IR(18453, 3), 672}, // 730 1D in SPV_OPERAND_TYPE_DIMENSIONALITY + {IR(18456, 3), 673}, // 731 2D in SPV_OPERAND_TYPE_DIMENSIONALITY + {IR(18459, 3), 674}, // 732 3D in SPV_OPERAND_TYPE_DIMENSIONALITY + {IR(18472, 7), 677}, // 733 Buffer in SPV_OPERAND_TYPE_DIMENSIONALITY + {IR(18462, 5), 675}, // 734 Cube in SPV_OPERAND_TYPE_DIMENSIONALITY + {IR(18467, 5), 676}, // 735 Rect in SPV_OPERAND_TYPE_DIMENSIONALITY + {IR(18479, 12), 678}, // 736 SubpassData in SPV_OPERAND_TYPE_DIMENSIONALITY + {IR(18491, 17), 679}, // 737 TileImageDataEXT in SPV_OPERAND_TYPE_DIMENSIONALITY + {IR(19303, 15), 732}, // 738 CoalescingAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18934, 15), 710}, // 739 ContractionOff in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(9608, 18), 724}, // 740 DenormFlushToZero in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(9593, 15), 723}, // 741 DenormPreserve in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18704, 13), 693}, // 742 DepthGreater in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18717, 10), 694}, // 743 DepthLess in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18689, 15), 692}, // 744 DepthReplacing in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18727, 15), 695}, // 745 DepthUnchanged in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19724, 25), 750}, // 746 DerivativeGroupLinearKHR in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19749, 24), 750}, // 747 DerivativeGroupLinearNV in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19677, 24), 749}, // 748 DerivativeGroupQuadsKHR in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19701, 23), 749}, // 749 DerivativeGroupQuadsNV in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19251, 29), 730}, // 750 EarlyAndLateFragmentTestsAMD in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18656, 19), 689}, // 751 EarlyFragmentTests in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20234, 18), 769}, // 752 FPFastMathDefault in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18961, 10), 712}, // 753 Finalizer in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20049, 26), 761}, // 754 FloatingPointModeALTINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20075, 27), 762}, // 755 FloatingPointModeIEEEINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18949, 12), 711}, // 756 Initializer in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18778, 11), 699}, // 757 InputLines in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18789, 20), 700}, // 758 InputLinesAdjacency in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18766, 12), 698}, // 759 InputPoints in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18819, 24), 702}, // 760 InputTrianglesAdjacency in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18508, 12), 680}, // 761 Invocations in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19318, 15), 733}, // 762 IsApiEntryAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18849, 9), 704}, // 763 Isolines in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18742, 10), 696}, // 764 LocalSize in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18752, 14), 697}, // 765 LocalSizeHint in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19029, 16), 717}, // 766 LocalSizeHintId in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19017, 12), 716}, // 767 LocalSizeId in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19333, 21), 734}, // 768 MaxNodeRecursionAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19378, 21), 737}, // 769 MaxNumWorkgroupsAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20124, 16), 764}, // 770 MaxWorkDimINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20102, 22), 763}, // 771 MaxWorkgroupSizeINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20210, 24), 768}, // 772 MaximallyReconvergesKHR in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20325, 22), 773}, // 773 MaximumRegistersINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20347, 24), 774}, // 774 MaximumRegistersIdINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20302, 23), 772}, // 775 NamedBarrierCountINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20422, 27), 775}, // 776 NamedMaximumRegistersINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20140, 20), 765}, // 777 NoGlobalOffsetINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19045, 34), 718}, // 778 NonCoherentColorAttachmentReadEXT in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19079, 34), 719}, // 779 NonCoherentDepthAttachmentReadEXT in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19113, 36), 720}, // 780 NonCoherentStencilAttachmentReadEXT in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19197, 34), 728}, // 781 NonCoherentTileAttachmentReadQCOM in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20160, 22), 766}, // 782 NumSIMDWorkitemsINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18640, 16), 688}, // 783 OriginLowerLeft in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18624, 16), 687}, // 784 OriginUpperLeft in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18886, 16), 707}, // 785 OutputLineStrip in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19609, 15), 747}, // 786 OutputLinesEXT in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19624, 14), 747}, // 787 OutputLinesNV in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18873, 13), 706}, // 788 OutputPoints in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19638, 20), 748}, // 789 OutputPrimitivesEXT in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19658, 19), 748}, // 790 OutputPrimitivesNV in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18902, 20), 708}, // 791 OutputTriangleStrip in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19773, 19), 751}, // 792 OutputTrianglesEXT in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19792, 18), 751}, // 793 OutputTrianglesNV in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18858, 15), 705}, // 794 OutputVertices in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18605, 19), 686}, // 795 PixelCenterInteger in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19810, 25), 752}, // 796 PixelInterlockOrderedEXT in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19835, 27), 753}, // 797 PixelInterlockUnorderedEXT in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18675, 10), 690}, // 798 PointMode in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19179, 18), 722}, // 799 PostDepthCoverage in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19550, 19), 744}, // 800 QuadDerivativesKHR in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18843, 6), 703}, // 801 Quads in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20276, 26), 771}, // 802 RegisterMapInterfaceINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19569, 20), 745}, // 803 RequireFullQuadsKHR in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(9651, 16), 726}, // 804 RoundingModeRTE in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20028, 21), 760}, // 805 RoundingModeRTNINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20007, 21), 759}, // 806 RoundingModeRTPINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(9667, 16), 727}, // 807 RoundingModeRTZ in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19862, 26), 754}, // 808 SampleInterlockOrderedEXT in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19888, 28), 755}, // 809 SampleInterlockUnorderedEXT in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20182, 28), 767}, // 810 SchedulerTargetFmaxMhzINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(6287, 16), 736}, // 811 ShaderIndexAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19916, 31), 756}, // 812 ShadingRateInterlockOrderedEXT in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19947, 33), 757}, // 813 ShadingRateInterlockUnorderedEXT in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19980, 27), 758}, // 814 SharedLocalMemorySizeINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19589, 20), 746}, // 815 SharesInputWithAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(9626, 25), 725}, // 816 SignedZeroInfNanPreserve in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18520, 13), 681}, // 817 SpacingEqual in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18533, 22), 682}, // 818 SpacingFractionalEven in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18555, 21), 683}, // 819 SpacingFractionalOdd in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19354, 24), 735}, // 820 StaticNumWorkgroupsAMDX in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19503, 25), 742}, // 821 StencilRefGreaterBackAMD in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19427, 26), 739}, // 822 StencilRefGreaterFrontAMD in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19528, 22), 743}, // 823 StencilRefLessBackAMD in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19453, 23), 740}, // 824 StencilRefLessFrontAMD in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19280, 23), 731}, // 825 StencilRefReplacingEXT in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19476, 27), 741}, // 826 StencilRefUnchangedBackAMD in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19399, 28), 738}, // 827 StencilRefUnchangedFrontAMD in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20252, 24), 770}, // 828 StreamingInterfaceINTEL in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(5394, 13), 713}, // 829 SubgroupSize in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19149, 30), 721}, // 830 SubgroupUniformControlFlowKHR in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18971, 22), 714}, // 831 SubgroupsPerWorkgroup in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18993, 24), 715}, // 832 SubgroupsPerWorkgroupId in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(19231, 20), 729}, // 833 TileShadingRateQCOM in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18809, 10), 701}, // 834 Triangles in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18922, 12), 709}, // 835 VecTypeHint in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18590, 15), 685}, // 836 VertexOrderCcw in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18576, 14), 684}, // 837 VertexOrderCw in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(18685, 4), 691}, // 838 Xfb in SPV_OPERAND_TYPE_EXECUTION_MODE + {IR(20587, 10), 787}, // 839 AnyHitKHR in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20597, 9), 787}, // 840 AnyHitNV in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20648, 12), 790}, // 841 CallableKHR in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20660, 11), 790}, // 842 CallableNV in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20606, 14), 788}, // 843 ClosestHitKHR in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20620, 13), 788}, // 844 ClosestHitNV in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(14627, 9), 780}, // 845 Fragment in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20499, 10), 781}, // 846 GLCompute in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(4875, 9), 779}, // 847 Geometry in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20556, 16), 786}, // 848 IntersectionKHR in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20572, 15), 786}, // 849 IntersectionNV in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(4642, 7), 782}, // 850 Kernel in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20679, 8), 792}, // 851 MeshEXT in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20516, 7), 784}, // 852 MeshNV in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20633, 8), 789}, // 853 MissKHR in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20641, 7), 789}, // 854 MissNV in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20523, 17), 785}, // 855 RayGenerationKHR in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20540, 16), 785}, // 856 RayGenerationNV in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20671, 8), 791}, // 857 TaskEXT in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20509, 7), 783}, // 858 TaskNV in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20456, 20), 777}, // 859 TessellationControl in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20476, 23), 778}, // 860 TessellationEvaluation in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20449, 7), 776}, // 861 Vertex in SPV_OPERAND_TYPE_EXECUTION_MODEL + {IR(20696, 12), 794}, // 862 FlushToZero in SPV_OPERAND_TYPE_FPDENORM_MODE + {IR(20687, 9), 793}, // 863 Preserve in SPV_OPERAND_TYPE_FPDENORM_MODE + {IR(20708, 12), 795}, // 864 BFloat16KHR in SPV_OPERAND_TYPE_FPENCODING + {IR(20720, 14), 796}, // 865 Float8E4M3EXT in SPV_OPERAND_TYPE_FPENCODING + {IR(20734, 14), 797}, // 866 Float8E5M2EXT in SPV_OPERAND_TYPE_FPENCODING + {IR(20753, 4), 799}, // 867 ALT in SPV_OPERAND_TYPE_FPOPERATION_MODE + {IR(20748, 5), 798}, // 868 IEEE in SPV_OPERAND_TYPE_FPOPERATION_MODE + {IR(20791, 14), 806}, // 869 AllowContract in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {IR(20805, 23), 806}, // 870 AllowContractFastINTEL in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {IR(20828, 13), 807}, // 871 AllowReassoc in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {IR(20841, 18), 807}, // 872 AllowReassocINTEL in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {IR(20775, 11), 804}, // 873 AllowRecip in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {IR(20859, 15), 808}, // 874 AllowTransform in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {IR(20786, 5), 805}, // 875 Fast in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {IR(20771, 4), 803}, // 876 NSZ in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {IR(14223, 5), 800}, // 877 None in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {IR(20764, 7), 802}, // 878 NotInf in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {IR(20757, 7), 801}, // 879 NotNaN in SPV_OPERAND_TYPE_FP_FAST_MATH_MODE + {IR(20874, 4), 809}, // 880 RTE in SPV_OPERAND_TYPE_FP_ROUNDING_MODE + {IR(20886, 4), 812}, // 881 RTN in SPV_OPERAND_TYPE_FP_ROUNDING_MODE + {IR(20882, 4), 811}, // 882 RTP in SPV_OPERAND_TYPE_FP_ROUNDING_MODE + {IR(20878, 4), 810}, // 883 RTZ in SPV_OPERAND_TYPE_FP_ROUNDING_MODE + {IR(20922, 18), 815}, // 884 Horizontal2Pixels in SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE + {IR(20940, 18), 816}, // 885 Horizontal4Pixels in SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE + {IR(20890, 16), 813}, // 886 Vertical2Pixels in SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE + {IR(20906, 16), 814}, // 887 Vertical4Pixels in SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE + {IR(20981, 6), 821}, // 888 Const in SPV_OPERAND_TYPE_FUNCTION_CONTROL + {IR(20965, 11), 819}, // 889 DontInline in SPV_OPERAND_TYPE_FUNCTION_CONTROL + {IR(20958, 7), 818}, // 890 Inline in SPV_OPERAND_TYPE_FUNCTION_CONTROL + {IR(14223, 5), 817}, // 891 None in SPV_OPERAND_TYPE_FUNCTION_CONTROL + {IR(13369, 11), 822}, // 892 OptNoneEXT in SPV_OPERAND_TYPE_FUNCTION_CONTROL + {IR(13380, 13), 822}, // 893 OptNoneINTEL in SPV_OPERAND_TYPE_FUNCTION_CONTROL + {IR(20976, 5), 820}, // 894 Pure in SPV_OPERAND_TYPE_FUNCTION_CONTROL + {IR(20997, 6), 825}, // 895 ByVal in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {IR(21008, 8), 827}, // 896 NoAlias in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {IR(21016, 10), 828}, // 897 NoCapture in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {IR(21034, 12), 830}, // 898 NoReadWrite in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {IR(21026, 8), 829}, // 899 NoWrite in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {IR(21046, 20), 831}, // 900 RuntimeAlignedINTEL in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {IR(20992, 5), 824}, // 901 Sext in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {IR(21003, 5), 826}, // 902 Sret in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {IR(20987, 5), 823}, // 903 Zext in SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE + {IR(21101, 16), 835}, // 904 ClusteredReduce in SPV_OPERAND_TYPE_GROUP_OPERATION + {IR(21087, 14), 834}, // 905 ExclusiveScan in SPV_OPERAND_TYPE_GROUP_OPERATION + {IR(21073, 14), 833}, // 906 InclusiveScan in SPV_OPERAND_TYPE_GROUP_OPERATION + {IR(21164, 27), 838}, // 907 PartitionedExclusiveScanNV in SPV_OPERAND_TYPE_GROUP_OPERATION + {IR(21137, 27), 837}, // 908 PartitionedInclusiveScanNV in SPV_OPERAND_TYPE_GROUP_OPERATION + {IR(21117, 20), 836}, // 909 PartitionedReduceNV in SPV_OPERAND_TYPE_GROUP_OPERATION + {IR(21066, 7), 832}, // 910 Reduce in SPV_OPERAND_TYPE_GROUP_OPERATION + {IR(21191, 10), 839}, // 911 NoneINTEL in SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER + {IR(21201, 10), 840}, // 912 ReadINTEL in SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER + {IR(21222, 15), 842}, // 913 ReadWriteINTEL in SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER + {IR(21211, 11), 841}, // 914 WriteINTEL in SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER + {IR(21237, 5), 844}, // 915 Bias in SPV_OPERAND_TYPE_IMAGE + {IR(21251, 12), 847}, // 916 ConstOffset in SPV_OPERAND_TYPE_IMAGE + {IR(21263, 13), 849}, // 917 ConstOffsets in SPV_OPERAND_TYPE_IMAGE + {IR(21246, 5), 846}, // 918 Grad in SPV_OPERAND_TYPE_IMAGE + {IR(21242, 4), 845}, // 919 Lod in SPV_OPERAND_TYPE_IMAGE + {IR(21276, 19), 852}, // 920 MakeTexelAvailable in SPV_OPERAND_TYPE_IMAGE + {IR(21295, 22), 852}, // 921 MakeTexelAvailableKHR in SPV_OPERAND_TYPE_IMAGE + {IR(21317, 17), 853}, // 922 MakeTexelVisible in SPV_OPERAND_TYPE_IMAGE + {IR(21334, 20), 853}, // 923 MakeTexelVisibleKHR in SPV_OPERAND_TYPE_IMAGE + {IR(8426, 7), 851}, // 924 MinLod in SPV_OPERAND_TYPE_IMAGE + {IR(21354, 16), 854}, // 925 NonPrivateTexel in SPV_OPERAND_TYPE_IMAGE + {IR(21370, 19), 854}, // 926 NonPrivateTexelKHR in SPV_OPERAND_TYPE_IMAGE + {IR(14223, 5), 843}, // 927 None in SPV_OPERAND_TYPE_IMAGE + {IR(21442, 12), 858}, // 928 Nontemporal in SPV_OPERAND_TYPE_IMAGE + {IR(15630, 7), 848}, // 929 Offset in SPV_OPERAND_TYPE_IMAGE + {IR(21454, 8), 859}, // 930 Offsets in SPV_OPERAND_TYPE_IMAGE + {IR(15427, 7), 850}, // 931 Sample in SPV_OPERAND_TYPE_IMAGE + {IR(21420, 11), 856}, // 932 SignExtend in SPV_OPERAND_TYPE_IMAGE + {IR(21389, 14), 855}, // 933 VolatileTexel in SPV_OPERAND_TYPE_IMAGE + {IR(21403, 17), 855}, // 934 VolatileTexelKHR in SPV_OPERAND_TYPE_IMAGE + {IR(21431, 11), 857}, // 935 ZeroExtend in SPV_OPERAND_TYPE_IMAGE + {IR(14120, 6), 874}, // 936 Float in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21623, 10), 873}, // 937 HalfFloat in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21558, 12), 868}, // 938 SignedInt16 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21570, 12), 869}, // 939 SignedInt32 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21547, 11), 867}, // 940 SignedInt8 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21472, 11), 861}, // 941 SnormInt16 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21462, 10), 860}, // 942 SnormInt8 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21532, 15), 866}, // 943 UnormInt101010 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21644, 17), 876}, // 944 UnormInt101010_2 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21661, 16), 877}, // 945 UnormInt10X6EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21794, 16), 884}, // 946 UnormInt12X4EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21810, 16), 885}, // 947 UnormInt14X2EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21493, 11), 863}, // 948 UnormInt16 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21633, 11), 875}, // 949 UnormInt24 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21717, 20), 880}, // 950 UnormInt2_101010EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21483, 10), 862}, // 951 UnormInt8 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21518, 14), 865}, // 952 UnormShort555 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21504, 14), 864}, // 953 UnormShort565 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21737, 19), 881}, // 954 UnsignedInt10X6EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21756, 19), 882}, // 955 UnsignedInt12X4EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21775, 19), 883}, // 956 UnsignedInt14X2EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21595, 14), 871}, // 957 UnsignedInt16 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21609, 14), 872}, // 958 UnsignedInt32 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21582, 13), 870}, // 959 UnsignedInt8 in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21677, 20), 878}, // 960 UnsignedIntRaw10EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21697, 20), 879}, // 961 UnsignedIntRaw12EXT in SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE + {IR(21828, 2), 887}, // 962 A in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21929, 5), 905}, // 963 ABGR in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21850, 5), 893}, // 964 ARGB in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21845, 5), 892}, // 965 BGRA in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21887, 6), 899}, // 966 Depth in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21893, 13), 900}, // 967 DepthStencil in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21855, 10), 894}, // 968 Intensity in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21865, 10), 895}, // 969 Luminance in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21826, 2), 886}, // 970 R in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21833, 3), 889}, // 971 RA in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21830, 3), 888}, // 972 RG in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21836, 4), 890}, // 973 RGB in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21840, 5), 891}, // 974 RGBA in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21882, 5), 898}, // 975 RGBx in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21878, 4), 897}, // 976 RGx in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21875, 3), 896}, // 977 Rx in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21923, 6), 904}, // 978 sBGRA in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21906, 5), 901}, // 979 sRGB in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21917, 6), 903}, // 980 sRGBA in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21911, 6), 902}, // 981 sRGBx in SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER + {IR(21934, 27), 906}, // 982 InitOnDeviceReprogramINTEL in SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER + {IR(21961, 23), 907}, // 983 InitOnDeviceResetINTEL in SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER + {IR(21984, 7), 908}, // 984 NoWait in SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS + {IR(21991, 11), 909}, // 985 WaitKernel in SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS + {IR(22002, 14), 910}, // 986 WaitWorkGroup in SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS + {IR(22016, 12), 912}, // 987 CmdExecTime in SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO + {IR(14223, 5), 911}, // 988 None in SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO + {IR(22028, 13), 914}, // 989 MayUsePrintf in SPV_OPERAND_TYPE_KERNEL_PROPERTY_FLAGS + {IR(14223, 5), 913}, // 990 None in SPV_OPERAND_TYPE_KERNEL_PROPERTY_FLAGS + {IR(22041, 7), 915}, // 991 Export in SPV_OPERAND_TYPE_LINKAGE_TYPE + {IR(22048, 7), 916}, // 992 Import in SPV_OPERAND_TYPE_LINKAGE_TYPE + {IR(22055, 12), 917}, // 993 LinkOnceODR in SPV_OPERAND_TYPE_LINKAGE_TYPE + {IR(22081, 12), 919}, // 994 CachedINTEL in SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL + {IR(22133, 17), 922}, // 995 ConstCachedINTEL in SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL + {IR(22108, 25), 921}, // 996 InvalidateAfterReadINTEL in SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL + {IR(22093, 15), 920}, // 997 StreamingINTEL in SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL + {IR(22067, 14), 918}, // 998 UncachedINTEL in SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL + {IR(22273, 21), 935}, // 999 DependencyArrayINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22168, 19), 926}, // 1000 DependencyInfinite in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22187, 17), 927}, // 1001 DependencyLength in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22157, 11), 925}, // 1002 DontUnroll in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(17497, 24), 933}, // 1003 InitiationIntervalINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22232, 18), 930}, // 1004 IterationMultiple in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22294, 18), 937}, // 1005 LoopCoalesceINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22373, 15), 941}, // 1006 LoopCountINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(17521, 20), 934}, // 1007 MaxConcurrencyINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22312, 21), 938}, // 1008 MaxInterleavingINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22218, 14), 929}, // 1009 MaxIterations in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22388, 26), 942}, // 1010 MaxReinvocationDelayINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22204, 14), 928}, // 1011 MinIterations in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22359, 14), 940}, // 1012 NoFusionINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(14223, 5), 923}, // 1013 None in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22260, 13), 932}, // 1014 PartialCount in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22250, 10), 931}, // 1015 PeelCount in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(17541, 20), 936}, // 1016 PipelineEnableINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22333, 26), 939}, // 1017 SpeculatedIterationsINTEL in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22150, 7), 924}, // 1018 Unroll in SPV_OPERAND_TYPE_LOOP_CONTROL + {IR(22697, 27), 956}, // 1019 MatrixAPackedBFloat16INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22645, 26), 954}, // 1020 MatrixAPackedFloat16INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22565, 23), 950}, // 1021 MatrixAPackedInt4INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22519, 23), 948}, // 1022 MatrixAPackedInt8INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22414, 29), 944}, // 1023 MatrixASignedComponentsINTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22611, 17), 952}, // 1024 MatrixATF32INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22724, 27), 957}, // 1025 MatrixBPackedBFloat16INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22671, 26), 955}, // 1026 MatrixBPackedFloat16INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22588, 23), 951}, // 1027 MatrixBPackedInt4INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22542, 23), 949}, // 1028 MatrixBPackedInt8INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22443, 29), 945}, // 1029 MatrixBSignedComponentsINTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22628, 17), 953}, // 1030 MatrixBTF32INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22472, 21), 946}, // 1031 MatrixCBFloat16INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22493, 26), 947}, // 1032 MatrixResultBFloat16INTEL in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(14223, 5), 943}, // 1033 None in SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS + {IR(22884, 20), 965}, // 1034 AliasScopeINTELMask in SPV_OPERAND_TYPE_MEMORY_ACCESS + {IR(22751, 8), 960}, // 1035 Aligned in SPV_OPERAND_TYPE_MEMORY_ACCESS + {IR(22759, 21), 962}, // 1036 MakePointerAvailable in SPV_OPERAND_TYPE_MEMORY_ACCESS + {IR(22780, 24), 962}, // 1037 MakePointerAvailableKHR in SPV_OPERAND_TYPE_MEMORY_ACCESS + {IR(22804, 19), 963}, // 1038 MakePointerVisible in SPV_OPERAND_TYPE_MEMORY_ACCESS + {IR(22823, 22), 963}, // 1039 MakePointerVisibleKHR in SPV_OPERAND_TYPE_MEMORY_ACCESS + {IR(22904, 17), 966}, // 1040 NoAliasINTELMask in SPV_OPERAND_TYPE_MEMORY_ACCESS + {IR(22845, 18), 964}, // 1041 NonPrivatePointer in SPV_OPERAND_TYPE_MEMORY_ACCESS + {IR(22863, 21), 964}, // 1042 NonPrivatePointerKHR in SPV_OPERAND_TYPE_MEMORY_ACCESS + {IR(14223, 5), 958}, // 1043 None in SPV_OPERAND_TYPE_MEMORY_ACCESS + {IR(21442, 12), 961}, // 1044 Nontemporal in SPV_OPERAND_TYPE_MEMORY_ACCESS + {IR(15461, 9), 959}, // 1045 Volatile in SPV_OPERAND_TYPE_MEMORY_ACCESS + {IR(22928, 8), 968}, // 1046 GLSL450 in SPV_OPERAND_TYPE_MEMORY_MODEL + {IR(22936, 7), 969}, // 1047 OpenCL in SPV_OPERAND_TYPE_MEMORY_MODEL + {IR(22921, 7), 967}, // 1048 Simple in SPV_OPERAND_TYPE_MEMORY_MODEL + {IR(22943, 7), 970}, // 1049 Vulkan in SPV_OPERAND_TYPE_MEMORY_MODEL + {IR(22950, 10), 970}, // 1050 VulkanKHR in SPV_OPERAND_TYPE_MEMORY_MODEL + {IR(22968, 8), 972}, // 1051 Acquire in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(22984, 15), 974}, // 1052 AcquireRelease in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(23088, 20), 980}, // 1053 AtomicCounterMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(23067, 21), 979}, // 1054 CrossWorkgroupMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(23108, 12), 981}, // 1055 ImageMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(23149, 14), 983}, // 1056 MakeAvailable in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(23163, 17), 983}, // 1057 MakeAvailableKHR in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(23180, 12), 984}, // 1058 MakeVisible in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(23192, 15), 984}, // 1059 MakeVisibleKHR in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(14223, 5), 971}, // 1060 None in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(23120, 13), 982}, // 1061 OutputMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(23133, 16), 982}, // 1062 OutputMemoryKHR in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(22960, 8), 971}, // 1063 Relaxed in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(22976, 8), 973}, // 1064 Release in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(22999, 23), 975}, // 1065 SequentiallyConsistent in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(23036, 15), 977}, // 1066 SubgroupMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(23022, 14), 976}, // 1067 UniformMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(15461, 9), 985}, // 1068 Volatile in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(23051, 16), 978}, // 1069 WorkgroupMemory in SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID + {IR(23207, 10), 986}, // 1070 AutoINTEL in SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS + {IR(23222, 4), 988}, // 1071 SAT in SPV_OPERAND_TYPE_OVERFLOW_MODES + {IR(23235, 8), 990}, // 1072 SAT_SYM in SPV_OPERAND_TYPE_OVERFLOW_MODES + {IR(23226, 9), 989}, // 1073 SAT_ZERO in SPV_OPERAND_TYPE_OVERFLOW_MODES + {IR(23217, 5), 987}, // 1074 WRAP in SPV_OPERAND_TYPE_OVERFLOW_MODES + {IR(23243, 25), 991}, // 1075 PackedVectorFormat4x8Bit in SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT + {IR(23268, 28), 991}, // 1076 PackedVectorFormat4x8BitKHR in SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT + {IR(23309, 4), 994}, // 1077 RND in SPV_OPERAND_TYPE_QUANTIZATION_MODES + {IR(23342, 9), 998}, // 1078 RND_CONV in SPV_OPERAND_TYPE_QUANTIZATION_MODES + {IR(23351, 13), 999}, // 1079 RND_CONV_ODD in SPV_OPERAND_TYPE_QUANTIZATION_MODES + {IR(23322, 8), 996}, // 1080 RND_INF in SPV_OPERAND_TYPE_QUANTIZATION_MODES + {IR(23330, 12), 997}, // 1081 RND_MIN_INF in SPV_OPERAND_TYPE_QUANTIZATION_MODES + {IR(23313, 9), 995}, // 1082 RND_ZERO in SPV_OPERAND_TYPE_QUANTIZATION_MODES + {IR(23296, 4), 992}, // 1083 TRN in SPV_OPERAND_TYPE_QUANTIZATION_MODES + {IR(23300, 9), 993}, // 1084 TRN_ZERO in SPV_OPERAND_TYPE_QUANTIZATION_MODES + {IR(14223, 5), 1000}, // 1085 None in SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS + {IR(23364, 25), 1001}, // 1086 RobustnessPerComponentNV in SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS + {IR(23389, 23), 1002}, // 1087 RobustnessPerElementNV in SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS + {IR(23481, 27), 1008}, // 1088 CullBackFacingTrianglesKHR in SPV_OPERAND_TYPE_RAY_FLAGS + {IR(23508, 28), 1009}, // 1089 CullFrontFacingTrianglesKHR in SPV_OPERAND_TYPE_RAY_FLAGS + {IR(23550, 16), 1011}, // 1090 CullNoOpaqueKHR in SPV_OPERAND_TYPE_RAY_FLAGS + {IR(23536, 14), 1010}, // 1091 CullOpaqueKHR in SPV_OPERAND_TYPE_RAY_FLAGS + {IR(23620, 30), 1014}, // 1092 ForceOpacityMicromap2StateEXT in SPV_OPERAND_TYPE_RAY_FLAGS + {IR(23422, 12), 1005}, // 1093 NoOpaqueKHR in SPV_OPERAND_TYPE_RAY_FLAGS + {IR(14975, 8), 1003}, // 1094 NoneKHR in SPV_OPERAND_TYPE_RAY_FLAGS + {IR(23412, 10), 1004}, // 1095 OpaqueKHR in SPV_OPERAND_TYPE_RAY_FLAGS + {IR(23607, 13), 1013}, // 1096 SkipAABBsKHR in SPV_OPERAND_TYPE_RAY_FLAGS + {IR(23583, 24), 1012}, // 1097 SkipBuiltinPrimitivesNV in SPV_OPERAND_TYPE_RAY_FLAGS + {IR(23457, 24), 1007}, // 1098 SkipClosestHitShaderKHR in SPV_OPERAND_TYPE_RAY_FLAGS + {IR(23566, 17), 1012}, // 1099 SkipTrianglesKHR in SPV_OPERAND_TYPE_RAY_FLAGS + {IR(23434, 23), 1006}, // 1100 TerminateOnFirstHitKHR in SPV_OPERAND_TYPE_RAY_FLAGS + {IR(23691, 37), 1016}, // 1101 RayQueryCandidateIntersectionAABBKHR in SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE + {IR(23650, 41), 1015}, // 1102 RayQueryCandidateIntersectionTriangleKHR in SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE + {IR(23806, 42), 1019}, // 1103 RayQueryCommittedIntersectionGeneratedKHR in SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE + {IR(23728, 37), 1017}, // 1104 RayQueryCommittedIntersectionNoneKHR in SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE + {IR(23765, 41), 1018}, // 1105 RayQueryCommittedIntersectionTriangleKHR in SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE + {IR(23848, 33), 1020}, // 1106 RayQueryCandidateIntersectionKHR in SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION + {IR(23881, 33), 1021}, // 1107 RayQueryCommittedIntersectionKHR in SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION + {IR(23926, 6), 1024}, // 1108 Clamp in SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE + {IR(23914, 12), 1023}, // 1109 ClampToEdge in SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE + {IR(14223, 5), 1022}, // 1110 None in SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE + {IR(23932, 7), 1025}, // 1111 Repeat in SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE + {IR(23939, 15), 1026}, // 1112 RepeatMirrored in SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE + {IR(23962, 7), 1028}, // 1113 Linear in SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE + {IR(23954, 8), 1027}, // 1114 Nearest in SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE + {IR(24027, 13), 1037}, // 1115 R11fG11fB10f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24069, 4), 1043}, // 1116 R16 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24107, 9), 1048}, // 1117 R16Snorm in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24040, 5), 1038}, // 1118 R16f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24169, 5), 1057}, // 1119 R16i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24240, 6), 1067}, // 1120 R16ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(23993, 5), 1032}, // 1121 R32f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24147, 5), 1053}, // 1122 R32i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24204, 6), 1062}, // 1123 R32ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24257, 5), 1070}, // 1124 R64i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24251, 6), 1069}, // 1125 R64ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24073, 3), 1044}, // 1126 R8 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24116, 8), 1049}, // 1127 R8Snorm in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24174, 4), 1058}, // 1128 R8i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24246, 5), 1068}, // 1129 R8ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24060, 5), 1041}, // 1130 Rg16 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24088, 10), 1046}, // 1131 Rg16Snorm in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24021, 6), 1036}, // 1132 Rg16f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24158, 6), 1055}, // 1133 Rg16i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24227, 7), 1065}, // 1134 Rg16ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24015, 6), 1035}, // 1135 Rg32f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24152, 6), 1054}, // 1136 Rg32i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24220, 7), 1064}, // 1137 Rg32ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24065, 4), 1042}, // 1138 Rg8 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24098, 9), 1047}, // 1139 Rg8Snorm in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24164, 5), 1056}, // 1140 Rg8i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24234, 6), 1066}, // 1141 Rg8ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24052, 8), 1040}, // 1142 Rgb10A2 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24210, 10), 1063}, // 1143 Rgb10a2ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24045, 7), 1039}, // 1144 Rgba16 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24076, 12), 1045}, // 1145 Rgba16Snorm in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(23985, 8), 1031}, // 1146 Rgba16f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24132, 8), 1051}, // 1147 Rgba16i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24187, 9), 1060}, // 1148 Rgba16ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(23977, 8), 1030}, // 1149 Rgba32f in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24124, 8), 1050}, // 1150 Rgba32i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24178, 9), 1059}, // 1151 Rgba32ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(23998, 6), 1033}, // 1152 Rgba8 in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24004, 11), 1034}, // 1153 Rgba8Snorm in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24140, 7), 1052}, // 1154 Rgba8i in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24196, 8), 1061}, // 1155 Rgba8ui in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(23969, 8), 1029}, // 1156 Unknown in SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT + {IR(24262, 12), 1071}, // 1157 CrossDevice in SPV_OPERAND_TYPE_SCOPE_ID + {IR(24274, 7), 1072}, // 1158 Device in SPV_OPERAND_TYPE_SCOPE_ID + {IR(24300, 11), 1075}, // 1159 Invocation in SPV_OPERAND_TYPE_SCOPE_ID + {IR(24311, 12), 1076}, // 1160 QueueFamily in SPV_OPERAND_TYPE_SCOPE_ID + {IR(24323, 15), 1076}, // 1161 QueueFamilyKHR in SPV_OPERAND_TYPE_SCOPE_ID + {IR(24338, 14), 1077}, // 1162 ShaderCallKHR in SPV_OPERAND_TYPE_SCOPE_ID + {IR(24291, 9), 1074}, // 1163 Subgroup in SPV_OPERAND_TYPE_SCOPE_ID + {IR(24281, 10), 1073}, // 1164 Workgroup in SPV_OPERAND_TYPE_SCOPE_ID + {IR(24360, 12), 1080}, // 1165 DontFlatten in SPV_OPERAND_TYPE_SELECTION_CONTROL + {IR(24352, 8), 1079}, // 1166 Flatten in SPV_OPERAND_TYPE_SELECTION_CONTROL + {IR(14223, 5), 1078}, // 1167 None in SPV_OPERAND_TYPE_SELECTION_CONTROL + {IR(24372, 29), 1081}, // 1168 IdentifierPossibleDuplicates in SPV_OPERAND_TYPE_SHDEBUG100_BUILD_IDENTIFIER_FLAGS + {IR(14104, 8), 1083}, // 1169 Address in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14112, 8), 1084}, // 1170 Boolean in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14120, 6), 1085}, // 1171 Float in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14126, 7), 1086}, // 1172 Signed in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14133, 11), 1087}, // 1173 SignedChar in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14144, 9), 1088}, // 1174 Unsigned in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14153, 13), 1089}, // 1175 UnsignedChar in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14092, 12), 1082}, // 1176 Unspecified in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING + {IR(14166, 6), 1090}, // 1177 Class in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE + {IR(14172, 10), 1091}, // 1178 Structure in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE + {IR(14182, 6), 1092}, // 1179 Union in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE + {IR(14203, 20), 1094}, // 1180 ImportedDeclaration in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_IMPORTED_ENTITY + {IR(14188, 15), 1093}, // 1181 ImportedModule in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_IMPORTED_ENTITY + {IR(14312, 15), 1102}, // 1182 FlagArtificial in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14327, 13), 1103}, // 1183 FlagExplicit in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14300, 12), 1101}, // 1184 FlagFwdDecl in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14390, 21), 1107}, // 1185 FlagIndirectVariable in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14283, 17), 1100}, // 1186 FlagIsDefinition in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14467, 16), 1111}, // 1187 FlagIsEnumClass in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14271, 12), 1099}, // 1188 FlagIsLocal in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14451, 16), 1110}, // 1189 FlagIsOptimized in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14244, 14), 1097}, // 1190 FlagIsPrivate in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14228, 16), 1096}, // 1191 FlagIsProtected in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14258, 13), 1098}, // 1192 FlagIsPublic in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14411, 20), 1108}, // 1193 FlagLValueReference in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14355, 18), 1105}, // 1194 FlagObjectPointer in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14340, 15), 1104}, // 1195 FlagPrototyped in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14431, 20), 1109}, // 1196 FlagRValueReference in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14373, 17), 1106}, // 1197 FlagStaticMember in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14503, 24), 1113}, // 1198 FlagTypePassByReference in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14483, 20), 1112}, // 1199 FlagTypePassByValue in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(24401, 26), 1114}, // 1200 FlagUnknownPhysicalLayout in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14223, 5), 1095}, // 1201 None in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS + {IR(14588, 9), 1119}, // 1202 BitPiece in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {IR(14620, 7), 1123}, // 1203 Constu in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {IR(14527, 6), 1115}, // 1204 Deref in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {IR(14627, 9), 1124}, // 1205 Fragment in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {IR(14538, 6), 1117}, // 1206 Minus in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {IR(14533, 5), 1116}, // 1207 Plus in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {IR(14577, 11), 1118}, // 1208 PlusUconst in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {IR(14609, 11), 1122}, // 1209 StackValue in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {IR(14597, 5), 1120}, // 1210 Swap in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {IR(14602, 7), 1121}, // 1211 Xderef in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION + {IR(14672, 11), 1128}, // 1212 AtomicType in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER + {IR(14636, 10), 1125}, // 1213 ConstType in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER + {IR(14659, 13), 1127}, // 1214 RestrictType in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER + {IR(14646, 13), 1126}, // 1215 VolatileType in SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER + {IR(24462, 15), 1135}, // 1216 CPP_for_OpenCL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(24427, 5), 1130}, // 1217 ESSL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(24432, 5), 1131}, // 1218 GLSL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(24482, 7), 1137}, // 1219 HERO_C in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(24457, 5), 1134}, // 1220 HLSL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(24489, 5), 1138}, // 1221 NZSL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(24437, 9), 1132}, // 1222 OpenCL_C in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(24446, 11), 1133}, // 1223 OpenCL_CPP in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(24509, 5), 1142}, // 1224 Rust in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(24477, 5), 1136}, // 1225 SYCL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(24499, 6), 1140}, // 1226 Slang in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(23969, 8), 1129}, // 1227 Unknown in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(24494, 5), 1139}, // 1228 WGSL in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(24505, 4), 1141}, // 1229 Zig in SPV_OPERAND_TYPE_SOURCE_LANGUAGE + {IR(24596, 14), 1153}, // 1230 AtomicCounter in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24678, 16), 1159}, // 1231 CallableDataKHR in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24694, 15), 1159}, // 1232 CallableDataNV in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24992, 17), 1168}, // 1233 CodeSectionINTEL in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24543, 15), 1148}, // 1234 CrossWorkgroup in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(25009, 16), 1169}, // 1235 DeviceOnlyINTEL in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24566, 9), 1150}, // 1236 Function in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24575, 8), 1151}, // 1237 Generic in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24783, 16), 1162}, // 1238 HitAttributeKHR in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24799, 15), 1162}, // 1239 HitAttributeNV in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24947, 21), 1166}, // 1240 HitObjectAttributeNV in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(25025, 14), 1170}, // 1241 HostOnlyINTEL in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24610, 6), 1154}, // 1242 Image in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24709, 24), 1160}, // 1243 IncomingCallableDataKHR in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24733, 23), 1160}, // 1244 IncomingCallableDataNV in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24814, 22), 1163}, // 1245 IncomingRayPayloadKHR in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24836, 21), 1163}, // 1246 IncomingRayPayloadNV in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24530, 6), 1144}, // 1247 Input in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24662, 16), 1158}, // 1248 NodePayloadAMDX in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24536, 7), 1146}, // 1249 Output in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24900, 22), 1165}, // 1250 PhysicalStorageBuffer in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24922, 25), 1165}, // 1251 PhysicalStorageBufferEXT in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24558, 8), 1149}, // 1252 Private in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24583, 13), 1152}, // 1253 PushConstant in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24756, 14), 1161}, // 1254 RayPayloadKHR in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24770, 13), 1161}, // 1255 RayPayloadNV in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24857, 22), 1164}, // 1256 ShaderRecordBufferKHR in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24879, 21), 1164}, // 1257 ShaderRecordBufferNV in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24616, 14), 1155}, // 1258 StorageBuffer in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24968, 24), 1167}, // 1259 TaskPayloadWorkgroupEXT in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24643, 19), 1157}, // 1260 TileAttachmentQCOM in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24630, 13), 1156}, // 1261 TileImageEXT in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(15512, 8), 1145}, // 1262 Uniform in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24514, 16), 1143}, // 1263 UniformConstant in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(24281, 10), 1147}, // 1264 Workgroup in SPV_OPERAND_TYPE_STORAGE_CLASS + {IR(22093, 15), 1174}, // 1265 StreamingINTEL in SPV_OPERAND_TYPE_STORE_CACHE_CONTROL + {IR(22067, 14), 1171}, // 1266 UncachedINTEL in SPV_OPERAND_TYPE_STORE_CACHE_CONTROL + {IR(25057, 15), 1173}, // 1267 WriteBackINTEL in SPV_OPERAND_TYPE_STORE_CACHE_CONTROL + {IR(25039, 18), 1172}, // 1268 WriteThroughINTEL in SPV_OPERAND_TYPE_STORE_CACHE_CONTROL + {IR(25083, 11), 1177}, // 1269 DecodeFunc in SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS + {IR(14223, 5), 1175}, // 1270 None in SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS + {IR(25072, 11), 1176}, // 1271 TensorView in SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS + {IR(23914, 12), 1180}, // 1272 ClampToEdge in SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE + {IR(15470, 9), 1179}, // 1273 Constant in SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE + {IR(23932, 7), 1181}, // 1274 Repeat in SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE + {IR(23939, 15), 1182}, // 1275 RepeatMirrored in SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE + {IR(25094, 10), 1178}, // 1276 Undefined in SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE + {IR(25147, 24), 1186}, // 1277 MakeElementAvailableARM in SPV_OPERAND_TYPE_TENSOR_OPERANDS + {IR(25171, 22), 1187}, // 1278 MakeElementVisibleARM in SPV_OPERAND_TYPE_TENSOR_OPERANDS + {IR(25193, 21), 1188}, // 1279 NonPrivateElementARM in SPV_OPERAND_TYPE_TENSOR_OPERANDS + {IR(25104, 8), 1183}, // 1280 NoneARM in SPV_OPERAND_TYPE_TENSOR_OPERANDS + {IR(25112, 15), 1184}, // 1281 NontemporalARM in SPV_OPERAND_TYPE_TENSOR_OPERANDS + {IR(25127, 20), 1185}, // 1282 OutOfBoundsValueARM in SPV_OPERAND_TYPE_TENSOR_OPERANDS }}; IndexRange OperandNameRangeForKind(spv_operand_type_t type) { @@ -2907,88 +2930,89 @@ IndexRange OperandNameRangeForKind(spv_operand_type_t type) { case SPV_OPERAND_TYPE_ACCESS_QUALIFIER: return IR(0, 3); case SPV_OPERAND_TYPE_ADDRESSING_MODEL: return IR(3, 5); case SPV_OPERAND_TYPE_BUILT_IN: return IR(8, 148); - case SPV_OPERAND_TYPE_CAPABILITY: return IR(156, 297); - case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return IR(453, 8); - case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE: return IR(461, 3); - case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY: return IR(464, 2); - case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS: return IR(466, 19); - case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION: return IR(485, 10); - case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER: return IR(495, 4); - case SPV_OPERAND_TYPE_COMPONENT_TYPE: return IR(499, 15); - case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT: return IR(514, 4); - case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS: return IR(518, 6); - case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE: return IR(524, 3); - case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE: return IR(527, 3); - case SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT: return IR(530, 4); - case SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return IR(534, 8); - case SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE: return IR(542, 3); - case SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS: return IR(545, 16); - case SPV_OPERAND_TYPE_DEBUG_OPERATION: return IR(561, 9); - case SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER: return IR(570, 3); - case SPV_OPERAND_TYPE_DECORATION: return IR(573, 150); - case SPV_OPERAND_TYPE_DIMENSIONALITY: return IR(723, 8); - case SPV_OPERAND_TYPE_EXECUTION_MODE: return IR(731, 101); - case SPV_OPERAND_TYPE_EXECUTION_MODEL: return IR(832, 23); - case SPV_OPERAND_TYPE_FPDENORM_MODE: return IR(855, 2); - case SPV_OPERAND_TYPE_FPENCODING: return IR(857, 3); - case SPV_OPERAND_TYPE_FPOPERATION_MODE: return IR(860, 2); - case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE: return IR(862, 11); - case SPV_OPERAND_TYPE_FP_ROUNDING_MODE: return IR(873, 4); - case SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE: return IR(877, 4); - case SPV_OPERAND_TYPE_FUNCTION_CONTROL: return IR(881, 7); - case SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE: return IR(888, 9); - case SPV_OPERAND_TYPE_GROUP_OPERATION: return IR(897, 7); - case SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER: return IR(904, 4); - case SPV_OPERAND_TYPE_IMAGE: return IR(908, 21); - case SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE: return IR(929, 26); - case SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER: return IR(955, 20); - case SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER: return IR(975, 2); - case SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS: return IR(977, 3); - case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO: return IR(980, 2); - case SPV_OPERAND_TYPE_KERNEL_PROPERTY_FLAGS: return IR(982, 2); - case SPV_OPERAND_TYPE_LINKAGE_TYPE: return IR(984, 3); - case SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL: return IR(987, 5); - case SPV_OPERAND_TYPE_LOOP_CONTROL: return IR(992, 20); - case SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: return IR(1012, 15); - case SPV_OPERAND_TYPE_MEMORY_ACCESS: return IR(1027, 12); - case SPV_OPERAND_TYPE_MEMORY_MODEL: return IR(1039, 5); - case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: return IR(1044, 19); - case SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS: return IR(1063, 1); - case SPV_OPERAND_TYPE_OVERFLOW_MODES: return IR(1064, 4); - case SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT: return IR(1068, 2); - case SPV_OPERAND_TYPE_QUANTIZATION_MODES: return IR(1070, 8); - case SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS: return IR(1078, 3); - case SPV_OPERAND_TYPE_RAY_FLAGS: return IR(1081, 13); - case SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE: return IR(1094, 2); - case SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE: return IR(1096, 3); - case SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION: return IR(1099, 2); - case SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE: return IR(1101, 5); - case SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE: return IR(1106, 2); - case SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT: return IR(1108, 42); - case SPV_OPERAND_TYPE_SCOPE_ID: return IR(1150, 8); - case SPV_OPERAND_TYPE_SELECTION_CONTROL: return IR(1158, 3); - case SPV_OPERAND_TYPE_SHDEBUG100_BUILD_IDENTIFIER_FLAGS: return IR(1161, 1); - case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return IR(1162, 8); - case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE: return IR(1170, 3); - case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_IMPORTED_ENTITY: return IR(1173, 2); - case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS: return IR(1175, 20); - case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION: return IR(1195, 10); - case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER: return IR(1205, 4); - case SPV_OPERAND_TYPE_SOURCE_LANGUAGE: return IR(1209, 14); - case SPV_OPERAND_TYPE_STORAGE_CLASS: return IR(1223, 35); - case SPV_OPERAND_TYPE_STORE_CACHE_CONTROL: return IR(1258, 4); - case SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS: return IR(1262, 3); - case SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE: return IR(1265, 5); - case SPV_OPERAND_TYPE_TENSOR_OPERANDS: return IR(1270, 6); - case SPV_OPERAND_TYPE_OPTIONAL_IMAGE: return IR(908, 21); + case SPV_OPERAND_TYPE_CAPABILITY: return IR(156, 303); + case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return IR(459, 8); + case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE: return IR(467, 3); + case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY: return IR(470, 2); + case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS: return IR(472, 19); + case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION: return IR(491, 10); + case SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER: return IR(501, 4); + case SPV_OPERAND_TYPE_COMPONENT_TYPE: return IR(505, 15); + case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_LAYOUT: return IR(520, 4); + case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_OPERANDS: return IR(524, 6); + case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE: return IR(530, 3); + case SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_USE: return IR(533, 3); + case SPV_OPERAND_TYPE_COOPERATIVE_VECTOR_MATRIX_LAYOUT: return IR(536, 4); + case SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return IR(540, 8); + case SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE: return IR(548, 3); + case SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS: return IR(551, 16); + case SPV_OPERAND_TYPE_DEBUG_OPERATION: return IR(567, 9); + case SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER: return IR(576, 3); + case SPV_OPERAND_TYPE_DECORATION: return IR(579, 151); + case SPV_OPERAND_TYPE_DIMENSIONALITY: return IR(730, 8); + case SPV_OPERAND_TYPE_EXECUTION_MODE: return IR(738, 101); + case SPV_OPERAND_TYPE_EXECUTION_MODEL: return IR(839, 23); + case SPV_OPERAND_TYPE_FPDENORM_MODE: return IR(862, 2); + case SPV_OPERAND_TYPE_FPENCODING: return IR(864, 3); + case SPV_OPERAND_TYPE_FPOPERATION_MODE: return IR(867, 2); + case SPV_OPERAND_TYPE_FP_FAST_MATH_MODE: return IR(869, 11); + case SPV_OPERAND_TYPE_FP_ROUNDING_MODE: return IR(880, 4); + case SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE: return IR(884, 4); + case SPV_OPERAND_TYPE_FUNCTION_CONTROL: return IR(888, 7); + case SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE: return IR(895, 9); + case SPV_OPERAND_TYPE_GROUP_OPERATION: return IR(904, 7); + case SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER: return IR(911, 4); + case SPV_OPERAND_TYPE_IMAGE: return IR(915, 21); + case SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE: return IR(936, 26); + case SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER: return IR(962, 20); + case SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER: return IR(982, 2); + case SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS: return IR(984, 3); + case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO: return IR(987, 2); + case SPV_OPERAND_TYPE_KERNEL_PROPERTY_FLAGS: return IR(989, 2); + case SPV_OPERAND_TYPE_LINKAGE_TYPE: return IR(991, 3); + case SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL: return IR(994, 5); + case SPV_OPERAND_TYPE_LOOP_CONTROL: return IR(999, 20); + case SPV_OPERAND_TYPE_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: return IR(1019, 15); + case SPV_OPERAND_TYPE_MEMORY_ACCESS: return IR(1034, 12); + case SPV_OPERAND_TYPE_MEMORY_MODEL: return IR(1046, 5); + case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: return IR(1051, 19); + case SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS: return IR(1070, 1); + case SPV_OPERAND_TYPE_OVERFLOW_MODES: return IR(1071, 4); + case SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT: return IR(1075, 2); + case SPV_OPERAND_TYPE_QUANTIZATION_MODES: return IR(1077, 8); + case SPV_OPERAND_TYPE_RAW_ACCESS_CHAIN_OPERANDS: return IR(1085, 3); + case SPV_OPERAND_TYPE_RAY_FLAGS: return IR(1088, 13); + case SPV_OPERAND_TYPE_RAY_QUERY_CANDIDATE_INTERSECTION_TYPE: return IR(1101, 2); + case SPV_OPERAND_TYPE_RAY_QUERY_COMMITTED_INTERSECTION_TYPE: return IR(1103, 3); + case SPV_OPERAND_TYPE_RAY_QUERY_INTERSECTION: return IR(1106, 2); + case SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE: return IR(1108, 5); + case SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE: return IR(1113, 2); + case SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT: return IR(1115, 42); + case SPV_OPERAND_TYPE_SCOPE_ID: return IR(1157, 8); + case SPV_OPERAND_TYPE_SELECTION_CONTROL: return IR(1165, 3); + case SPV_OPERAND_TYPE_SHDEBUG100_BUILD_IDENTIFIER_FLAGS: return IR(1168, 1); + case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING: return IR(1169, 8); + case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_COMPOSITE_TYPE: return IR(1177, 3); + case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_IMPORTED_ENTITY: return IR(1180, 2); + case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_INFO_FLAGS: return IR(1182, 20); + case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_OPERATION: return IR(1202, 10); + case SPV_OPERAND_TYPE_SHDEBUG100_DEBUG_TYPE_QUALIFIER: return IR(1212, 4); + case SPV_OPERAND_TYPE_SOURCE_LANGUAGE: return IR(1216, 14); + case SPV_OPERAND_TYPE_STORAGE_CLASS: return IR(1230, 35); + case SPV_OPERAND_TYPE_STORE_CACHE_CONTROL: return IR(1265, 4); + case SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS: return IR(1269, 3); + case SPV_OPERAND_TYPE_TENSOR_CLAMP_MODE: return IR(1272, 5); + case SPV_OPERAND_TYPE_TENSOR_OPERANDS: return IR(1277, 6); + case SPV_OPERAND_TYPE_OPTIONAL_IMAGE: return IR(915, 21); case SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER: return IR(0, 3); - case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS: return IR(1027, 12); - case SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT: return IR(1068, 2); - case SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS: return IR(518, 6); - case SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: return IR(1012, 15); - case SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS: return IR(1078, 3); - case SPV_OPERAND_TYPE_OPTIONAL_FPENCODING: return IR(857, 3); - case SPV_OPERAND_TYPE_OPTIONAL_TENSOR_OPERANDS: return IR(1270, 6); + case SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS: return IR(1034, 12); + case SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT: return IR(1075, 2); + case SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS: return IR(524, 6); + case SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS: return IR(1019, 15); + case SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS: return IR(1085, 3); + case SPV_OPERAND_TYPE_OPTIONAL_FPENCODING: return IR(864, 3); + case SPV_OPERAND_TYPE_OPTIONAL_TENSOR_OPERANDS: return IR(1277, 6); + case SPV_OPERAND_TYPE_OPTIONAL_CAPABILITY: return IR(156, 303); default: break; } return IR(0,0); @@ -3006,1627 +3030,1670 @@ IndexRange OperandNameRangeForKind(spv_operand_type_t type) { // extensions, as an IndexRange into kExtensionSpans // version, first version of SPIR-V that has it // lastVersion, last version of SPIR-V that has it -static const std::array kInstructionDesc{{ - {spv::Op::OpNop, false, false, IR(0, 0), IR(24981, 4), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMiscellaneous}, - {spv::Op::OpUndef, true, true, IR(39, 2), IR(25037, 6), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMiscellaneous}, - {spv::Op::OpSourceContinued, false, false, IR(11, 1), IR(25043, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, - {spv::Op::OpSource, false, false, IR(41, 4), IR(25162, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, - {spv::Op::OpSourceExtension, false, false, IR(11, 1), IR(25169, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, - {spv::Op::OpName, false, false, IR(45, 2), IR(25185, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, - {spv::Op::OpMemberName, false, false, IR(47, 3), IR(25190, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, - {spv::Op::OpString, true, false, IR(50, 2), IR(25201, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, - {spv::Op::OpLine, false, false, IR(52, 3), IR(25208, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, - {spv::Op::OpExtension, false, false, IR(11, 1), IR(25213, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kExtension}, - {spv::Op::OpExtInstImport, true, false, IR(50, 2), IR(25223, 14), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kExtension}, - {spv::Op::OpExtInst, true, true, IR(55, 4), IR(25283, 8), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kExtension}, - {spv::Op::OpMemoryModel, false, false, IR(59, 2), IR(25355, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMode_Setting}, - {spv::Op::OpEntryPoint, false, false, IR(61, 4), IR(25429, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMode_Setting}, - {spv::Op::OpExecutionMode, false, false, IR(65, 2), IR(25472, 14), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMode_Setting}, - {spv::Op::OpCapability, false, false, IR(67, 1), IR(25514, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMode_Setting}, - {spv::Op::OpTypeVoid, true, false, IR(68, 1), IR(25525, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeBool, true, false, IR(68, 1), IR(25534, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeInt, true, false, IR(69, 3), IR(25543, 8), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeFloat, true, false, IR(72, 3), IR(25588, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeVector, true, false, IR(75, 3), IR(25598, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeMatrix, true, false, IR(75, 3), IR(25609, 11), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeImage, true, false, IR(78, 9), IR(25733, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeSampler, true, false, IR(68, 1), IR(25743, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeSampledImage, true, false, IR(87, 2), IR(25755, 17), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeArray, true, false, IR(89, 3), IR(25772, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeRuntimeArray, true, false, IR(87, 2), IR(25782, 17), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeStruct, true, false, IR(92, 2), IR(25799, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeOpaque, true, false, IR(50, 2), IR(25810, 11), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypePointer, true, false, IR(94, 3), IR(25852, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeFunction, true, false, IR(97, 3), IR(25864, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeEvent, true, false, IR(68, 1), IR(25877, 10), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeDeviceEvent, true, false, IR(68, 1), IR(25887, 16), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeReserveId, true, false, IR(68, 1), IR(25903, 14), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeQueue, true, false, IR(68, 1), IR(25917, 10), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypePipe, true, false, IR(100, 2), IR(25927, 9), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeForwardPointer, false, false, IR(102, 2), IR(25936, 19), IR(0, 0), IR(199, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpConstantTrue, true, true, IR(39, 2), IR(25955, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpConstantFalse, true, true, IR(39, 2), IR(25968, 14), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpConstant, true, true, IR(104, 3), IR(15254, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpConstantComposite, true, true, IR(107, 3), IR(26020, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpConstantSampler, true, true, IR(110, 5), IR(26116, 16), IR(0, 0), IR(201, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpConstantNull, true, true, IR(39, 2), IR(26132, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpSpecConstantTrue, true, true, IR(39, 2), IR(26145, 17), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpSpecConstantFalse, true, true, IR(39, 2), IR(26162, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpSpecConstant, true, true, IR(104, 3), IR(26180, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpSpecConstantComposite, true, true, IR(107, 3), IR(26193, 22), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpSpecConstantOp, true, true, IR(115, 3), IR(26256, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpFunction, true, true, IR(118, 4), IR(24333, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kFunction}, - {spv::Op::OpFunctionParameter, true, true, IR(39, 2), IR(26305, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kFunction}, - {spv::Op::OpFunctionEnd, false, false, IR(0, 0), IR(26323, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kFunction}, - {spv::Op::OpFunctionCall, true, true, IR(122, 4), IR(26335, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kFunction}, - {spv::Op::OpVariable, true, true, IR(126, 4), IR(26348, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpImageTexelPointer, true, true, IR(130, 5), IR(26357, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpLoad, true, true, IR(135, 4), IR(26415, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpStore, false, false, IR(139, 3), IR(26420, 6), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpCopyMemory, false, false, IR(142, 4), IR(26426, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpCopyMemorySized, false, false, IR(146, 5), IR(26437, 16), IR(0, 0), IR(202, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpAccessChain, true, true, IR(122, 4), IR(26453, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpInBoundsAccessChain, true, true, IR(122, 4), IR(26465, 20), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpPtrAccessChain, true, true, IR(151, 5), IR(26485, 15), IR(0, 0), IR(204, 4), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpArrayLength, true, true, IR(156, 4), IR(26500, 12), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpGenericPtrMemSemantics, true, true, IR(160, 3), IR(26512, 23), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpInBoundsPtrAccessChain, true, true, IR(151, 5), IR(26535, 23), IR(0, 0), IR(1, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpDecorate, false, false, IR(163, 2), IR(26586, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAnnotation}, - {spv::Op::OpMemberDecorate, false, false, IR(165, 3), IR(26595, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAnnotation}, - {spv::Op::OpDecorationGroup, true, false, IR(68, 1), IR(26610, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAnnotation}, - {spv::Op::OpGroupDecorate, false, false, IR(168, 2), IR(26626, 14), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAnnotation}, - {spv::Op::OpGroupMemberDecorate, false, false, IR(170, 2), IR(26685, 20), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAnnotation}, - {spv::Op::OpVectorExtractDynamic, true, true, IR(172, 4), IR(26705, 21), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, - {spv::Op::OpVectorInsertDynamic, true, true, IR(130, 5), IR(26726, 20), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, - {spv::Op::OpVectorShuffle, true, true, IR(176, 5), IR(26746, 14), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, - {spv::Op::OpCompositeConstruct, true, true, IR(107, 3), IR(26760, 19), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, - {spv::Op::OpCompositeExtract, true, true, IR(181, 4), IR(26779, 17), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, - {spv::Op::OpCompositeInsert, true, true, IR(176, 5), IR(26796, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, - {spv::Op::OpCopyObject, true, true, IR(160, 3), IR(26812, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, - {spv::Op::OpTranspose, true, true, IR(160, 3), IR(26823, 10), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, - {spv::Op::OpSampledImage, true, true, IR(172, 4), IR(26833, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSampleImplicitLod, true, true, IR(185, 5), IR(26878, 23), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSampleExplicitLod, true, true, IR(190, 5), IR(26924, 23), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSampleDrefImplicitLod, true, true, IR(195, 6), IR(26947, 27), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSampleDrefExplicitLod, true, true, IR(201, 6), IR(26974, 27), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSampleProjImplicitLod, true, true, IR(185, 5), IR(27001, 27), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSampleProjExplicitLod, true, true, IR(190, 5), IR(27028, 27), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSampleProjDrefImplicitLod, true, true, IR(195, 6), IR(27055, 31), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSampleProjDrefExplicitLod, true, true, IR(201, 6), IR(27086, 31), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageFetch, true, true, IR(185, 5), IR(27117, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageGather, true, true, IR(195, 6), IR(27128, 12), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageDrefGather, true, true, IR(195, 6), IR(27140, 16), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageRead, true, true, IR(185, 5), IR(27156, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageWrite, false, false, IR(207, 4), IR(27166, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImage, true, true, IR(160, 3), IR(24377, 6), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageQueryFormat, true, true, IR(160, 3), IR(27177, 17), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageQueryOrder, true, true, IR(160, 3), IR(27194, 16), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageQuerySizeLod, true, true, IR(172, 4), IR(27210, 18), IR(0, 0), IR(208, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageQuerySize, true, true, IR(160, 3), IR(27228, 15), IR(0, 0), IR(208, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageQueryLod, true, true, IR(172, 4), IR(27243, 14), IR(0, 0), IR(210, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageQueryLevels, true, true, IR(160, 3), IR(27257, 17), IR(0, 0), IR(208, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageQuerySamples, true, true, IR(160, 3), IR(27274, 18), IR(0, 0), IR(208, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpConvertFToU, true, true, IR(160, 3), IR(27292, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpConvertFToS, true, true, IR(160, 3), IR(27304, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpConvertSToF, true, true, IR(160, 3), IR(27316, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpConvertUToF, true, true, IR(160, 3), IR(27328, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpUConvert, true, true, IR(160, 3), IR(27340, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpSConvert, true, true, IR(160, 3), IR(27349, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpFConvert, true, true, IR(160, 3), IR(27358, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpQuantizeToF16, true, true, IR(160, 3), IR(27367, 14), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpConvertPtrToU, true, true, IR(160, 3), IR(27381, 14), IR(0, 0), IR(199, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpSatConvertSToU, true, true, IR(160, 3), IR(27395, 15), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpSatConvertUToS, true, true, IR(160, 3), IR(27410, 15), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpConvertUToPtr, true, true, IR(160, 3), IR(27425, 14), IR(0, 0), IR(199, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpPtrCastToGeneric, true, true, IR(160, 3), IR(27439, 17), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpGenericCastToPtr, true, true, IR(160, 3), IR(27456, 17), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpGenericCastToPtrExplicit, true, true, IR(211, 4), IR(27473, 25), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpBitcast, true, true, IR(160, 3), IR(27498, 8), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpSNegate, true, true, IR(160, 3), IR(27506, 8), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpFNegate, true, true, IR(160, 3), IR(27514, 8), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpIAdd, true, true, IR(172, 4), IR(27522, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpFAdd, true, true, IR(172, 4), IR(27527, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpISub, true, true, IR(172, 4), IR(27532, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpFSub, true, true, IR(172, 4), IR(27537, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpIMul, true, true, IR(172, 4), IR(27542, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpFMul, true, true, IR(172, 4), IR(27547, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpUDiv, true, true, IR(172, 4), IR(27552, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpSDiv, true, true, IR(172, 4), IR(27557, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpFDiv, true, true, IR(172, 4), IR(27562, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpUMod, true, true, IR(172, 4), IR(27567, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpSRem, true, true, IR(172, 4), IR(27572, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpSMod, true, true, IR(172, 4), IR(27577, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpFRem, true, true, IR(172, 4), IR(27582, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpFMod, true, true, IR(172, 4), IR(27587, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpVectorTimesScalar, true, true, IR(172, 4), IR(27592, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpMatrixTimesScalar, true, true, IR(172, 4), IR(27610, 18), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpVectorTimesMatrix, true, true, IR(172, 4), IR(27628, 18), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpMatrixTimesVector, true, true, IR(172, 4), IR(27646, 18), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpMatrixTimesMatrix, true, true, IR(172, 4), IR(27664, 18), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpOuterProduct, true, true, IR(172, 4), IR(27682, 13), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpDot, true, true, IR(172, 4), IR(27695, 4), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpIAddCarry, true, true, IR(172, 4), IR(27699, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpISubBorrow, true, true, IR(172, 4), IR(27709, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpUMulExtended, true, true, IR(172, 4), IR(27720, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpSMulExtended, true, true, IR(172, 4), IR(27733, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpAny, true, true, IR(160, 3), IR(27746, 4), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpAll, true, true, IR(160, 3), IR(27750, 4), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpIsNan, true, true, IR(160, 3), IR(27754, 6), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpIsInf, true, true, IR(160, 3), IR(27760, 6), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpIsFinite, true, true, IR(160, 3), IR(27766, 9), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpIsNormal, true, true, IR(160, 3), IR(27775, 9), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpSignBitSet, true, true, IR(160, 3), IR(27784, 11), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpLessOrGreater, true, true, IR(172, 4), IR(27795, 14), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), SPV_SPIRV_VERSION_WORD(1,5), PrintingClass::kRelational_and_Logical}, - {spv::Op::OpOrdered, true, true, IR(172, 4), IR(27809, 8), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpUnordered, true, true, IR(172, 4), IR(27817, 10), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpLogicalEqual, true, true, IR(172, 4), IR(27827, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpLogicalNotEqual, true, true, IR(172, 4), IR(27840, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpLogicalOr, true, true, IR(172, 4), IR(27856, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpLogicalAnd, true, true, IR(172, 4), IR(27866, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpLogicalNot, true, true, IR(160, 3), IR(27877, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpSelect, true, true, IR(130, 5), IR(27888, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpIEqual, true, true, IR(172, 4), IR(27895, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpINotEqual, true, true, IR(172, 4), IR(27902, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpUGreaterThan, true, true, IR(172, 4), IR(27912, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpSGreaterThan, true, true, IR(172, 4), IR(27925, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpUGreaterThanEqual, true, true, IR(172, 4), IR(27938, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpSGreaterThanEqual, true, true, IR(172, 4), IR(27956, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpULessThan, true, true, IR(172, 4), IR(27974, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpSLessThan, true, true, IR(172, 4), IR(27984, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpULessThanEqual, true, true, IR(172, 4), IR(27994, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpSLessThanEqual, true, true, IR(172, 4), IR(28009, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpFOrdEqual, true, true, IR(172, 4), IR(28024, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpFUnordEqual, true, true, IR(172, 4), IR(28034, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpFOrdNotEqual, true, true, IR(172, 4), IR(28046, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpFUnordNotEqual, true, true, IR(172, 4), IR(28059, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpFOrdLessThan, true, true, IR(172, 4), IR(28074, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpFUnordLessThan, true, true, IR(172, 4), IR(28087, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpFOrdGreaterThan, true, true, IR(172, 4), IR(28102, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpFUnordGreaterThan, true, true, IR(172, 4), IR(28118, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpFOrdLessThanEqual, true, true, IR(172, 4), IR(28136, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpFUnordLessThanEqual, true, true, IR(172, 4), IR(28154, 20), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpFOrdGreaterThanEqual, true, true, IR(172, 4), IR(28174, 21), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpFUnordGreaterThanEqual, true, true, IR(172, 4), IR(28195, 23), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, - {spv::Op::OpShiftRightLogical, true, true, IR(172, 4), IR(28218, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, - {spv::Op::OpShiftRightArithmetic, true, true, IR(172, 4), IR(28236, 21), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, - {spv::Op::OpShiftLeftLogical, true, true, IR(172, 4), IR(28257, 17), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, - {spv::Op::OpBitwiseOr, true, true, IR(172, 4), IR(28274, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, - {spv::Op::OpBitwiseXor, true, true, IR(172, 4), IR(28284, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, - {spv::Op::OpBitwiseAnd, true, true, IR(172, 4), IR(28295, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, - {spv::Op::OpNot, true, true, IR(160, 3), IR(28306, 4), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, - {spv::Op::OpBitFieldInsert, true, true, IR(215, 6), IR(28310, 15), IR(0, 0), IR(211, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, - {spv::Op::OpBitFieldSExtract, true, true, IR(130, 5), IR(28325, 17), IR(0, 0), IR(211, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, - {spv::Op::OpBitFieldUExtract, true, true, IR(130, 5), IR(28342, 17), IR(0, 0), IR(211, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, - {spv::Op::OpBitReverse, true, true, IR(160, 3), IR(28359, 11), IR(0, 0), IR(211, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, - {spv::Op::OpBitCount, true, true, IR(160, 3), IR(28370, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, - {spv::Op::OpDPdx, true, true, IR(160, 3), IR(28379, 5), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, - {spv::Op::OpDPdy, true, true, IR(160, 3), IR(28384, 5), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, - {spv::Op::OpFwidth, true, true, IR(160, 3), IR(28389, 7), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, - {spv::Op::OpDPdxFine, true, true, IR(160, 3), IR(28396, 9), IR(0, 0), IR(213, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, - {spv::Op::OpDPdyFine, true, true, IR(160, 3), IR(28405, 9), IR(0, 0), IR(213, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, - {spv::Op::OpFwidthFine, true, true, IR(160, 3), IR(28414, 11), IR(0, 0), IR(213, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, - {spv::Op::OpDPdxCoarse, true, true, IR(160, 3), IR(28425, 11), IR(0, 0), IR(213, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, - {spv::Op::OpDPdyCoarse, true, true, IR(160, 3), IR(28436, 11), IR(0, 0), IR(213, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, - {spv::Op::OpFwidthCoarse, true, true, IR(160, 3), IR(28447, 13), IR(0, 0), IR(213, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, - {spv::Op::OpEmitVertex, false, false, IR(0, 0), IR(28460, 11), IR(0, 0), IR(69, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPrimitive}, - {spv::Op::OpEndPrimitive, false, false, IR(0, 0), IR(28471, 13), IR(0, 0), IR(69, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPrimitive}, - {spv::Op::OpEmitStreamVertex, false, false, IR(10, 1), IR(28484, 17), IR(0, 0), IR(110, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPrimitive}, - {spv::Op::OpEndStreamPrimitive, false, false, IR(10, 1), IR(28501, 19), IR(0, 0), IR(110, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPrimitive}, - {spv::Op::OpControlBarrier, false, false, IR(221, 3), IR(28557, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBarrier}, - {spv::Op::OpMemoryBarrier, false, false, IR(224, 2), IR(28572, 14), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBarrier}, - {spv::Op::OpAtomicLoad, true, true, IR(226, 5), IR(28586, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicStore, false, false, IR(231, 4), IR(28597, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicExchange, true, true, IR(235, 6), IR(28609, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicCompareExchange, true, true, IR(241, 8), IR(28624, 22), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicCompareExchangeWeak, true, true, IR(241, 8), IR(28646, 26), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), SPV_SPIRV_VERSION_WORD(1,3), PrintingClass::kAtomic}, - {spv::Op::OpAtomicIIncrement, true, true, IR(226, 5), IR(28672, 17), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicIDecrement, true, true, IR(226, 5), IR(28689, 17), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicIAdd, true, true, IR(235, 6), IR(28706, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicISub, true, true, IR(235, 6), IR(28717, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicSMin, true, true, IR(235, 6), IR(28728, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicUMin, true, true, IR(235, 6), IR(28739, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicSMax, true, true, IR(235, 6), IR(28750, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicUMax, true, true, IR(235, 6), IR(28761, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicAnd, true, true, IR(235, 6), IR(28772, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicOr, true, true, IR(235, 6), IR(28782, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicXor, true, true, IR(235, 6), IR(28791, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpPhi, true, true, IR(107, 3), IR(28801, 4), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpLoopMerge, false, false, IR(249, 3), IR(28835, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpSelectionMerge, false, false, IR(252, 2), IR(28880, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpLabel, true, false, IR(68, 1), IR(28895, 6), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpBranch, false, false, IR(10, 1), IR(28901, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpBranchConditional, false, false, IR(254, 4), IR(28908, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpSwitch, false, false, IR(258, 3), IR(28971, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpKill, false, false, IR(0, 0), IR(28978, 5), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpReturn, false, false, IR(0, 0), IR(28983, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpReturnValue, false, false, IR(10, 1), IR(28990, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpUnreachable, false, false, IR(0, 0), IR(29002, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpLifetimeStart, false, false, IR(261, 2), IR(29014, 14), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpLifetimeStop, false, false, IR(261, 2), IR(29028, 13), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpGroupAsyncCopy, true, true, IR(263, 8), IR(29041, 15), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupWaitEvents, false, false, IR(271, 3), IR(29056, 16), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupAll, true, true, IR(274, 4), IR(29072, 9), IR(0, 0), IR(214, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupAny, true, true, IR(274, 4), IR(29081, 9), IR(0, 0), IR(214, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupBroadcast, true, true, IR(278, 5), IR(29090, 15), IR(0, 0), IR(214, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupIAdd, true, true, IR(283, 5), IR(29138, 10), IR(0, 0), IR(214, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupFAdd, true, true, IR(283, 5), IR(29148, 10), IR(0, 0), IR(214, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupFMin, true, true, IR(283, 5), IR(29158, 10), IR(0, 0), IR(214, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupUMin, true, true, IR(283, 5), IR(29168, 10), IR(0, 0), IR(214, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupSMin, true, true, IR(283, 5), IR(29178, 10), IR(0, 0), IR(214, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupFMax, true, true, IR(283, 5), IR(29188, 10), IR(0, 0), IR(214, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupUMax, true, true, IR(283, 5), IR(29198, 10), IR(0, 0), IR(214, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupSMax, true, true, IR(283, 5), IR(29208, 10), IR(0, 0), IR(214, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpReadPipe, true, true, IR(215, 6), IR(29218, 9), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpWritePipe, true, true, IR(215, 6), IR(29227, 10), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpReservedReadPipe, true, true, IR(288, 8), IR(29237, 17), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpReservedWritePipe, true, true, IR(288, 8), IR(29254, 18), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpReserveReadPipePackets, true, true, IR(215, 6), IR(29272, 23), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpReserveWritePipePackets, true, true, IR(215, 6), IR(29295, 24), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpCommitReadPipe, false, false, IR(296, 4), IR(29319, 15), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpCommitWritePipe, false, false, IR(296, 4), IR(29334, 16), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpIsValidReserveId, true, true, IR(160, 3), IR(29350, 17), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpGetNumPipePackets, true, true, IR(130, 5), IR(29367, 18), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpGetMaxPipePackets, true, true, IR(130, 5), IR(29385, 18), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpGroupReserveReadPipePackets, true, true, IR(300, 7), IR(29403, 28), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpGroupReserveWritePipePackets, true, true, IR(300, 7), IR(29431, 29), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpGroupCommitReadPipe, false, false, IR(307, 5), IR(29460, 20), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpGroupCommitWritePipe, false, false, IR(307, 5), IR(29480, 21), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpEnqueueMarker, true, true, IR(215, 6), IR(29501, 14), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpEnqueueKernel, true, true, IR(312, 13), IR(29515, 14), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpGetKernelNDrangeSubGroupCount, true, true, IR(325, 7), IR(29529, 30), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpGetKernelNDrangeMaxSubGroupSize, true, true, IR(325, 7), IR(29559, 32), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpGetKernelWorkGroupSize, true, true, IR(215, 6), IR(29591, 23), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpGetKernelPreferredWorkGroupSizeMultiple, true, true, IR(215, 6), IR(29614, 40), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpRetainEvent, false, false, IR(10, 1), IR(29654, 12), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpReleaseEvent, false, false, IR(10, 1), IR(29666, 13), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpCreateUserEvent, true, true, IR(39, 2), IR(29679, 16), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpIsValidEvent, true, true, IR(160, 3), IR(29695, 13), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpSetUserEventStatus, false, false, IR(36, 2), IR(29708, 19), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpCaptureEventProfilingInfo, false, false, IR(33, 3), IR(29727, 26), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpGetDefaultQueue, true, true, IR(39, 2), IR(29753, 16), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpBuildNDRange, true, true, IR(130, 5), IR(29769, 13), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpImageSparseSampleImplicitLod, true, true, IR(185, 5), IR(29782, 29), IR(0, 0), IR(215, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSparseSampleExplicitLod, true, true, IR(190, 5), IR(29811, 29), IR(0, 0), IR(215, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSparseSampleDrefImplicitLod, true, true, IR(195, 6), IR(29840, 33), IR(0, 0), IR(215, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSparseSampleDrefExplicitLod, true, true, IR(201, 6), IR(29873, 33), IR(0, 0), IR(215, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSparseSampleProjImplicitLod, true, true, IR(185, 5), IR(29906, 33), IR(0, 0), IR(215, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSparseSampleProjExplicitLod, true, true, IR(190, 5), IR(29939, 33), IR(0, 0), IR(215, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSparseSampleProjDrefImplicitLod, true, true, IR(195, 6), IR(29972, 37), IR(0, 0), IR(215, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSparseSampleProjDrefExplicitLod, true, true, IR(201, 6), IR(30009, 37), IR(0, 0), IR(215, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSparseFetch, true, true, IR(185, 5), IR(30046, 17), IR(0, 0), IR(215, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSparseGather, true, true, IR(195, 6), IR(30063, 18), IR(0, 0), IR(215, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSparseDrefGather, true, true, IR(195, 6), IR(30081, 22), IR(0, 0), IR(215, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageSparseTexelsResident, true, true, IR(160, 3), IR(30103, 26), IR(0, 0), IR(215, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpNoLine, false, false, IR(0, 0), IR(30129, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, - {spv::Op::OpAtomicFlagTestAndSet, true, true, IR(226, 5), IR(30136, 21), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicFlagClear, false, false, IR(332, 3), IR(30157, 16), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpImageSparseRead, true, true, IR(185, 5), IR(30173, 16), IR(0, 0), IR(215, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpSizeOf, true, true, IR(160, 3), IR(30189, 7), IR(0, 0), IR(1, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kMiscellaneous}, - {spv::Op::OpTypePipeStorage, true, false, IR(68, 1), IR(30196, 16), IR(0, 0), IR(216, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpConstantPipeStorage, true, true, IR(335, 5), IR(30212, 20), IR(0, 0), IR(216, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpCreatePipeFromPipeStorage, true, true, IR(160, 3), IR(30232, 26), IR(0, 0), IR(216, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpGetKernelLocalSizeForSubgroupCount, true, true, IR(325, 7), IR(30258, 35), IR(0, 0), IR(149, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpGetKernelMaxNumSubgroups, true, true, IR(215, 6), IR(30293, 25), IR(0, 0), IR(149, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, - {spv::Op::OpTypeNamedBarrier, true, false, IR(68, 1), IR(30318, 17), IR(0, 0), IR(217, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpNamedBarrierInitialize, true, true, IR(160, 3), IR(30335, 23), IR(0, 0), IR(217, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kBarrier}, - {spv::Op::OpMemoryNamedBarrier, false, false, IR(332, 3), IR(30358, 19), IR(0, 0), IR(217, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kBarrier}, - {spv::Op::OpModuleProcessed, false, false, IR(11, 1), IR(30377, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kDebug}, - {spv::Op::OpExecutionModeId, false, false, IR(65, 2), IR(30393, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,2), 0xffffffffu, PrintingClass::kMode_Setting}, - {spv::Op::OpDecorateId, false, false, IR(163, 2), IR(30409, 11), IR(0, 0), IR(1, 0), IR(154, 1), SPV_SPIRV_VERSION_WORD(1,2), 0xffffffffu, PrintingClass::kAnnotation}, - {spv::Op::OpGroupNonUniformElect, true, true, IR(340, 3), IR(30420, 21), IR(0, 0), IR(76, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformAll, true, true, IR(274, 4), IR(30441, 19), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformAny, true, true, IR(274, 4), IR(30460, 19), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformAllEqual, true, true, IR(274, 4), IR(30479, 24), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformBroadcast, true, true, IR(278, 5), IR(30503, 25), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformBroadcastFirst, true, true, IR(274, 4), IR(30528, 30), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformBallot, true, true, IR(274, 4), IR(5569, 22), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformInverseBallot, true, true, IR(274, 4), IR(30558, 29), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformBallotBitExtract, true, true, IR(278, 5), IR(30587, 32), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformBallotBitCount, true, true, IR(283, 5), IR(30619, 30), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformBallotFindLSB, true, true, IR(274, 4), IR(30649, 29), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformBallotFindMSB, true, true, IR(274, 4), IR(30678, 29), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformShuffle, true, true, IR(278, 5), IR(8659, 23), IR(0, 0), IR(220, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformShuffleXor, true, true, IR(278, 5), IR(30707, 26), IR(0, 0), IR(220, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformShuffleUp, true, true, IR(278, 5), IR(30733, 25), IR(0, 0), IR(221, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformShuffleDown, true, true, IR(278, 5), IR(30758, 27), IR(0, 0), IR(221, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformIAdd, true, true, IR(343, 6), IR(30785, 20), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformFAdd, true, true, IR(343, 6), IR(30805, 20), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformIMul, true, true, IR(343, 6), IR(30825, 20), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformFMul, true, true, IR(343, 6), IR(30845, 20), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformSMin, true, true, IR(343, 6), IR(30865, 20), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformUMin, true, true, IR(343, 6), IR(30885, 20), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformFMin, true, true, IR(343, 6), IR(30905, 20), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformSMax, true, true, IR(343, 6), IR(30925, 20), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformUMax, true, true, IR(343, 6), IR(30945, 20), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformFMax, true, true, IR(343, 6), IR(30965, 20), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformBitwiseAnd, true, true, IR(343, 6), IR(30985, 26), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformBitwiseOr, true, true, IR(343, 6), IR(31011, 25), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformBitwiseXor, true, true, IR(343, 6), IR(31036, 26), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformLogicalAnd, true, true, IR(343, 6), IR(31062, 26), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformLogicalOr, true, true, IR(343, 6), IR(31088, 25), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformLogicalXor, true, true, IR(343, 6), IR(31113, 26), IR(0, 0), IR(222, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformQuadBroadcast, true, true, IR(278, 5), IR(31139, 29), IR(0, 0), IR(225, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformQuadSwap, true, true, IR(278, 5), IR(31168, 24), IR(0, 0), IR(225, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpCopyLogical, true, true, IR(160, 3), IR(31192, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,4), 0xffffffffu, PrintingClass::kComposite}, - {spv::Op::OpPtrEqual, true, true, IR(172, 4), IR(31204, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,4), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpPtrNotEqual, true, true, IR(172, 4), IR(31213, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,4), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpPtrDiff, true, true, IR(172, 4), IR(31225, 8), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,4), 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpColorAttachmentReadEXT, true, true, IR(349, 4), IR(31233, 23), IR(0, 0), IR(141, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpDepthAttachmentReadEXT, true, true, IR(353, 3), IR(31256, 23), IR(0, 0), IR(150, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpStencilAttachmentReadEXT, true, true, IR(353, 3), IR(31279, 25), IR(0, 0), IR(151, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpTypeTensorARM, true, false, IR(356, 4), IR(31304, 14), IR(0, 0), IR(198, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTensorReadARM, true, true, IR(360, 5), IR(31360, 14), IR(0, 0), IR(198, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kTensor}, - {spv::Op::OpTensorWriteARM, false, false, IR(365, 4), IR(31374, 15), IR(0, 0), IR(198, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kTensor}, - {spv::Op::OpTensorQuerySizeARM, true, true, IR(172, 4), IR(31389, 19), IR(0, 0), IR(198, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kTensor}, - {spv::Op::OpTerminateInvocation, false, false, IR(0, 0), IR(31408, 20), IR(0, 0), IR(3, 1), IR(164, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpTypeUntypedPointerKHR, true, false, IR(369, 2), IR(31428, 22), IR(0, 0), IR(229, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpUntypedVariableKHR, true, true, IR(371, 5), IR(31450, 19), IR(0, 0), IR(229, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpUntypedAccessChainKHR, true, true, IR(151, 5), IR(31469, 22), IR(0, 0), IR(229, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpUntypedInBoundsAccessChainKHR, true, true, IR(151, 5), IR(31491, 30), IR(0, 0), IR(229, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpSubgroupBallotKHR, true, true, IR(160, 3), IR(5330, 18), IR(0, 0), IR(230, 1), IR(2, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupFirstInvocationKHR, true, true, IR(160, 3), IR(31521, 27), IR(0, 0), IR(230, 1), IR(2, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpUntypedPtrAccessChainKHR, true, true, IR(376, 6), IR(31548, 25), IR(0, 0), IR(229, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpUntypedInBoundsPtrAccessChainKHR, true, true, IR(376, 6), IR(31573, 33), IR(0, 0), IR(229, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpUntypedArrayLengthKHR, true, true, IR(382, 5), IR(31606, 22), IR(0, 0), IR(229, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpUntypedPrefetchKHR, false, false, IR(387, 5), IR(31628, 19), IR(0, 0), IR(229, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpSubgroupAllKHR, true, true, IR(160, 3), IR(31647, 15), IR(0, 0), IR(231, 1), IR(40, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupAnyKHR, true, true, IR(160, 3), IR(31662, 15), IR(0, 0), IR(231, 1), IR(40, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupAllEqualKHR, true, true, IR(160, 3), IR(31677, 20), IR(0, 0), IR(231, 1), IR(40, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupNonUniformRotateKHR, true, true, IR(392, 6), IR(13128, 25), IR(0, 0), IR(232, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupReadInvocationKHR, true, true, IR(172, 4), IR(31697, 26), IR(0, 0), IR(230, 1), IR(2, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpExtInstWithForwardRefsKHR, true, true, IR(398, 5), IR(31723, 26), IR(0, 0), IR(1, 0), IR(165, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kExtension}, - {spv::Op::OpTraceRayKHR, false, false, IR(403, 11), IR(31749, 12), IR(0, 0), IR(60, 1), IR(28, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpExecuteCallableKHR, false, false, IR(36, 2), IR(31761, 19), IR(0, 0), IR(60, 1), IR(28, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpConvertUToAccelerationStructureKHR, true, true, IR(160, 3), IR(31780, 35), IR(0, 0), IR(233, 2), IR(166, 2), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpIgnoreIntersectionKHR, false, false, IR(0, 0), IR(31815, 22), IR(0, 0), IR(60, 1), IR(28, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTerminateRayKHR, false, false, IR(0, 0), IR(31837, 16), IR(0, 0), IR(60, 1), IR(28, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpSDot, true, true, IR(414, 5), IR(31900, 5), IR(93, 1), IR(235, 1), IR(120, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpUDot, true, true, IR(414, 5), IR(31913, 5), IR(94, 1), IR(235, 1), IR(120, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpSUDot, true, true, IR(414, 5), IR(31926, 6), IR(95, 1), IR(235, 1), IR(120, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpSDotAccSat, true, true, IR(419, 6), IR(31941, 11), IR(96, 1), IR(235, 1), IR(120, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpUDotAccSat, true, true, IR(419, 6), IR(31966, 11), IR(97, 1), IR(235, 1), IR(120, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpSUDotAccSat, true, true, IR(419, 6), IR(31991, 12), IR(98, 1), IR(235, 1), IR(120, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpTypeCooperativeMatrixKHR, true, false, IR(425, 6), IR(32018, 25), IR(0, 0), IR(236, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpCooperativeMatrixLoadKHR, true, true, IR(431, 6), IR(32043, 25), IR(0, 0), IR(236, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpCooperativeMatrixStoreKHR, false, false, IR(437, 5), IR(32068, 26), IR(0, 0), IR(236, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpCooperativeMatrixMulAddKHR, true, true, IR(442, 6), IR(32148, 27), IR(0, 0), IR(236, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpCooperativeMatrixLengthKHR, true, true, IR(160, 3), IR(32175, 27), IR(0, 0), IR(236, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMiscellaneous}, - {spv::Op::OpConstantCompositeReplicateEXT, true, true, IR(160, 3), IR(32202, 30), IR(0, 0), IR(237, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpSpecConstantCompositeReplicateEXT, true, true, IR(160, 3), IR(32232, 34), IR(0, 0), IR(237, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpCompositeConstructReplicateEXT, true, true, IR(160, 3), IR(32266, 31), IR(0, 0), IR(237, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kComposite}, - {spv::Op::OpTypeRayQueryKHR, true, false, IR(68, 1), IR(32297, 16), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpRayQueryInitializeKHR, false, false, IR(448, 8), IR(32313, 22), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryTerminateKHR, false, false, IR(10, 1), IR(32335, 21), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGenerateIntersectionKHR, false, false, IR(36, 2), IR(32356, 32), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryConfirmIntersectionKHR, false, false, IR(10, 1), IR(32388, 31), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryProceedKHR, true, true, IR(160, 3), IR(32419, 19), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionTypeKHR, true, true, IR(172, 4), IR(32438, 31), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpImageSampleWeightedQCOM, true, true, IR(130, 5), IR(32469, 24), IR(0, 0), IR(238, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageBoxFilterQCOM, true, true, IR(130, 5), IR(32493, 19), IR(0, 0), IR(239, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageBlockMatchSSDQCOM, true, true, IR(325, 7), IR(32512, 23), IR(0, 0), IR(240, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageBlockMatchSADQCOM, true, true, IR(325, 7), IR(32535, 23), IR(0, 0), IR(240, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageBlockMatchWindowSSDQCOM, true, true, IR(325, 7), IR(32558, 29), IR(0, 0), IR(241, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageBlockMatchWindowSADQCOM, true, true, IR(325, 7), IR(32587, 29), IR(0, 0), IR(241, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageBlockMatchGatherSSDQCOM, true, true, IR(325, 7), IR(32616, 29), IR(0, 0), IR(241, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpImageBlockMatchGatherSADQCOM, true, true, IR(325, 7), IR(32645, 29), IR(0, 0), IR(241, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpGroupIAddNonUniformAMD, true, true, IR(283, 5), IR(32674, 23), IR(0, 0), IR(214, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupFAddNonUniformAMD, true, true, IR(283, 5), IR(32697, 23), IR(0, 0), IR(214, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupFMinNonUniformAMD, true, true, IR(283, 5), IR(32720, 23), IR(0, 0), IR(214, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupUMinNonUniformAMD, true, true, IR(283, 5), IR(32743, 23), IR(0, 0), IR(214, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupSMinNonUniformAMD, true, true, IR(283, 5), IR(32766, 23), IR(0, 0), IR(214, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupFMaxNonUniformAMD, true, true, IR(283, 5), IR(32789, 23), IR(0, 0), IR(214, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupUMaxNonUniformAMD, true, true, IR(283, 5), IR(32812, 23), IR(0, 0), IR(214, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupSMaxNonUniformAMD, true, true, IR(283, 5), IR(32835, 23), IR(0, 0), IR(214, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpFragmentMaskFetchAMD, true, true, IR(172, 4), IR(32858, 21), IR(0, 0), IR(242, 1), IR(56, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpFragmentFetchAMD, true, true, IR(130, 5), IR(32879, 17), IR(0, 0), IR(242, 1), IR(56, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpReadClockKHR, true, true, IR(340, 3), IR(32896, 13), IR(0, 0), IR(243, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpAllocateNodePayloadsAMDX, true, true, IR(278, 5), IR(32909, 25), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpEnqueueNodePayloadsAMDX, false, false, IR(10, 1), IR(32934, 24), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTypeNodePayloadArrayAMDX, true, false, IR(87, 2), IR(32958, 25), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpFinishWritingNodePayloadAMDX, true, true, IR(160, 3), IR(32983, 29), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpNodePayloadArrayLengthAMDX, true, true, IR(160, 3), IR(33012, 27), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpIsNodePayloadValidAMDX, true, true, IR(172, 4), IR(33039, 23), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpConstantStringAMDX, true, false, IR(50, 2), IR(33062, 19), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpSpecConstantStringAMDX, true, false, IR(50, 2), IR(33081, 23), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpGroupNonUniformQuadAllKHR, true, true, IR(160, 3), IR(33104, 26), IR(0, 0), IR(158, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpGroupNonUniformQuadAnyKHR, true, true, IR(160, 3), IR(33130, 26), IR(0, 0), IR(158, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpHitObjectRecordHitMotionNV, false, false, IR(456, 14), IR(33156, 27), IR(0, 0), IR(244, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectRecordHitWithIndexMotionNV, false, false, IR(470, 13), IR(33183, 36), IR(0, 0), IR(244, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectRecordMissMotionNV, false, false, IR(483, 7), IR(33219, 28), IR(0, 0), IR(244, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetWorldToObjectNV, true, true, IR(160, 3), IR(33247, 28), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetObjectToWorldNV, true, true, IR(160, 3), IR(33275, 28), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetObjectRayDirectionNV, true, true, IR(160, 3), IR(33303, 33), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetObjectRayOriginNV, true, true, IR(160, 3), IR(33336, 30), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectTraceRayMotionNV, false, false, IR(470, 13), IR(33366, 26), IR(0, 0), IR(244, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetShaderRecordBufferHandleNV, true, true, IR(160, 3), IR(33392, 39), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetShaderBindingTableRecordIndexNV, true, true, IR(160, 3), IR(33431, 44), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectRecordEmptyNV, false, false, IR(10, 1), IR(33475, 23), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectTraceRayNV, false, false, IR(490, 12), IR(33498, 20), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectRecordHitNV, false, false, IR(470, 13), IR(33518, 21), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectRecordHitWithIndexNV, false, false, IR(490, 12), IR(33539, 30), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectRecordMissNV, false, false, IR(502, 6), IR(33569, 22), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectExecuteShaderNV, false, false, IR(36, 2), IR(33591, 25), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetCurrentTimeNV, true, true, IR(160, 3), IR(33616, 26), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetAttributesNV, false, false, IR(36, 2), IR(33642, 25), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetHitKindNV, true, true, IR(160, 3), IR(33667, 22), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetPrimitiveIndexNV, true, true, IR(160, 3), IR(33689, 29), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetGeometryIndexNV, true, true, IR(160, 3), IR(33718, 28), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetInstanceIdNV, true, true, IR(160, 3), IR(33746, 25), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetInstanceCustomIndexNV, true, true, IR(160, 3), IR(33771, 34), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetWorldRayDirectionNV, true, true, IR(160, 3), IR(33805, 32), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetWorldRayOriginNV, true, true, IR(160, 3), IR(33837, 29), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetRayTMaxNV, true, true, IR(160, 3), IR(33866, 22), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetRayTMinNV, true, true, IR(160, 3), IR(33888, 22), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectIsEmptyNV, true, true, IR(160, 3), IR(33910, 19), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectIsHitNV, true, true, IR(160, 3), IR(33929, 17), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectIsMissNV, true, true, IR(160, 3), IR(33946, 18), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpReorderThreadWithHitObjectNV, false, false, IR(508, 3), IR(33964, 29), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpReorderThreadWithHintNV, false, false, IR(36, 2), IR(33993, 24), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTypeHitObjectNV, true, false, IR(68, 1), IR(34017, 16), IR(0, 0), IR(120, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpImageSampleFootprintNV, true, true, IR(511, 7), IR(34033, 23), IR(0, 0), IR(246, 1), IR(70, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpTypeCooperativeVectorNV, true, false, IR(89, 3), IR(34056, 24), IR(0, 0), IR(247, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpCooperativeVectorMatrixMulNV, true, true, IR(518, 13), IR(34080, 29), IR(0, 0), IR(247, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpCooperativeVectorOuterProductAccumulateNV, false, false, IR(531, 7), IR(34109, 42), IR(0, 0), IR(248, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpCooperativeVectorReduceSumAccumulateNV, false, false, IR(33, 3), IR(34151, 39), IR(0, 0), IR(248, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpCooperativeVectorMatrixMulAddNV, true, true, IR(538, 16), IR(34190, 32), IR(0, 0), IR(247, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpCooperativeMatrixConvertNV, true, true, IR(160, 3), IR(34222, 27), IR(0, 0), IR(249, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpEmitMeshTasksEXT, false, false, IR(554, 4), IR(34249, 17), IR(0, 0), IR(53, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpSetMeshOutputsEXT, false, false, IR(36, 2), IR(34266, 18), IR(0, 0), IR(53, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpGroupNonUniformPartitionNV, true, true, IR(160, 3), IR(34284, 27), IR(0, 0), IR(179, 1), IR(73, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kNon_Uniform}, - {spv::Op::OpWritePackedPrimitiveIndices4x8NV, false, false, IR(36, 2), IR(34311, 33), IR(0, 0), IR(50, 1), IR(18, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpFetchMicroTriangleVertexPositionNV, true, true, IR(325, 7), IR(34344, 35), IR(0, 0), IR(250, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpFetchMicroTriangleVertexBarycentricNV, true, true, IR(325, 7), IR(34379, 38), IR(0, 0), IR(250, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpCooperativeVectorLoadNV, true, true, IR(558, 5), IR(34417, 24), IR(0, 0), IR(247, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpCooperativeVectorStoreNV, false, false, IR(563, 4), IR(34441, 25), IR(0, 0), IR(247, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpReportIntersectionKHR, true, true, IR(172, 4), IR(34466, 22), IR(99, 1), IR(54, 2), IR(24, 2), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpIgnoreIntersectionNV, false, false, IR(0, 0), IR(34509, 21), IR(0, 0), IR(56, 1), IR(26, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTerminateRayNV, false, false, IR(0, 0), IR(34530, 15), IR(0, 0), IR(56, 1), IR(26, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTraceNV, false, false, IR(403, 11), IR(34545, 8), IR(0, 0), IR(56, 1), IR(26, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTraceMotionNV, false, false, IR(490, 12), IR(34553, 14), IR(0, 0), IR(57, 1), IR(27, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTraceRayMotionNV, false, false, IR(490, 12), IR(34567, 17), IR(0, 0), IR(57, 1), IR(27, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR, true, true, IR(172, 4), IR(34584, 50), IR(0, 0), IR(251, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTypeAccelerationStructureKHR, true, false, IR(68, 1), IR(34634, 29), IR(100, 1), IR(252, 4), IR(168, 4), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpExecuteCallableNV, false, false, IR(36, 2), IR(34691, 18), IR(0, 0), IR(56, 1), IR(26, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetClusterIdNV, true, true, IR(172, 4), IR(34709, 23), IR(0, 0), IR(64, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetClusterIdNV, true, true, IR(160, 3), IR(34732, 24), IR(0, 0), IR(64, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTypeCooperativeMatrixNV, true, false, IR(567, 5), IR(34756, 24), IR(0, 0), IR(256, 1), IR(77, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpCooperativeMatrixLoadNV, true, true, IR(572, 6), IR(34780, 24), IR(0, 0), IR(256, 1), IR(77, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpCooperativeMatrixStoreNV, false, false, IR(578, 5), IR(34804, 25), IR(0, 0), IR(256, 1), IR(77, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpCooperativeMatrixMulAddNV, true, true, IR(130, 5), IR(34829, 26), IR(0, 0), IR(256, 1), IR(77, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpCooperativeMatrixLengthNV, true, true, IR(160, 3), IR(34855, 26), IR(0, 0), IR(256, 1), IR(77, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpBeginInvocationInterlockEXT, false, false, IR(0, 0), IR(34881, 28), IR(0, 0), IR(257, 3), IR(78, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpEndInvocationInterlockEXT, false, false, IR(0, 0), IR(34909, 26), IR(0, 0), IR(257, 3), IR(78, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpCooperativeMatrixReduceNV, true, true, IR(583, 5), IR(34978, 26), IR(0, 0), IR(260, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kArithmetic}, - {spv::Op::OpCooperativeMatrixLoadTensorNV, true, true, IR(588, 7), IR(35079, 30), IR(0, 0), IR(196, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpCooperativeMatrixStoreTensorNV, false, false, IR(595, 5), IR(35109, 31), IR(0, 0), IR(196, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpCooperativeMatrixPerElementOpNV, true, true, IR(151, 5), IR(35140, 32), IR(0, 0), IR(261, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kFunction}, - {spv::Op::OpTypeTensorLayoutNV, true, false, IR(89, 3), IR(35172, 19), IR(0, 0), IR(262, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeTensorViewNV, true, false, IR(600, 4), IR(35191, 17), IR(0, 0), IR(262, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpCreateTensorLayoutNV, true, true, IR(39, 2), IR(35208, 21), IR(0, 0), IR(262, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTensorLayoutSetDimensionNV, true, true, IR(122, 4), IR(35229, 27), IR(0, 0), IR(262, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTensorLayoutSetStrideNV, true, true, IR(122, 4), IR(35256, 24), IR(0, 0), IR(262, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTensorLayoutSliceNV, true, true, IR(122, 4), IR(35280, 20), IR(0, 0), IR(262, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTensorLayoutSetClampValueNV, true, true, IR(172, 4), IR(35300, 28), IR(0, 0), IR(262, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpCreateTensorViewNV, true, true, IR(39, 2), IR(35328, 19), IR(0, 0), IR(262, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTensorViewSetDimensionNV, true, true, IR(122, 4), IR(35347, 25), IR(0, 0), IR(262, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTensorViewSetStrideNV, true, true, IR(122, 4), IR(35372, 22), IR(0, 0), IR(262, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpDemoteToHelperInvocation, false, false, IR(0, 0), IR(11440, 25), IR(45, 1), IR(263, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kControl_Flow}, - {spv::Op::OpIsHelperInvocationEXT, true, true, IR(39, 2), IR(35394, 22), IR(0, 0), IR(263, 1), IR(79, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTensorViewSetClipNV, true, true, IR(325, 7), IR(35416, 20), IR(0, 0), IR(262, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTensorLayoutSetBlockSizeNV, true, true, IR(122, 4), IR(35436, 27), IR(0, 0), IR(262, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpCooperativeMatrixTransposeNV, true, true, IR(160, 3), IR(35463, 29), IR(0, 0), IR(249, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpConvertUToImageNV, true, true, IR(160, 3), IR(35492, 18), IR(0, 0), IR(121, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpConvertUToSamplerNV, true, true, IR(160, 3), IR(35510, 20), IR(0, 0), IR(121, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpConvertImageToUNV, true, true, IR(160, 3), IR(35530, 18), IR(0, 0), IR(121, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpConvertSamplerToUNV, true, true, IR(160, 3), IR(35548, 20), IR(0, 0), IR(121, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpConvertUToSampledImageNV, true, true, IR(160, 3), IR(35568, 25), IR(0, 0), IR(121, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpConvertSampledImageToUNV, true, true, IR(160, 3), IR(35593, 25), IR(0, 0), IR(121, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpSamplerImageAddressingModeNV, false, false, IR(0, 1), IR(35618, 29), IR(0, 0), IR(121, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRawAccessChainNV, true, true, IR(604, 7), IR(35699, 17), IR(0, 0), IR(185, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpRayQueryGetIntersectionSpherePositionNV, true, true, IR(172, 4), IR(35716, 40), IR(0, 0), IR(61, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionSphereRadiusNV, true, true, IR(172, 4), IR(35756, 38), IR(0, 0), IR(61, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionLSSPositionsNV, true, true, IR(172, 4), IR(35794, 38), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionLSSRadiiNV, true, true, IR(172, 4), IR(35832, 34), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionLSSHitValueNV, true, true, IR(172, 4), IR(35866, 37), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetSpherePositionNV, true, true, IR(160, 3), IR(35903, 29), IR(0, 0), IR(61, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetSphereRadiusNV, true, true, IR(160, 3), IR(35932, 27), IR(0, 0), IR(61, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetLSSPositionsNV, true, true, IR(160, 3), IR(35959, 27), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectGetLSSRadiiNV, true, true, IR(160, 3), IR(35986, 23), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectIsSphereHitNV, true, true, IR(160, 3), IR(36009, 23), IR(0, 0), IR(61, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpHitObjectIsLSSHitNV, true, true, IR(160, 3), IR(36032, 20), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryIsSphereHitNV, true, true, IR(172, 4), IR(36052, 22), IR(0, 0), IR(61, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryIsLSSHitNV, true, true, IR(172, 4), IR(36074, 19), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpSubgroupShuffleINTEL, true, true, IR(172, 4), IR(11888, 21), IR(0, 0), IR(264, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupShuffleDownINTEL, true, true, IR(130, 5), IR(36093, 25), IR(0, 0), IR(264, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupShuffleUpINTEL, true, true, IR(130, 5), IR(36118, 23), IR(0, 0), IR(264, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupShuffleXorINTEL, true, true, IR(172, 4), IR(36141, 24), IR(0, 0), IR(264, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupBlockReadINTEL, true, true, IR(160, 3), IR(36165, 23), IR(0, 0), IR(265, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupBlockWriteINTEL, false, false, IR(36, 2), IR(36188, 24), IR(0, 0), IR(265, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupImageBlockReadINTEL, true, true, IR(172, 4), IR(36212, 28), IR(0, 0), IR(266, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupImageBlockWriteINTEL, false, false, IR(33, 3), IR(36240, 29), IR(0, 0), IR(266, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupImageMediaBlockReadINTEL, true, true, IR(215, 6), IR(36269, 33), IR(0, 0), IR(267, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupImageMediaBlockWriteINTEL, false, false, IR(611, 5), IR(36302, 34), IR(0, 0), IR(267, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpUCountLeadingZerosINTEL, true, true, IR(160, 3), IR(36336, 24), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpUCountTrailingZerosINTEL, true, true, IR(160, 3), IR(36360, 25), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpAbsISubINTEL, true, true, IR(172, 4), IR(36385, 13), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpAbsUSubINTEL, true, true, IR(172, 4), IR(36398, 13), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpIAddSatINTEL, true, true, IR(172, 4), IR(36411, 13), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpUAddSatINTEL, true, true, IR(172, 4), IR(36424, 13), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpIAverageINTEL, true, true, IR(172, 4), IR(36437, 14), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpUAverageINTEL, true, true, IR(172, 4), IR(36451, 14), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpIAverageRoundedINTEL, true, true, IR(172, 4), IR(36465, 21), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpUAverageRoundedINTEL, true, true, IR(172, 4), IR(36486, 21), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpISubSatINTEL, true, true, IR(172, 4), IR(36507, 13), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpUSubSatINTEL, true, true, IR(172, 4), IR(36520, 13), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpIMul32x16INTEL, true, true, IR(172, 4), IR(36533, 15), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpUMul32x16INTEL, true, true, IR(172, 4), IR(36548, 15), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpConstantFunctionPointerINTEL, true, true, IR(160, 3), IR(36563, 29), IR(0, 0), IR(194, 1), IR(93, 1), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpFunctionPointerCallINTEL, true, true, IR(107, 3), IR(36592, 25), IR(0, 0), IR(194, 1), IR(93, 1), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpAsmTargetINTEL, true, false, IR(50, 2), IR(36617, 15), IR(0, 0), IR(124, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpAsmINTEL, true, true, IR(616, 6), IR(12106, 9), IR(0, 0), IR(124, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpAsmCallINTEL, true, true, IR(122, 4), IR(36632, 13), IR(0, 0), IR(124, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpAtomicFMinEXT, true, true, IR(235, 6), IR(36645, 14), IR(0, 0), IR(269, 4), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAtomicFMaxEXT, true, true, IR(235, 6), IR(36659, 14), IR(0, 0), IR(269, 4), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpAssumeTrueKHR, false, false, IR(10, 1), IR(36673, 14), IR(0, 0), IR(273, 1), IR(97, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kMiscellaneous}, - {spv::Op::OpExpectKHR, true, true, IR(172, 4), IR(36687, 10), IR(0, 0), IR(273, 1), IR(97, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kMiscellaneous}, - {spv::Op::OpDecorateString, false, false, IR(163, 2), IR(36697, 15), IR(101, 1), IR(1, 0), IR(172, 2), SPV_SPIRV_VERSION_WORD(1,4), 0xffffffffu, PrintingClass::kAnnotation}, - {spv::Op::OpMemberDecorateString, false, false, IR(165, 3), IR(36733, 21), IR(102, 1), IR(1, 0), IR(172, 2), SPV_SPIRV_VERSION_WORD(1,4), 0xffffffffu, PrintingClass::kAnnotation}, - {spv::Op::OpVmeImageINTEL, true, true, IR(172, 4), IR(36781, 14), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpTypeVmeImageINTEL, true, false, IR(87, 2), IR(36795, 18), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpTypeAvcImePayloadINTEL, true, false, IR(68, 1), IR(36813, 23), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpTypeAvcRefPayloadINTEL, true, false, IR(68, 1), IR(36836, 23), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpTypeAvcSicPayloadINTEL, true, false, IR(68, 1), IR(36859, 23), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpTypeAvcMcePayloadINTEL, true, false, IR(68, 1), IR(36882, 23), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpTypeAvcMceResultINTEL, true, false, IR(68, 1), IR(36905, 22), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpTypeAvcImeResultINTEL, true, false, IR(68, 1), IR(36927, 22), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpTypeAvcImeResultSingleReferenceStreamoutINTEL, true, false, IR(68, 1), IR(36949, 46), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpTypeAvcImeResultDualReferenceStreamoutINTEL, true, false, IR(68, 1), IR(36995, 44), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpTypeAvcImeSingleReferenceStreaminINTEL, true, false, IR(68, 1), IR(37039, 39), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpTypeAvcImeDualReferenceStreaminINTEL, true, false, IR(68, 1), IR(37078, 37), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpTypeAvcRefResultINTEL, true, false, IR(68, 1), IR(37115, 22), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpTypeAvcSicResultINTEL, true, false, IR(68, 1), IR(37137, 22), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL, true, true, IR(172, 4), IR(37159, 60), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL, true, true, IR(172, 4), IR(37219, 53), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL, true, true, IR(172, 4), IR(37272, 47), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceSetInterShapePenaltyINTEL, true, true, IR(172, 4), IR(37319, 40), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL, true, true, IR(172, 4), IR(37359, 51), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceSetInterDirectionPenaltyINTEL, true, true, IR(172, 4), IR(37410, 44), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL, true, true, IR(172, 4), IR(37454, 51), IR(0, 0), IR(275, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL, true, true, IR(172, 4), IR(37505, 56), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL, true, true, IR(39, 2), IR(37561, 50), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL, true, true, IR(39, 2), IR(37611, 52), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL, true, true, IR(39, 2), IR(37663, 49), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL, true, true, IR(215, 6), IR(37712, 47), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL, true, true, IR(172, 4), IR(37759, 50), IR(0, 0), IR(275, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL, true, true, IR(39, 2), IR(37809, 51), IR(0, 0), IR(275, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL, true, true, IR(39, 2), IR(37860, 56), IR(0, 0), IR(277, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceSetAcOnlyHaarINTEL, true, true, IR(160, 3), IR(37916, 33), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL, true, true, IR(172, 4), IR(37949, 52), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL, true, true, IR(172, 4), IR(38001, 61), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL, true, true, IR(130, 5), IR(38062, 61), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceConvertToImePayloadINTEL, true, true, IR(160, 3), IR(38123, 39), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceConvertToImeResultINTEL, true, true, IR(160, 3), IR(38162, 38), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceConvertToRefPayloadINTEL, true, true, IR(160, 3), IR(38200, 39), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceConvertToRefResultINTEL, true, true, IR(160, 3), IR(38239, 38), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceConvertToSicPayloadINTEL, true, true, IR(160, 3), IR(38277, 39), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceConvertToSicResultINTEL, true, true, IR(160, 3), IR(38316, 38), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetMotionVectorsINTEL, true, true, IR(160, 3), IR(38354, 36), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetInterDistortionsINTEL, true, true, IR(160, 3), IR(38390, 39), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetBestInterDistortionsINTEL, true, true, IR(160, 3), IR(38429, 43), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetInterMajorShapeINTEL, true, true, IR(160, 3), IR(38472, 38), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetInterMinorShapeINTEL, true, true, IR(160, 3), IR(38510, 38), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetInterDirectionsINTEL, true, true, IR(160, 3), IR(38548, 38), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetInterMotionVectorCountINTEL, true, true, IR(160, 3), IR(38586, 45), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetInterReferenceIdsINTEL, true, true, IR(160, 3), IR(38631, 40), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL, true, true, IR(130, 5), IR(38671, 62), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeInitializeINTEL, true, true, IR(130, 5), IR(38733, 30), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeSetSingleReferenceINTEL, true, true, IR(130, 5), IR(38763, 38), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeSetDualReferenceINTEL, true, true, IR(215, 6), IR(38801, 36), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeRefWindowSizeINTEL, true, true, IR(172, 4), IR(38837, 33), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeAdjustRefOffsetINTEL, true, true, IR(215, 6), IR(38870, 35), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeConvertToMcePayloadINTEL, true, true, IR(160, 3), IR(38905, 39), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeSetMaxMotionVectorCountINTEL, true, true, IR(172, 4), IR(38944, 43), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL, true, true, IR(160, 3), IR(38987, 47), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL, true, true, IR(172, 4), IR(39034, 54), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeSetWeightedSadINTEL, true, true, IR(172, 4), IR(39088, 34), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL, true, true, IR(130, 5), IR(39122, 47), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeEvaluateWithDualReferenceINTEL, true, true, IR(215, 6), IR(39169, 45), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL, true, true, IR(215, 6), IR(39214, 55), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL, true, true, IR(325, 7), IR(39269, 53), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL, true, true, IR(130, 5), IR(39322, 56), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL, true, true, IR(215, 6), IR(39378, 54), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL, true, true, IR(215, 6), IR(39432, 58), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL, true, true, IR(325, 7), IR(39490, 56), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeConvertToMceResultINTEL, true, true, IR(160, 3), IR(39546, 38), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeGetSingleReferenceStreaminINTEL, true, true, IR(160, 3), IR(39584, 46), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeGetDualReferenceStreaminINTEL, true, true, IR(160, 3), IR(39630, 44), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL, true, true, IR(160, 3), IR(39674, 49), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeStripDualReferenceStreamoutINTEL, true, true, IR(160, 3), IR(39723, 47), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL, true, true, IR(172, 4), IR(39770, 70), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL, true, true, IR(172, 4), IR(39840, 68), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL, true, true, IR(172, 4), IR(39908, 69), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL, true, true, IR(130, 5), IR(39977, 68), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL, true, true, IR(130, 5), IR(40045, 66), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL, true, true, IR(130, 5), IR(40111, 67), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeGetBorderReachedINTEL, true, true, IR(172, 4), IR(40178, 36), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL, true, true, IR(160, 3), IR(40214, 48), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL, true, true, IR(160, 3), IR(40262, 59), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL, true, true, IR(160, 3), IR(40321, 58), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL, true, true, IR(160, 3), IR(40379, 56), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcFmeInitializeINTEL, true, true, IR(622, 9), IR(40435, 30), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcBmeInitializeINTEL, true, true, IR(631, 10), IR(40465, 30), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcRefConvertToMcePayloadINTEL, true, true, IR(160, 3), IR(40495, 39), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcRefSetBidirectionalMixDisableINTEL, true, true, IR(160, 3), IR(40534, 46), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcRefSetBilinearFilterEnableINTEL, true, true, IR(160, 3), IR(40580, 43), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL, true, true, IR(130, 5), IR(40623, 47), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcRefEvaluateWithDualReferenceINTEL, true, true, IR(215, 6), IR(40670, 45), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL, true, true, IR(130, 5), IR(40715, 46), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL, true, true, IR(215, 6), IR(40761, 56), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcRefConvertToMceResultINTEL, true, true, IR(160, 3), IR(40817, 38), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicInitializeINTEL, true, true, IR(160, 3), IR(40855, 30), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicConfigureSkcINTEL, true, true, IR(288, 8), IR(40885, 32), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicConfigureIpeLumaINTEL, true, true, IR(631, 10), IR(40917, 36), IR(0, 0), IR(275, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicConfigureIpeLumaChromaINTEL, true, true, IR(641, 13), IR(40953, 42), IR(0, 0), IR(277, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicGetMotionVectorMaskINTEL, true, true, IR(172, 4), IR(40995, 39), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicConvertToMcePayloadINTEL, true, true, IR(160, 3), IR(41034, 39), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL, true, true, IR(172, 4), IR(41073, 44), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL, true, true, IR(215, 6), IR(41117, 48), IR(0, 0), IR(275, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL, true, true, IR(172, 4), IR(41165, 50), IR(0, 0), IR(277, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicSetBilinearFilterEnableINTEL, true, true, IR(160, 3), IR(41215, 43), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL, true, true, IR(172, 4), IR(41258, 48), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL, true, true, IR(172, 4), IR(41306, 43), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicEvaluateIpeINTEL, true, true, IR(172, 4), IR(41349, 31), IR(0, 0), IR(275, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL, true, true, IR(130, 5), IR(41380, 47), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicEvaluateWithDualReferenceINTEL, true, true, IR(215, 6), IR(41427, 45), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL, true, true, IR(130, 5), IR(41472, 46), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL, true, true, IR(215, 6), IR(41518, 56), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicConvertToMceResultINTEL, true, true, IR(160, 3), IR(41574, 38), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicGetIpeLumaShapeINTEL, true, true, IR(160, 3), IR(41612, 35), IR(0, 0), IR(275, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL, true, true, IR(160, 3), IR(41647, 44), IR(0, 0), IR(275, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL, true, true, IR(160, 3), IR(41691, 46), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicGetPackedIpeLumaModesINTEL, true, true, IR(160, 3), IR(41737, 41), IR(0, 0), IR(275, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicGetIpeChromaModeINTEL, true, true, IR(160, 3), IR(41778, 36), IR(0, 0), IR(277, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL, true, true, IR(160, 3), IR(41814, 50), IR(0, 0), IR(275, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL, true, true, IR(160, 3), IR(41864, 48), IR(0, 0), IR(275, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSubgroupAvcSicGetInterRawSadsINTEL, true, true, IR(160, 3), IR(41912, 35), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpVariableLengthArrayINTEL, true, true, IR(160, 3), IR(12344, 25), IR(0, 0), IR(279, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpSaveMemoryINTEL, true, true, IR(39, 2), IR(41947, 16), IR(0, 0), IR(279, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpRestoreMemoryINTEL, false, false, IR(10, 1), IR(41963, 19), IR(0, 0), IR(279, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatSinCosPiINTEL, true, true, IR(654, 8), IR(41982, 28), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatCastINTEL, true, true, IR(654, 8), IR(42010, 24), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatCastFromIntINTEL, true, true, IR(654, 8), IR(42034, 31), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatCastToIntINTEL, true, true, IR(654, 8), IR(42065, 29), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatAddINTEL, true, true, IR(662, 10), IR(42094, 23), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatSubINTEL, true, true, IR(662, 10), IR(42117, 23), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatMulINTEL, true, true, IR(662, 10), IR(42140, 23), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatDivINTEL, true, true, IR(662, 10), IR(42163, 23), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatGTINTEL, true, true, IR(672, 6), IR(42186, 22), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatGEINTEL, true, true, IR(672, 6), IR(42208, 22), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatLTINTEL, true, true, IR(672, 6), IR(42230, 22), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatLEINTEL, true, true, IR(672, 6), IR(42252, 22), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatEQINTEL, true, true, IR(672, 6), IR(42274, 22), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatRecipINTEL, true, true, IR(654, 8), IR(42296, 25), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatRSqrtINTEL, true, true, IR(654, 8), IR(42321, 25), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatCbrtINTEL, true, true, IR(654, 8), IR(42346, 24), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatHypotINTEL, true, true, IR(662, 10), IR(42370, 25), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatSqrtINTEL, true, true, IR(654, 8), IR(42395, 24), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatLogINTEL, true, true, IR(654, 8), IR(42419, 23), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatLog2INTEL, true, true, IR(654, 8), IR(42442, 24), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatLog10INTEL, true, true, IR(654, 8), IR(42466, 25), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatLog1pINTEL, true, true, IR(654, 8), IR(42491, 25), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatExpINTEL, true, true, IR(654, 8), IR(42516, 23), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatExp2INTEL, true, true, IR(654, 8), IR(42539, 24), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatExp10INTEL, true, true, IR(654, 8), IR(42563, 25), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatExpm1INTEL, true, true, IR(654, 8), IR(42588, 25), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatSinINTEL, true, true, IR(654, 8), IR(42613, 23), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatCosINTEL, true, true, IR(654, 8), IR(42636, 23), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatSinCosINTEL, true, true, IR(654, 8), IR(42659, 26), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatSinPiINTEL, true, true, IR(654, 8), IR(42685, 25), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatCosPiINTEL, true, true, IR(654, 8), IR(42710, 25), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatASinINTEL, true, true, IR(654, 8), IR(42735, 24), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatASinPiINTEL, true, true, IR(654, 8), IR(42759, 26), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatACosINTEL, true, true, IR(654, 8), IR(42785, 24), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatACosPiINTEL, true, true, IR(654, 8), IR(42809, 26), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatATanINTEL, true, true, IR(654, 8), IR(42835, 24), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatATanPiINTEL, true, true, IR(654, 8), IR(42859, 26), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatATan2INTEL, true, true, IR(662, 10), IR(42885, 25), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatPowINTEL, true, true, IR(662, 10), IR(42910, 23), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatPowRINTEL, true, true, IR(662, 10), IR(42933, 24), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpArbitraryFloatPowNINTEL, true, true, IR(662, 10), IR(42957, 24), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpLoopControlINTEL, false, false, IR(18, 1), IR(42981, 17), IR(0, 0), IR(281, 1), IR(104, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpAliasDomainDeclINTEL, true, false, IR(678, 2), IR(42998, 21), IR(0, 0), IR(130, 1), IR(111, 1), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpAliasScopeDeclINTEL, true, false, IR(680, 3), IR(43019, 20), IR(0, 0), IR(130, 1), IR(111, 1), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpAliasScopeListDeclINTEL, true, false, IR(92, 2), IR(43039, 24), IR(0, 0), IR(130, 1), IR(111, 1), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpFixedSqrtINTEL, true, true, IR(654, 8), IR(43063, 15), IR(0, 0), IR(184, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpFixedRecipINTEL, true, true, IR(654, 8), IR(43078, 16), IR(0, 0), IR(184, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpFixedRsqrtINTEL, true, true, IR(654, 8), IR(43094, 16), IR(0, 0), IR(184, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpFixedSinINTEL, true, true, IR(654, 8), IR(43110, 14), IR(0, 0), IR(184, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpFixedCosINTEL, true, true, IR(654, 8), IR(43124, 14), IR(0, 0), IR(184, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpFixedSinCosINTEL, true, true, IR(654, 8), IR(43138, 17), IR(0, 0), IR(184, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpFixedSinPiINTEL, true, true, IR(654, 8), IR(43155, 16), IR(0, 0), IR(184, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpFixedCosPiINTEL, true, true, IR(654, 8), IR(43171, 16), IR(0, 0), IR(184, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpFixedSinCosPiINTEL, true, true, IR(654, 8), IR(43187, 19), IR(0, 0), IR(184, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpFixedLogINTEL, true, true, IR(654, 8), IR(43206, 14), IR(0, 0), IR(184, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpFixedExpINTEL, true, true, IR(654, 8), IR(43220, 14), IR(0, 0), IR(184, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpPtrCastToCrossWorkgroupINTEL, true, true, IR(160, 3), IR(43234, 29), IR(0, 0), IR(195, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpCrossWorkgroupCastToPtrINTEL, true, true, IR(160, 3), IR(43263, 29), IR(0, 0), IR(195, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, - {spv::Op::OpReadPipeBlockingINTEL, true, true, IR(172, 4), IR(43292, 22), IR(0, 0), IR(282, 1), IR(118, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpWritePipeBlockingINTEL, true, true, IR(172, 4), IR(43314, 23), IR(0, 0), IR(282, 1), IR(118, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kPipe}, - {spv::Op::OpFPGARegINTEL, true, true, IR(160, 3), IR(12903, 13), IR(0, 0), IR(283, 1), IR(119, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetRayTMinKHR, true, true, IR(160, 3), IR(43337, 22), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetRayFlagsKHR, true, true, IR(160, 3), IR(43359, 23), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionTKHR, true, true, IR(172, 4), IR(43382, 28), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR, true, true, IR(172, 4), IR(43410, 46), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionInstanceIdKHR, true, true, IR(172, 4), IR(43456, 37), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR, true, true, IR(172, 4), IR(43493, 65), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionGeometryIndexKHR, true, true, IR(172, 4), IR(43558, 40), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionPrimitiveIndexKHR, true, true, IR(172, 4), IR(43598, 41), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionBarycentricsKHR, true, true, IR(172, 4), IR(43639, 39), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionFrontFaceKHR, true, true, IR(172, 4), IR(43678, 36), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR, true, true, IR(160, 3), IR(43714, 46), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionObjectRayDirectionKHR, true, true, IR(172, 4), IR(43760, 45), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionObjectRayOriginKHR, true, true, IR(172, 4), IR(43805, 42), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetWorldRayDirectionKHR, true, true, IR(160, 3), IR(43847, 32), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetWorldRayOriginKHR, true, true, IR(160, 3), IR(43879, 29), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionObjectToWorldKHR, true, true, IR(172, 4), IR(43908, 40), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpRayQueryGetIntersectionWorldToObjectKHR, true, true, IR(172, 4), IR(43948, 40), IR(0, 0), IR(188, 1), IR(47, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpAtomicFAddEXT, true, true, IR(235, 6), IR(43988, 14), IR(0, 0), IR(284, 4), IR(126, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kAtomic}, - {spv::Op::OpTypeBufferSurfaceINTEL, true, false, IR(100, 2), IR(44002, 23), IR(0, 0), IR(122, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpTypeStructContinuedINTEL, false, false, IR(683, 1), IR(44025, 25), IR(0, 0), IR(288, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpConstantCompositeContinuedINTEL, false, false, IR(683, 1), IR(44050, 32), IR(0, 0), IR(288, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpSpecConstantCompositeContinuedINTEL, false, false, IR(683, 1), IR(44082, 36), IR(0, 0), IR(288, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConstant_Creation}, - {spv::Op::OpCompositeConstructContinuedINTEL, true, true, IR(107, 3), IR(44118, 33), IR(0, 0), IR(288, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kComposite}, - {spv::Op::OpConvertFToBF16INTEL, true, true, IR(160, 3), IR(44151, 20), IR(0, 0), IR(289, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpConvertBF16ToFINTEL, true, true, IR(160, 3), IR(44171, 20), IR(0, 0), IR(289, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpControlBarrierArriveINTEL, false, false, IR(221, 3), IR(44191, 26), IR(0, 0), IR(290, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kBarrier}, - {spv::Op::OpControlBarrierWaitINTEL, false, false, IR(221, 3), IR(44217, 24), IR(0, 0), IR(290, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kBarrier}, - {spv::Op::OpArithmeticFenceEXT, true, true, IR(160, 3), IR(13335, 19), IR(0, 0), IR(291, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMiscellaneous}, - {spv::Op::OpTaskSequenceCreateINTEL, true, true, IR(684, 7), IR(44241, 24), IR(0, 0), IR(292, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTaskSequenceAsyncINTEL, false, false, IR(168, 2), IR(44265, 23), IR(0, 0), IR(292, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTaskSequenceGetINTEL, true, true, IR(160, 3), IR(44288, 21), IR(0, 0), IR(292, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTaskSequenceReleaseINTEL, false, false, IR(10, 1), IR(44309, 25), IR(0, 0), IR(292, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, - {spv::Op::OpTypeTaskSequenceINTEL, true, false, IR(68, 1), IR(44334, 22), IR(0, 0), IR(292, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, - {spv::Op::OpSubgroupBlockPrefetchINTEL, false, false, IR(139, 3), IR(44356, 27), IR(0, 0), IR(293, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroup2DBlockLoadINTEL, false, false, IR(691, 10), IR(44383, 25), IR(0, 0), IR(105, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroup2DBlockLoadTransformINTEL, false, false, IR(691, 10), IR(44408, 34), IR(0, 0), IR(294, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroup2DBlockLoadTransposeINTEL, false, false, IR(691, 10), IR(44442, 34), IR(0, 0), IR(295, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroup2DBlockPrefetchINTEL, false, false, IR(701, 9), IR(44476, 29), IR(0, 0), IR(105, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroup2DBlockStoreINTEL, false, false, IR(691, 10), IR(44505, 26), IR(0, 0), IR(105, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpSubgroupMatrixMultiplyAccumulateINTEL, true, true, IR(710, 7), IR(13673, 38), IR(0, 0), IR(296, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpBitwiseFunctionINTEL, true, true, IR(215, 6), IR(44593, 21), IR(0, 0), IR(297, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kBit}, - {spv::Op::OpGroupIMulKHR, true, true, IR(283, 5), IR(44614, 13), IR(0, 0), IR(298, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupFMulKHR, true, true, IR(283, 5), IR(44627, 13), IR(0, 0), IR(298, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupBitwiseAndKHR, true, true, IR(283, 5), IR(44640, 19), IR(0, 0), IR(298, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupBitwiseOrKHR, true, true, IR(283, 5), IR(44659, 18), IR(0, 0), IR(298, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupBitwiseXorKHR, true, true, IR(283, 5), IR(44677, 19), IR(0, 0), IR(298, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupLogicalAndKHR, true, true, IR(283, 5), IR(44696, 19), IR(0, 0), IR(298, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupLogicalOrKHR, true, true, IR(283, 5), IR(44715, 18), IR(0, 0), IR(298, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpGroupLogicalXorKHR, true, true, IR(283, 5), IR(44733, 19), IR(0, 0), IR(298, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, - {spv::Op::OpRoundFToTF32INTEL, true, true, IR(160, 3), IR(44752, 18), IR(0, 0), IR(299, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConversion}, - {spv::Op::OpMaskedGatherINTEL, true, true, IR(717, 6), IR(44770, 18), IR(0, 0), IR(300, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpMaskedScatterINTEL, false, false, IR(723, 4), IR(44788, 19), IR(0, 0), IR(300, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, - {spv::Op::OpConvertHandleToImageINTEL, true, true, IR(160, 3), IR(44807, 26), IR(0, 0), IR(301, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpConvertHandleToSamplerINTEL, true, true, IR(160, 3), IR(44833, 28), IR(0, 0), IR(301, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, - {spv::Op::OpConvertHandleToSampledImageINTEL, true, true, IR(160, 3), IR(44861, 33), IR(0, 0), IR(301, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, +static const std::array kInstructionDesc{{ + {spv::Op::OpNop, false, false, IR(0, 0), IR(25214, 4), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMiscellaneous}, + {spv::Op::OpUndef, true, true, IR(39, 2), IR(25270, 6), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMiscellaneous}, + {spv::Op::OpSourceContinued, false, false, IR(11, 1), IR(25276, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, + {spv::Op::OpSource, false, false, IR(41, 4), IR(25395, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, + {spv::Op::OpSourceExtension, false, false, IR(11, 1), IR(25402, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, + {spv::Op::OpName, false, false, IR(45, 2), IR(25418, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, + {spv::Op::OpMemberName, false, false, IR(47, 3), IR(25423, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, + {spv::Op::OpString, true, false, IR(50, 2), IR(25434, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, + {spv::Op::OpLine, false, false, IR(52, 3), IR(25441, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, + {spv::Op::OpExtension, false, false, IR(11, 1), IR(25446, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kExtension}, + {spv::Op::OpExtInstImport, true, false, IR(50, 2), IR(25456, 14), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kExtension}, + {spv::Op::OpExtInst, true, true, IR(55, 4), IR(25516, 8), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kExtension}, + {spv::Op::OpMemoryModel, false, false, IR(59, 2), IR(25588, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMode_Setting}, + {spv::Op::OpEntryPoint, false, false, IR(61, 4), IR(25662, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMode_Setting}, + {spv::Op::OpExecutionMode, false, false, IR(65, 2), IR(25705, 14), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMode_Setting}, + {spv::Op::OpCapability, false, false, IR(67, 1), IR(25747, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMode_Setting}, + {spv::Op::OpTypeVoid, true, false, IR(68, 1), IR(25758, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeBool, true, false, IR(68, 1), IR(25767, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeInt, true, false, IR(69, 3), IR(25776, 8), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeFloat, true, false, IR(72, 3), IR(25821, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeVector, true, false, IR(75, 3), IR(25831, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeMatrix, true, false, IR(75, 3), IR(25842, 11), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeImage, true, false, IR(78, 9), IR(25966, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeSampler, true, false, IR(68, 1), IR(25976, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeSampledImage, true, false, IR(87, 2), IR(25988, 17), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeArray, true, false, IR(89, 3), IR(26005, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeRuntimeArray, true, false, IR(87, 2), IR(26015, 17), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeStruct, true, false, IR(92, 2), IR(26032, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeOpaque, true, false, IR(50, 2), IR(26043, 11), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypePointer, true, false, IR(94, 3), IR(26085, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeFunction, true, false, IR(97, 3), IR(26097, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeEvent, true, false, IR(68, 1), IR(26110, 10), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeDeviceEvent, true, false, IR(68, 1), IR(26120, 16), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeReserveId, true, false, IR(68, 1), IR(26136, 14), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeQueue, true, false, IR(68, 1), IR(26150, 10), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypePipe, true, false, IR(100, 2), IR(26160, 9), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeForwardPointer, false, false, IR(102, 2), IR(26169, 19), IR(0, 0), IR(203, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpConstantTrue, true, true, IR(39, 2), IR(26188, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpConstantFalse, true, true, IR(39, 2), IR(26201, 14), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpConstant, true, true, IR(104, 3), IR(15470, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpConstantComposite, true, true, IR(107, 3), IR(26253, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpConstantSampler, true, true, IR(110, 5), IR(26349, 16), IR(0, 0), IR(205, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpConstantNull, true, true, IR(39, 2), IR(26365, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpSpecConstantTrue, true, true, IR(39, 2), IR(26378, 17), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpSpecConstantFalse, true, true, IR(39, 2), IR(26395, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpSpecConstant, true, true, IR(104, 3), IR(26413, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpSpecConstantComposite, true, true, IR(107, 3), IR(26426, 22), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpSpecConstantOp, true, true, IR(115, 3), IR(26489, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpFunction, true, true, IR(118, 4), IR(24566, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kFunction}, + {spv::Op::OpFunctionParameter, true, true, IR(39, 2), IR(26538, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kFunction}, + {spv::Op::OpFunctionEnd, false, false, IR(0, 0), IR(26556, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kFunction}, + {spv::Op::OpFunctionCall, true, true, IR(122, 4), IR(26568, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kFunction}, + {spv::Op::OpVariable, true, true, IR(126, 4), IR(26581, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpImageTexelPointer, true, true, IR(130, 5), IR(26590, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpLoad, true, true, IR(135, 4), IR(26648, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpStore, false, false, IR(139, 3), IR(26653, 6), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpCopyMemory, false, false, IR(142, 4), IR(26659, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpCopyMemorySized, false, false, IR(146, 5), IR(26670, 16), IR(0, 0), IR(206, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpAccessChain, true, true, IR(122, 4), IR(26686, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpInBoundsAccessChain, true, true, IR(122, 4), IR(26698, 20), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpPtrAccessChain, true, true, IR(151, 5), IR(26718, 15), IR(0, 0), IR(208, 4), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpArrayLength, true, true, IR(156, 4), IR(26733, 12), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpGenericPtrMemSemantics, true, true, IR(160, 3), IR(26745, 23), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpInBoundsPtrAccessChain, true, true, IR(151, 5), IR(26768, 23), IR(0, 0), IR(1, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpDecorate, false, false, IR(163, 2), IR(26819, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAnnotation}, + {spv::Op::OpMemberDecorate, false, false, IR(165, 3), IR(26828, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAnnotation}, + {spv::Op::OpDecorationGroup, true, false, IR(68, 1), IR(26843, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAnnotation}, + {spv::Op::OpGroupDecorate, false, false, IR(168, 2), IR(26859, 14), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAnnotation}, + {spv::Op::OpGroupMemberDecorate, false, false, IR(170, 2), IR(26918, 20), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAnnotation}, + {spv::Op::OpVectorExtractDynamic, true, true, IR(172, 4), IR(26938, 21), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpVectorInsertDynamic, true, true, IR(130, 5), IR(26959, 20), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpVectorShuffle, true, true, IR(176, 5), IR(26979, 14), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpCompositeConstruct, true, true, IR(107, 3), IR(26993, 19), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpCompositeExtract, true, true, IR(181, 4), IR(27012, 17), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpCompositeInsert, true, true, IR(176, 5), IR(27029, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpCopyObject, true, true, IR(160, 3), IR(27045, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpTranspose, true, true, IR(160, 3), IR(27056, 10), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpSampledImage, true, true, IR(172, 4), IR(27066, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSampleImplicitLod, true, true, IR(185, 5), IR(27111, 23), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSampleExplicitLod, true, true, IR(190, 5), IR(27157, 23), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSampleDrefImplicitLod, true, true, IR(195, 6), IR(27180, 27), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSampleDrefExplicitLod, true, true, IR(201, 6), IR(27207, 27), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSampleProjImplicitLod, true, true, IR(185, 5), IR(27234, 27), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSampleProjExplicitLod, true, true, IR(190, 5), IR(27261, 27), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSampleProjDrefImplicitLod, true, true, IR(195, 6), IR(27288, 31), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSampleProjDrefExplicitLod, true, true, IR(201, 6), IR(27319, 31), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageFetch, true, true, IR(185, 5), IR(27350, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageGather, true, true, IR(195, 6), IR(27361, 12), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageDrefGather, true, true, IR(195, 6), IR(27373, 16), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageRead, true, true, IR(185, 5), IR(27389, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageWrite, false, false, IR(207, 4), IR(27399, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImage, true, true, IR(160, 3), IR(24610, 6), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageQueryFormat, true, true, IR(160, 3), IR(27410, 17), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageQueryOrder, true, true, IR(160, 3), IR(27427, 16), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageQuerySizeLod, true, true, IR(172, 4), IR(27443, 18), IR(0, 0), IR(212, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageQuerySize, true, true, IR(160, 3), IR(27461, 15), IR(0, 0), IR(212, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageQueryLod, true, true, IR(172, 4), IR(27476, 14), IR(0, 0), IR(214, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageQueryLevels, true, true, IR(160, 3), IR(27490, 17), IR(0, 0), IR(212, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageQuerySamples, true, true, IR(160, 3), IR(27507, 18), IR(0, 0), IR(212, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpConvertFToU, true, true, IR(160, 3), IR(27525, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpConvertFToS, true, true, IR(160, 3), IR(27537, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpConvertSToF, true, true, IR(160, 3), IR(27549, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpConvertUToF, true, true, IR(160, 3), IR(27561, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpUConvert, true, true, IR(160, 3), IR(27573, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpSConvert, true, true, IR(160, 3), IR(27582, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpFConvert, true, true, IR(160, 3), IR(27591, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpQuantizeToF16, true, true, IR(160, 3), IR(27600, 14), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpConvertPtrToU, true, true, IR(160, 3), IR(27614, 14), IR(0, 0), IR(203, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpSatConvertSToU, true, true, IR(160, 3), IR(27628, 15), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpSatConvertUToS, true, true, IR(160, 3), IR(27643, 15), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpConvertUToPtr, true, true, IR(160, 3), IR(27658, 14), IR(0, 0), IR(203, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpPtrCastToGeneric, true, true, IR(160, 3), IR(27672, 17), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpGenericCastToPtr, true, true, IR(160, 3), IR(27689, 17), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpGenericCastToPtrExplicit, true, true, IR(211, 4), IR(27706, 25), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpBitcast, true, true, IR(160, 3), IR(27731, 8), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpSNegate, true, true, IR(160, 3), IR(27739, 8), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpFNegate, true, true, IR(160, 3), IR(27747, 8), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpIAdd, true, true, IR(172, 4), IR(27755, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpFAdd, true, true, IR(172, 4), IR(27760, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpISub, true, true, IR(172, 4), IR(27765, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpFSub, true, true, IR(172, 4), IR(27770, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpIMul, true, true, IR(172, 4), IR(27775, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpFMul, true, true, IR(172, 4), IR(27780, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpUDiv, true, true, IR(172, 4), IR(27785, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpSDiv, true, true, IR(172, 4), IR(27790, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpFDiv, true, true, IR(172, 4), IR(27795, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpUMod, true, true, IR(172, 4), IR(27800, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpSRem, true, true, IR(172, 4), IR(27805, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpSMod, true, true, IR(172, 4), IR(27810, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpFRem, true, true, IR(172, 4), IR(27815, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpFMod, true, true, IR(172, 4), IR(27820, 5), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpVectorTimesScalar, true, true, IR(172, 4), IR(27825, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpMatrixTimesScalar, true, true, IR(172, 4), IR(27843, 18), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpVectorTimesMatrix, true, true, IR(172, 4), IR(27861, 18), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpMatrixTimesVector, true, true, IR(172, 4), IR(27879, 18), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpMatrixTimesMatrix, true, true, IR(172, 4), IR(27897, 18), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpOuterProduct, true, true, IR(172, 4), IR(27915, 13), IR(0, 0), IR(66, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpDot, true, true, IR(172, 4), IR(27928, 4), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpIAddCarry, true, true, IR(172, 4), IR(27932, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpISubBorrow, true, true, IR(172, 4), IR(27942, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpUMulExtended, true, true, IR(172, 4), IR(27953, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpSMulExtended, true, true, IR(172, 4), IR(27966, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpAny, true, true, IR(160, 3), IR(27979, 4), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpAll, true, true, IR(160, 3), IR(27983, 4), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpIsNan, true, true, IR(160, 3), IR(27987, 6), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpIsInf, true, true, IR(160, 3), IR(27993, 6), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpIsFinite, true, true, IR(160, 3), IR(27999, 9), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpIsNormal, true, true, IR(160, 3), IR(28008, 9), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpSignBitSet, true, true, IR(160, 3), IR(28017, 11), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpLessOrGreater, true, true, IR(172, 4), IR(28028, 14), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), SPV_SPIRV_VERSION_WORD(1,5), PrintingClass::kRelational_and_Logical}, + {spv::Op::OpOrdered, true, true, IR(172, 4), IR(28042, 8), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpUnordered, true, true, IR(172, 4), IR(28050, 10), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpLogicalEqual, true, true, IR(172, 4), IR(28060, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpLogicalNotEqual, true, true, IR(172, 4), IR(28073, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpLogicalOr, true, true, IR(172, 4), IR(28089, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpLogicalAnd, true, true, IR(172, 4), IR(28099, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpLogicalNot, true, true, IR(160, 3), IR(28110, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpSelect, true, true, IR(130, 5), IR(28121, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpIEqual, true, true, IR(172, 4), IR(28128, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpINotEqual, true, true, IR(172, 4), IR(28135, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpUGreaterThan, true, true, IR(172, 4), IR(28145, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpSGreaterThan, true, true, IR(172, 4), IR(28158, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpUGreaterThanEqual, true, true, IR(172, 4), IR(28171, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpSGreaterThanEqual, true, true, IR(172, 4), IR(28189, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpULessThan, true, true, IR(172, 4), IR(28207, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpSLessThan, true, true, IR(172, 4), IR(28217, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpULessThanEqual, true, true, IR(172, 4), IR(28227, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpSLessThanEqual, true, true, IR(172, 4), IR(28242, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpFOrdEqual, true, true, IR(172, 4), IR(28257, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpFUnordEqual, true, true, IR(172, 4), IR(28267, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpFOrdNotEqual, true, true, IR(172, 4), IR(28279, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpFUnordNotEqual, true, true, IR(172, 4), IR(28292, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpFOrdLessThan, true, true, IR(172, 4), IR(28307, 13), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpFUnordLessThan, true, true, IR(172, 4), IR(28320, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpFOrdGreaterThan, true, true, IR(172, 4), IR(28335, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpFUnordGreaterThan, true, true, IR(172, 4), IR(28351, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpFOrdLessThanEqual, true, true, IR(172, 4), IR(28369, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpFUnordLessThanEqual, true, true, IR(172, 4), IR(28387, 20), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpFOrdGreaterThanEqual, true, true, IR(172, 4), IR(28407, 21), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpFUnordGreaterThanEqual, true, true, IR(172, 4), IR(28428, 23), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kRelational_and_Logical}, + {spv::Op::OpShiftRightLogical, true, true, IR(172, 4), IR(28451, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, + {spv::Op::OpShiftRightArithmetic, true, true, IR(172, 4), IR(28469, 21), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, + {spv::Op::OpShiftLeftLogical, true, true, IR(172, 4), IR(28490, 17), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, + {spv::Op::OpBitwiseOr, true, true, IR(172, 4), IR(28507, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, + {spv::Op::OpBitwiseXor, true, true, IR(172, 4), IR(28517, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, + {spv::Op::OpBitwiseAnd, true, true, IR(172, 4), IR(28528, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, + {spv::Op::OpNot, true, true, IR(160, 3), IR(28539, 4), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, + {spv::Op::OpBitFieldInsert, true, true, IR(215, 6), IR(28543, 15), IR(0, 0), IR(215, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, + {spv::Op::OpBitFieldSExtract, true, true, IR(130, 5), IR(28558, 17), IR(0, 0), IR(215, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, + {spv::Op::OpBitFieldUExtract, true, true, IR(130, 5), IR(28575, 17), IR(0, 0), IR(215, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, + {spv::Op::OpBitReverse, true, true, IR(160, 3), IR(28592, 11), IR(0, 0), IR(215, 2), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, + {spv::Op::OpBitCount, true, true, IR(160, 3), IR(28603, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBit}, + {spv::Op::OpDPdx, true, true, IR(160, 3), IR(28612, 5), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, + {spv::Op::OpDPdy, true, true, IR(160, 3), IR(28617, 5), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, + {spv::Op::OpFwidth, true, true, IR(160, 3), IR(28622, 7), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, + {spv::Op::OpDPdxFine, true, true, IR(160, 3), IR(28629, 9), IR(0, 0), IR(217, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, + {spv::Op::OpDPdyFine, true, true, IR(160, 3), IR(28638, 9), IR(0, 0), IR(217, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, + {spv::Op::OpFwidthFine, true, true, IR(160, 3), IR(28647, 11), IR(0, 0), IR(217, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, + {spv::Op::OpDPdxCoarse, true, true, IR(160, 3), IR(28658, 11), IR(0, 0), IR(217, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, + {spv::Op::OpDPdyCoarse, true, true, IR(160, 3), IR(28669, 11), IR(0, 0), IR(217, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, + {spv::Op::OpFwidthCoarse, true, true, IR(160, 3), IR(28680, 13), IR(0, 0), IR(217, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDerivative}, + {spv::Op::OpEmitVertex, false, false, IR(0, 0), IR(28693, 11), IR(0, 0), IR(69, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPrimitive}, + {spv::Op::OpEndPrimitive, false, false, IR(0, 0), IR(28704, 13), IR(0, 0), IR(69, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPrimitive}, + {spv::Op::OpEmitStreamVertex, false, false, IR(10, 1), IR(28717, 17), IR(0, 0), IR(116, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPrimitive}, + {spv::Op::OpEndStreamPrimitive, false, false, IR(10, 1), IR(28734, 19), IR(0, 0), IR(116, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPrimitive}, + {spv::Op::OpControlBarrier, false, false, IR(221, 3), IR(28790, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBarrier}, + {spv::Op::OpMemoryBarrier, false, false, IR(224, 2), IR(28805, 14), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kBarrier}, + {spv::Op::OpAtomicLoad, true, true, IR(226, 5), IR(28819, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicStore, false, false, IR(231, 4), IR(28830, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicExchange, true, true, IR(235, 6), IR(28842, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicCompareExchange, true, true, IR(241, 8), IR(28857, 22), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicCompareExchangeWeak, true, true, IR(241, 8), IR(28879, 26), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), SPV_SPIRV_VERSION_WORD(1,3), PrintingClass::kAtomic}, + {spv::Op::OpAtomicIIncrement, true, true, IR(226, 5), IR(28905, 17), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicIDecrement, true, true, IR(226, 5), IR(28922, 17), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicIAdd, true, true, IR(235, 6), IR(28939, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicISub, true, true, IR(235, 6), IR(28950, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicSMin, true, true, IR(235, 6), IR(28961, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicUMin, true, true, IR(235, 6), IR(28972, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicSMax, true, true, IR(235, 6), IR(28983, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicUMax, true, true, IR(235, 6), IR(28994, 11), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicAnd, true, true, IR(235, 6), IR(29005, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicOr, true, true, IR(235, 6), IR(29015, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicXor, true, true, IR(235, 6), IR(29024, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpPhi, true, true, IR(107, 3), IR(29034, 4), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpLoopMerge, false, false, IR(249, 3), IR(29068, 10), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpSelectionMerge, false, false, IR(252, 2), IR(29113, 15), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpLabel, true, false, IR(68, 1), IR(29128, 6), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpBranch, false, false, IR(10, 1), IR(29134, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpBranchConditional, false, false, IR(254, 4), IR(29141, 18), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpSwitch, false, false, IR(258, 3), IR(29204, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpKill, false, false, IR(0, 0), IR(29211, 5), IR(0, 0), IR(3, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpReturn, false, false, IR(0, 0), IR(29216, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpReturnValue, false, false, IR(10, 1), IR(29223, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpUnreachable, false, false, IR(0, 0), IR(29235, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpLifetimeStart, false, false, IR(261, 2), IR(29247, 14), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpLifetimeStop, false, false, IR(261, 2), IR(29261, 13), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpGroupAsyncCopy, true, true, IR(263, 8), IR(29274, 15), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupWaitEvents, false, false, IR(271, 3), IR(29289, 16), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupAll, true, true, IR(274, 4), IR(29305, 9), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupAny, true, true, IR(274, 4), IR(29314, 9), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupBroadcast, true, true, IR(278, 5), IR(29323, 15), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupIAdd, true, true, IR(283, 5), IR(29371, 10), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupFAdd, true, true, IR(283, 5), IR(29381, 10), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupFMin, true, true, IR(283, 5), IR(29391, 10), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupUMin, true, true, IR(283, 5), IR(29401, 10), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupSMin, true, true, IR(283, 5), IR(29411, 10), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupFMax, true, true, IR(283, 5), IR(29421, 10), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupUMax, true, true, IR(283, 5), IR(29431, 10), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupSMax, true, true, IR(283, 5), IR(29441, 10), IR(0, 0), IR(218, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpReadPipe, true, true, IR(215, 6), IR(29451, 9), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpWritePipe, true, true, IR(215, 6), IR(29460, 10), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpReservedReadPipe, true, true, IR(288, 8), IR(29470, 17), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpReservedWritePipe, true, true, IR(288, 8), IR(29487, 18), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpReserveReadPipePackets, true, true, IR(215, 6), IR(29505, 23), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpReserveWritePipePackets, true, true, IR(215, 6), IR(29528, 24), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpCommitReadPipe, false, false, IR(296, 4), IR(29552, 15), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpCommitWritePipe, false, false, IR(296, 4), IR(29567, 16), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpIsValidReserveId, true, true, IR(160, 3), IR(29583, 17), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpGetNumPipePackets, true, true, IR(130, 5), IR(29600, 18), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpGetMaxPipePackets, true, true, IR(130, 5), IR(29618, 18), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpGroupReserveReadPipePackets, true, true, IR(300, 7), IR(29636, 28), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpGroupReserveWritePipePackets, true, true, IR(300, 7), IR(29664, 29), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpGroupCommitReadPipe, false, false, IR(307, 5), IR(29693, 20), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpGroupCommitWritePipe, false, false, IR(307, 5), IR(29713, 21), IR(0, 0), IR(75, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpEnqueueMarker, true, true, IR(215, 6), IR(29734, 14), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpEnqueueKernel, true, true, IR(312, 13), IR(29748, 14), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpGetKernelNDrangeSubGroupCount, true, true, IR(325, 7), IR(29762, 30), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpGetKernelNDrangeMaxSubGroupSize, true, true, IR(325, 7), IR(29792, 32), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpGetKernelWorkGroupSize, true, true, IR(215, 6), IR(29824, 23), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpGetKernelPreferredWorkGroupSizeMultiple, true, true, IR(215, 6), IR(29847, 40), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpRetainEvent, false, false, IR(10, 1), IR(29887, 12), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpReleaseEvent, false, false, IR(10, 1), IR(29899, 13), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpCreateUserEvent, true, true, IR(39, 2), IR(29912, 16), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpIsValidEvent, true, true, IR(160, 3), IR(29928, 13), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpSetUserEventStatus, false, false, IR(36, 2), IR(29941, 19), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpCaptureEventProfilingInfo, false, false, IR(33, 3), IR(29960, 26), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpGetDefaultQueue, true, true, IR(39, 2), IR(29986, 16), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpBuildNDRange, true, true, IR(130, 5), IR(30002, 13), IR(0, 0), IR(74, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpImageSparseSampleImplicitLod, true, true, IR(185, 5), IR(30015, 29), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSparseSampleExplicitLod, true, true, IR(190, 5), IR(30044, 29), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSparseSampleDrefImplicitLod, true, true, IR(195, 6), IR(30073, 33), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSparseSampleDrefExplicitLod, true, true, IR(201, 6), IR(30106, 33), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSparseSampleProjImplicitLod, true, true, IR(185, 5), IR(30139, 33), IR(0, 0), IR(219, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSparseSampleProjExplicitLod, true, true, IR(190, 5), IR(30172, 33), IR(0, 0), IR(219, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSparseSampleProjDrefImplicitLod, true, true, IR(195, 6), IR(30205, 37), IR(0, 0), IR(219, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSparseSampleProjDrefExplicitLod, true, true, IR(201, 6), IR(30242, 37), IR(0, 0), IR(219, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSparseFetch, true, true, IR(185, 5), IR(30279, 17), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSparseGather, true, true, IR(195, 6), IR(30296, 18), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSparseDrefGather, true, true, IR(195, 6), IR(30314, 22), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageSparseTexelsResident, true, true, IR(160, 3), IR(30336, 26), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpNoLine, false, false, IR(0, 0), IR(30362, 7), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kDebug}, + {spv::Op::OpAtomicFlagTestAndSet, true, true, IR(226, 5), IR(30369, 21), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicFlagClear, false, false, IR(332, 3), IR(30390, 16), IR(0, 0), IR(0, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpImageSparseRead, true, true, IR(185, 5), IR(30406, 16), IR(0, 0), IR(219, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,0), 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpSizeOf, true, true, IR(160, 3), IR(30422, 7), IR(0, 0), IR(1, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kMiscellaneous}, + {spv::Op::OpTypePipeStorage, true, false, IR(68, 1), IR(30429, 16), IR(0, 0), IR(220, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpConstantPipeStorage, true, true, IR(335, 5), IR(30445, 20), IR(0, 0), IR(220, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpCreatePipeFromPipeStorage, true, true, IR(160, 3), IR(30465, 26), IR(0, 0), IR(220, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpGetKernelLocalSizeForSubgroupCount, true, true, IR(325, 7), IR(30491, 35), IR(0, 0), IR(155, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpGetKernelMaxNumSubgroups, true, true, IR(215, 6), IR(30526, 25), IR(0, 0), IR(155, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kDevice_Side_Enqueue}, + {spv::Op::OpTypeNamedBarrier, true, false, IR(68, 1), IR(30551, 17), IR(0, 0), IR(221, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpNamedBarrierInitialize, true, true, IR(160, 3), IR(30568, 23), IR(0, 0), IR(221, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kBarrier}, + {spv::Op::OpMemoryNamedBarrier, false, false, IR(332, 3), IR(30591, 19), IR(0, 0), IR(221, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kBarrier}, + {spv::Op::OpModuleProcessed, false, false, IR(11, 1), IR(30610, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,1), 0xffffffffu, PrintingClass::kDebug}, + {spv::Op::OpExecutionModeId, false, false, IR(65, 2), IR(30626, 16), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,2), 0xffffffffu, PrintingClass::kMode_Setting}, + {spv::Op::OpDecorateId, false, false, IR(163, 2), IR(30642, 11), IR(0, 0), IR(1, 0), IR(158, 1), SPV_SPIRV_VERSION_WORD(1,2), 0xffffffffu, PrintingClass::kAnnotation}, + {spv::Op::OpGroupNonUniformElect, true, true, IR(340, 3), IR(30653, 21), IR(0, 0), IR(76, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformAll, true, true, IR(274, 4), IR(30674, 19), IR(0, 0), IR(222, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformAny, true, true, IR(274, 4), IR(30693, 19), IR(0, 0), IR(222, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformAllEqual, true, true, IR(274, 4), IR(30712, 24), IR(0, 0), IR(222, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformBroadcast, true, true, IR(278, 5), IR(30736, 25), IR(0, 0), IR(223, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformBroadcastFirst, true, true, IR(274, 4), IR(30761, 30), IR(0, 0), IR(223, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformBallot, true, true, IR(274, 4), IR(5662, 22), IR(0, 0), IR(223, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformInverseBallot, true, true, IR(274, 4), IR(30791, 29), IR(0, 0), IR(223, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformBallotBitExtract, true, true, IR(278, 5), IR(30820, 32), IR(0, 0), IR(223, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformBallotBitCount, true, true, IR(283, 5), IR(30852, 30), IR(0, 0), IR(223, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformBallotFindLSB, true, true, IR(274, 4), IR(30882, 29), IR(0, 0), IR(223, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformBallotFindMSB, true, true, IR(274, 4), IR(30911, 29), IR(0, 0), IR(223, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformShuffle, true, true, IR(278, 5), IR(8752, 23), IR(0, 0), IR(224, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformShuffleXor, true, true, IR(278, 5), IR(30940, 26), IR(0, 0), IR(224, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformShuffleUp, true, true, IR(278, 5), IR(30966, 25), IR(0, 0), IR(225, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformShuffleDown, true, true, IR(278, 5), IR(30991, 27), IR(0, 0), IR(225, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformIAdd, true, true, IR(343, 6), IR(31018, 20), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformFAdd, true, true, IR(343, 6), IR(31038, 20), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformIMul, true, true, IR(343, 6), IR(31058, 20), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformFMul, true, true, IR(343, 6), IR(31078, 20), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformSMin, true, true, IR(343, 6), IR(31098, 20), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformUMin, true, true, IR(343, 6), IR(31118, 20), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformFMin, true, true, IR(343, 6), IR(31138, 20), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformSMax, true, true, IR(343, 6), IR(31158, 20), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformUMax, true, true, IR(343, 6), IR(31178, 20), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformFMax, true, true, IR(343, 6), IR(31198, 20), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformBitwiseAnd, true, true, IR(343, 6), IR(31218, 26), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformBitwiseOr, true, true, IR(343, 6), IR(31244, 25), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformBitwiseXor, true, true, IR(343, 6), IR(31269, 26), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformLogicalAnd, true, true, IR(343, 6), IR(31295, 26), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformLogicalOr, true, true, IR(343, 6), IR(31321, 25), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformLogicalXor, true, true, IR(343, 6), IR(31346, 26), IR(0, 0), IR(226, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformQuadBroadcast, true, true, IR(278, 5), IR(31372, 29), IR(0, 0), IR(229, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformQuadSwap, true, true, IR(278, 5), IR(31401, 24), IR(0, 0), IR(229, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,3), 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpCopyLogical, true, true, IR(160, 3), IR(31425, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,4), 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpPtrEqual, true, true, IR(172, 4), IR(31437, 9), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,4), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpPtrNotEqual, true, true, IR(172, 4), IR(31446, 12), IR(0, 0), IR(1, 0), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,4), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpPtrDiff, true, true, IR(172, 4), IR(31458, 8), IR(0, 0), IR(230, 3), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,4), 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpColorAttachmentReadEXT, true, true, IR(349, 4), IR(31466, 23), IR(0, 0), IR(147, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpDepthAttachmentReadEXT, true, true, IR(353, 3), IR(31489, 23), IR(0, 0), IR(156, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpStencilAttachmentReadEXT, true, true, IR(353, 3), IR(31512, 25), IR(0, 0), IR(157, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpTypeTensorARM, true, false, IR(356, 4), IR(31537, 14), IR(0, 0), IR(202, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTensorReadARM, true, true, IR(360, 5), IR(31593, 14), IR(0, 0), IR(202, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kTensor}, + {spv::Op::OpTensorWriteARM, false, false, IR(365, 4), IR(31607, 15), IR(0, 0), IR(202, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kTensor}, + {spv::Op::OpTensorQuerySizeARM, true, true, IR(172, 4), IR(31622, 19), IR(0, 0), IR(202, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kTensor}, + {spv::Op::OpGraphConstantARM, true, true, IR(369, 3), IR(31641, 17), IR(0, 0), IR(233, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGraph}, + {spv::Op::OpGraphEntryPointARM, false, false, IR(372, 3), IR(31658, 19), IR(0, 0), IR(233, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGraph}, + {spv::Op::OpGraphARM, true, true, IR(39, 2), IR(9043, 9), IR(0, 0), IR(233, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGraph}, + {spv::Op::OpGraphInputARM, true, true, IR(122, 4), IR(31677, 14), IR(0, 0), IR(233, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGraph}, + {spv::Op::OpGraphSetOutputARM, false, false, IR(375, 3), IR(31691, 18), IR(0, 0), IR(233, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGraph}, + {spv::Op::OpGraphEndARM, false, false, IR(0, 0), IR(31709, 12), IR(0, 0), IR(233, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGraph}, + {spv::Op::OpTypeGraphARM, true, false, IR(378, 3), IR(31721, 13), IR(0, 0), IR(233, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTerminateInvocation, false, false, IR(0, 0), IR(31734, 20), IR(0, 0), IR(3, 1), IR(168, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpTypeUntypedPointerKHR, true, false, IR(381, 2), IR(31754, 22), IR(0, 0), IR(234, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpUntypedVariableKHR, true, true, IR(383, 5), IR(31776, 19), IR(0, 0), IR(234, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpUntypedAccessChainKHR, true, true, IR(151, 5), IR(31795, 22), IR(0, 0), IR(234, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpUntypedInBoundsAccessChainKHR, true, true, IR(151, 5), IR(31817, 30), IR(0, 0), IR(234, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpSubgroupBallotKHR, true, true, IR(160, 3), IR(5423, 18), IR(0, 0), IR(235, 1), IR(2, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupFirstInvocationKHR, true, true, IR(160, 3), IR(31847, 27), IR(0, 0), IR(235, 1), IR(2, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpUntypedPtrAccessChainKHR, true, true, IR(388, 6), IR(31874, 25), IR(0, 0), IR(234, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpUntypedInBoundsPtrAccessChainKHR, true, true, IR(388, 6), IR(31899, 33), IR(0, 0), IR(234, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpUntypedArrayLengthKHR, true, true, IR(394, 5), IR(31932, 22), IR(0, 0), IR(234, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpUntypedPrefetchKHR, false, false, IR(399, 5), IR(31954, 19), IR(0, 0), IR(234, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpFmaKHR, true, true, IR(130, 5), IR(31973, 7), IR(0, 0), IR(236, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpSubgroupAllKHR, true, true, IR(160, 3), IR(31980, 15), IR(0, 0), IR(237, 1), IR(41, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupAnyKHR, true, true, IR(160, 3), IR(31995, 15), IR(0, 0), IR(237, 1), IR(41, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupAllEqualKHR, true, true, IR(160, 3), IR(32010, 20), IR(0, 0), IR(237, 1), IR(41, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupNonUniformRotateKHR, true, true, IR(404, 6), IR(13262, 25), IR(0, 0), IR(238, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupReadInvocationKHR, true, true, IR(172, 4), IR(32030, 26), IR(0, 0), IR(235, 1), IR(2, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpExtInstWithForwardRefsKHR, true, true, IR(410, 5), IR(32056, 26), IR(0, 0), IR(1, 0), IR(169, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kExtension}, + {spv::Op::OpUntypedGroupAsyncCopyKHR, true, true, IR(415, 11), IR(32082, 25), IR(0, 0), IR(234, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpTraceRayKHR, false, false, IR(426, 11), IR(32107, 12), IR(0, 0), IR(60, 1), IR(28, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpExecuteCallableKHR, false, false, IR(36, 2), IR(32119, 19), IR(0, 0), IR(60, 1), IR(28, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpConvertUToAccelerationStructureKHR, true, true, IR(160, 3), IR(32138, 35), IR(0, 0), IR(239, 2), IR(170, 2), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpIgnoreIntersectionKHR, false, false, IR(0, 0), IR(32173, 22), IR(0, 0), IR(60, 1), IR(28, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTerminateRayKHR, false, false, IR(0, 0), IR(32195, 16), IR(0, 0), IR(60, 1), IR(28, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpSDot, true, true, IR(437, 5), IR(32258, 5), IR(93, 1), IR(241, 1), IR(122, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpUDot, true, true, IR(437, 5), IR(32271, 5), IR(94, 1), IR(241, 1), IR(122, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpSUDot, true, true, IR(437, 5), IR(32284, 6), IR(95, 1), IR(241, 1), IR(122, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpSDotAccSat, true, true, IR(442, 6), IR(32299, 11), IR(96, 1), IR(241, 1), IR(122, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpUDotAccSat, true, true, IR(442, 6), IR(32324, 11), IR(97, 1), IR(241, 1), IR(122, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpSUDotAccSat, true, true, IR(442, 6), IR(32349, 12), IR(98, 1), IR(241, 1), IR(122, 1), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpTypeCooperativeMatrixKHR, true, false, IR(448, 6), IR(32376, 25), IR(0, 0), IR(86, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpCooperativeMatrixLoadKHR, true, true, IR(454, 6), IR(32401, 25), IR(0, 0), IR(86, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpCooperativeMatrixStoreKHR, false, false, IR(460, 5), IR(32426, 26), IR(0, 0), IR(86, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpCooperativeMatrixMulAddKHR, true, true, IR(465, 6), IR(32506, 27), IR(0, 0), IR(86, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpCooperativeMatrixLengthKHR, true, true, IR(160, 3), IR(32533, 27), IR(0, 0), IR(86, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMiscellaneous}, + {spv::Op::OpConstantCompositeReplicateEXT, true, true, IR(160, 3), IR(32560, 30), IR(0, 0), IR(242, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpSpecConstantCompositeReplicateEXT, true, true, IR(160, 3), IR(32590, 34), IR(0, 0), IR(242, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpCompositeConstructReplicateEXT, true, true, IR(160, 3), IR(32624, 31), IR(0, 0), IR(242, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpTypeRayQueryKHR, true, false, IR(68, 1), IR(32655, 16), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpRayQueryInitializeKHR, false, false, IR(471, 8), IR(32671, 22), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryTerminateKHR, false, false, IR(10, 1), IR(32693, 21), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGenerateIntersectionKHR, false, false, IR(36, 2), IR(32714, 32), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryConfirmIntersectionKHR, false, false, IR(10, 1), IR(32746, 31), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryProceedKHR, true, true, IR(160, 3), IR(32777, 19), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionTypeKHR, true, true, IR(172, 4), IR(32796, 31), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpImageSampleWeightedQCOM, true, true, IR(130, 5), IR(32827, 24), IR(0, 0), IR(243, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageBoxFilterQCOM, true, true, IR(130, 5), IR(32851, 19), IR(0, 0), IR(244, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageBlockMatchSSDQCOM, true, true, IR(325, 7), IR(32870, 23), IR(0, 0), IR(245, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageBlockMatchSADQCOM, true, true, IR(325, 7), IR(32893, 23), IR(0, 0), IR(245, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpBitCastArrayQCOM, true, true, IR(160, 3), IR(32916, 17), IR(0, 0), IR(246, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpImageBlockMatchWindowSSDQCOM, true, true, IR(325, 7), IR(32933, 29), IR(0, 0), IR(247, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageBlockMatchWindowSADQCOM, true, true, IR(325, 7), IR(32962, 29), IR(0, 0), IR(247, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageBlockMatchGatherSSDQCOM, true, true, IR(325, 7), IR(32991, 29), IR(0, 0), IR(247, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpImageBlockMatchGatherSADQCOM, true, true, IR(325, 7), IR(33020, 29), IR(0, 0), IR(247, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpCompositeConstructCoopMatQCOM, true, true, IR(160, 3), IR(33049, 30), IR(0, 0), IR(246, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpCompositeExtractCoopMatQCOM, true, true, IR(160, 3), IR(33079, 28), IR(0, 0), IR(246, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpExtractSubArrayQCOM, true, true, IR(172, 4), IR(33107, 20), IR(0, 0), IR(246, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpGroupIAddNonUniformAMD, true, true, IR(283, 5), IR(33127, 23), IR(0, 0), IR(218, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupFAddNonUniformAMD, true, true, IR(283, 5), IR(33150, 23), IR(0, 0), IR(218, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupFMinNonUniformAMD, true, true, IR(283, 5), IR(33173, 23), IR(0, 0), IR(218, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupUMinNonUniformAMD, true, true, IR(283, 5), IR(33196, 23), IR(0, 0), IR(218, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupSMinNonUniformAMD, true, true, IR(283, 5), IR(33219, 23), IR(0, 0), IR(218, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupFMaxNonUniformAMD, true, true, IR(283, 5), IR(33242, 23), IR(0, 0), IR(218, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupUMaxNonUniformAMD, true, true, IR(283, 5), IR(33265, 23), IR(0, 0), IR(218, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupSMaxNonUniformAMD, true, true, IR(283, 5), IR(33288, 23), IR(0, 0), IR(218, 1), IR(33, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpFragmentMaskFetchAMD, true, true, IR(172, 4), IR(33311, 21), IR(0, 0), IR(248, 1), IR(58, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpFragmentFetchAMD, true, true, IR(130, 5), IR(33332, 17), IR(0, 0), IR(248, 1), IR(58, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpReadClockKHR, true, true, IR(340, 3), IR(33349, 13), IR(0, 0), IR(249, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpAllocateNodePayloadsAMDX, true, true, IR(278, 5), IR(33362, 25), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpEnqueueNodePayloadsAMDX, false, false, IR(10, 1), IR(33387, 24), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTypeNodePayloadArrayAMDX, true, false, IR(87, 2), IR(33411, 25), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpFinishWritingNodePayloadAMDX, true, true, IR(160, 3), IR(33436, 29), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpNodePayloadArrayLengthAMDX, true, true, IR(160, 3), IR(33465, 27), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpIsNodePayloadValidAMDX, true, true, IR(172, 4), IR(33492, 23), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpConstantStringAMDX, true, false, IR(50, 2), IR(33515, 19), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpSpecConstantStringAMDX, true, false, IR(50, 2), IR(33534, 23), IR(0, 0), IR(43, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpGroupNonUniformQuadAllKHR, true, true, IR(160, 3), IR(33557, 26), IR(0, 0), IR(164, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpGroupNonUniformQuadAnyKHR, true, true, IR(160, 3), IR(33583, 26), IR(0, 0), IR(164, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpHitObjectRecordHitMotionNV, false, false, IR(479, 14), IR(33609, 27), IR(0, 0), IR(250, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectRecordHitWithIndexMotionNV, false, false, IR(493, 13), IR(33636, 36), IR(0, 0), IR(250, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectRecordMissMotionNV, false, false, IR(506, 7), IR(33672, 28), IR(0, 0), IR(250, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetWorldToObjectNV, true, true, IR(160, 3), IR(33700, 28), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetObjectToWorldNV, true, true, IR(160, 3), IR(33728, 28), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetObjectRayDirectionNV, true, true, IR(160, 3), IR(33756, 33), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetObjectRayOriginNV, true, true, IR(160, 3), IR(33789, 30), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectTraceRayMotionNV, false, false, IR(493, 13), IR(33819, 26), IR(0, 0), IR(250, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetShaderRecordBufferHandleNV, true, true, IR(160, 3), IR(33845, 39), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetShaderBindingTableRecordIndexNV, true, true, IR(160, 3), IR(33884, 44), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectRecordEmptyNV, false, false, IR(10, 1), IR(33928, 23), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectTraceRayNV, false, false, IR(513, 12), IR(33951, 20), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectRecordHitNV, false, false, IR(493, 13), IR(33971, 21), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectRecordHitWithIndexNV, false, false, IR(513, 12), IR(33992, 30), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectRecordMissNV, false, false, IR(525, 6), IR(34022, 22), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectExecuteShaderNV, false, false, IR(36, 2), IR(34044, 25), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetCurrentTimeNV, true, true, IR(160, 3), IR(34069, 26), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetAttributesNV, false, false, IR(36, 2), IR(34095, 25), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetHitKindNV, true, true, IR(160, 3), IR(34120, 22), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetPrimitiveIndexNV, true, true, IR(160, 3), IR(34142, 29), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetGeometryIndexNV, true, true, IR(160, 3), IR(34171, 28), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetInstanceIdNV, true, true, IR(160, 3), IR(34199, 25), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetInstanceCustomIndexNV, true, true, IR(160, 3), IR(34224, 34), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetWorldRayDirectionNV, true, true, IR(160, 3), IR(34258, 32), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetWorldRayOriginNV, true, true, IR(160, 3), IR(34290, 29), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetRayTMaxNV, true, true, IR(160, 3), IR(34319, 22), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetRayTMinNV, true, true, IR(160, 3), IR(34341, 22), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectIsEmptyNV, true, true, IR(160, 3), IR(34363, 19), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectIsHitNV, true, true, IR(160, 3), IR(34382, 17), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectIsMissNV, true, true, IR(160, 3), IR(34399, 18), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpReorderThreadWithHitObjectNV, false, false, IR(531, 3), IR(34417, 29), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpReorderThreadWithHintNV, false, false, IR(36, 2), IR(34446, 24), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTypeHitObjectNV, true, false, IR(68, 1), IR(34470, 16), IR(0, 0), IR(126, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpImageSampleFootprintNV, true, true, IR(534, 7), IR(34486, 23), IR(0, 0), IR(252, 1), IR(72, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpTypeCooperativeVectorNV, true, false, IR(89, 3), IR(34509, 24), IR(0, 0), IR(253, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpCooperativeVectorMatrixMulNV, true, true, IR(541, 13), IR(34533, 29), IR(0, 0), IR(253, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpCooperativeVectorOuterProductAccumulateNV, false, false, IR(554, 7), IR(34562, 42), IR(0, 0), IR(254, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpCooperativeVectorReduceSumAccumulateNV, false, false, IR(33, 3), IR(34604, 39), IR(0, 0), IR(254, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpCooperativeVectorMatrixMulAddNV, true, true, IR(561, 16), IR(34643, 32), IR(0, 0), IR(253, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpCooperativeMatrixConvertNV, true, true, IR(160, 3), IR(34675, 27), IR(0, 0), IR(255, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpEmitMeshTasksEXT, false, false, IR(577, 4), IR(34702, 17), IR(0, 0), IR(53, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpSetMeshOutputsEXT, false, false, IR(36, 2), IR(34719, 18), IR(0, 0), IR(53, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpGroupNonUniformPartitionNV, true, true, IR(160, 3), IR(34737, 27), IR(0, 0), IR(183, 1), IR(75, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kNon_Uniform}, + {spv::Op::OpWritePackedPrimitiveIndices4x8NV, false, false, IR(36, 2), IR(34764, 33), IR(0, 0), IR(50, 1), IR(18, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpFetchMicroTriangleVertexPositionNV, true, true, IR(325, 7), IR(34797, 35), IR(0, 0), IR(256, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpFetchMicroTriangleVertexBarycentricNV, true, true, IR(325, 7), IR(34832, 38), IR(0, 0), IR(256, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpCooperativeVectorLoadNV, true, true, IR(581, 5), IR(34870, 24), IR(0, 0), IR(253, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpCooperativeVectorStoreNV, false, false, IR(586, 4), IR(34894, 25), IR(0, 0), IR(253, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpReportIntersectionKHR, true, true, IR(172, 4), IR(34919, 22), IR(99, 1), IR(54, 2), IR(24, 2), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpIgnoreIntersectionNV, false, false, IR(0, 0), IR(34962, 21), IR(0, 0), IR(56, 1), IR(26, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTerminateRayNV, false, false, IR(0, 0), IR(34983, 15), IR(0, 0), IR(56, 1), IR(26, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTraceNV, false, false, IR(426, 11), IR(34998, 8), IR(0, 0), IR(56, 1), IR(26, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTraceMotionNV, false, false, IR(513, 12), IR(35006, 14), IR(0, 0), IR(57, 1), IR(27, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTraceRayMotionNV, false, false, IR(513, 12), IR(35020, 17), IR(0, 0), IR(57, 1), IR(27, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR, true, true, IR(172, 4), IR(35037, 50), IR(0, 0), IR(257, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTypeAccelerationStructureKHR, true, false, IR(68, 1), IR(35087, 29), IR(100, 1), IR(258, 4), IR(172, 4), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpExecuteCallableNV, false, false, IR(36, 2), IR(35144, 18), IR(0, 0), IR(56, 1), IR(26, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionClusterIdNV, true, true, IR(172, 4), IR(35162, 35), IR(101, 1), IR(64, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetClusterIdNV, true, true, IR(160, 3), IR(35220, 24), IR(0, 0), IR(64, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTypeCooperativeMatrixNV, true, false, IR(590, 5), IR(35244, 24), IR(0, 0), IR(262, 1), IR(79, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpCooperativeMatrixLoadNV, true, true, IR(595, 6), IR(35268, 24), IR(0, 0), IR(262, 1), IR(79, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpCooperativeMatrixStoreNV, false, false, IR(601, 5), IR(35292, 25), IR(0, 0), IR(262, 1), IR(79, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpCooperativeMatrixMulAddNV, true, true, IR(130, 5), IR(35317, 26), IR(0, 0), IR(262, 1), IR(79, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpCooperativeMatrixLengthNV, true, true, IR(160, 3), IR(35343, 26), IR(0, 0), IR(262, 1), IR(79, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpBeginInvocationInterlockEXT, false, false, IR(0, 0), IR(35369, 28), IR(0, 0), IR(263, 3), IR(80, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpEndInvocationInterlockEXT, false, false, IR(0, 0), IR(35397, 26), IR(0, 0), IR(263, 3), IR(80, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpCooperativeMatrixReduceNV, true, true, IR(606, 5), IR(35466, 26), IR(0, 0), IR(266, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kArithmetic}, + {spv::Op::OpCooperativeMatrixLoadTensorNV, true, true, IR(611, 7), IR(35567, 30), IR(0, 0), IR(200, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpCooperativeMatrixStoreTensorNV, false, false, IR(618, 5), IR(35597, 31), IR(0, 0), IR(200, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpCooperativeMatrixPerElementOpNV, true, true, IR(151, 5), IR(35628, 32), IR(0, 0), IR(267, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kFunction}, + {spv::Op::OpTypeTensorLayoutNV, true, false, IR(89, 3), IR(35660, 19), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeTensorViewNV, true, false, IR(623, 4), IR(35679, 17), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpCreateTensorLayoutNV, true, true, IR(39, 2), IR(35696, 21), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTensorLayoutSetDimensionNV, true, true, IR(122, 4), IR(35717, 27), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTensorLayoutSetStrideNV, true, true, IR(122, 4), IR(35744, 24), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTensorLayoutSliceNV, true, true, IR(122, 4), IR(35768, 20), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTensorLayoutSetClampValueNV, true, true, IR(172, 4), IR(35788, 28), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpCreateTensorViewNV, true, true, IR(39, 2), IR(35816, 19), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTensorViewSetDimensionNV, true, true, IR(122, 4), IR(35835, 25), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTensorViewSetStrideNV, true, true, IR(122, 4), IR(35860, 22), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpDemoteToHelperInvocation, false, false, IR(0, 0), IR(11574, 25), IR(45, 1), IR(269, 1), IR(0, 0), SPV_SPIRV_VERSION_WORD(1,6), 0xffffffffu, PrintingClass::kControl_Flow}, + {spv::Op::OpIsHelperInvocationEXT, true, true, IR(39, 2), IR(35882, 22), IR(0, 0), IR(269, 1), IR(81, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTensorViewSetClipNV, true, true, IR(325, 7), IR(35904, 20), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTensorLayoutSetBlockSizeNV, true, true, IR(122, 4), IR(35924, 27), IR(0, 0), IR(268, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpCooperativeMatrixTransposeNV, true, true, IR(160, 3), IR(35951, 29), IR(0, 0), IR(255, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpConvertUToImageNV, true, true, IR(160, 3), IR(35980, 18), IR(0, 0), IR(127, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpConvertUToSamplerNV, true, true, IR(160, 3), IR(35998, 20), IR(0, 0), IR(127, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpConvertImageToUNV, true, true, IR(160, 3), IR(36018, 18), IR(0, 0), IR(127, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpConvertSamplerToUNV, true, true, IR(160, 3), IR(36036, 20), IR(0, 0), IR(127, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpConvertUToSampledImageNV, true, true, IR(160, 3), IR(36056, 25), IR(0, 0), IR(127, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpConvertSampledImageToUNV, true, true, IR(160, 3), IR(36081, 25), IR(0, 0), IR(127, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpSamplerImageAddressingModeNV, false, false, IR(0, 1), IR(36106, 29), IR(0, 0), IR(127, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRawAccessChainNV, true, true, IR(627, 7), IR(36187, 17), IR(0, 0), IR(189, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpRayQueryGetIntersectionSpherePositionNV, true, true, IR(172, 4), IR(36204, 40), IR(0, 0), IR(61, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionSphereRadiusNV, true, true, IR(172, 4), IR(36244, 38), IR(0, 0), IR(61, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionLSSPositionsNV, true, true, IR(172, 4), IR(36282, 38), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionLSSRadiiNV, true, true, IR(172, 4), IR(36320, 34), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionLSSHitValueNV, true, true, IR(172, 4), IR(36354, 37), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetSpherePositionNV, true, true, IR(160, 3), IR(36391, 29), IR(0, 0), IR(61, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetSphereRadiusNV, true, true, IR(160, 3), IR(36420, 27), IR(0, 0), IR(61, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetLSSPositionsNV, true, true, IR(160, 3), IR(36447, 27), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectGetLSSRadiiNV, true, true, IR(160, 3), IR(36474, 23), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectIsSphereHitNV, true, true, IR(160, 3), IR(36497, 23), IR(0, 0), IR(61, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpHitObjectIsLSSHitNV, true, true, IR(160, 3), IR(36520, 20), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryIsSphereHitNV, true, true, IR(172, 4), IR(36540, 22), IR(0, 0), IR(61, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryIsLSSHitNV, true, true, IR(172, 4), IR(36562, 19), IR(0, 0), IR(62, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpSubgroupShuffleINTEL, true, true, IR(172, 4), IR(12022, 21), IR(0, 0), IR(270, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupShuffleDownINTEL, true, true, IR(130, 5), IR(36581, 25), IR(0, 0), IR(270, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupShuffleUpINTEL, true, true, IR(130, 5), IR(36606, 23), IR(0, 0), IR(270, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupShuffleXorINTEL, true, true, IR(172, 4), IR(36629, 24), IR(0, 0), IR(270, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupBlockReadINTEL, true, true, IR(160, 3), IR(36653, 23), IR(0, 0), IR(271, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupBlockWriteINTEL, false, false, IR(36, 2), IR(36676, 24), IR(0, 0), IR(271, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupImageBlockReadINTEL, true, true, IR(172, 4), IR(36700, 28), IR(0, 0), IR(272, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupImageBlockWriteINTEL, false, false, IR(33, 3), IR(36728, 29), IR(0, 0), IR(272, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupImageMediaBlockReadINTEL, true, true, IR(215, 6), IR(36757, 33), IR(0, 0), IR(273, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupImageMediaBlockWriteINTEL, false, false, IR(634, 5), IR(36790, 34), IR(0, 0), IR(273, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpUCountLeadingZerosINTEL, true, true, IR(160, 3), IR(36824, 24), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpUCountTrailingZerosINTEL, true, true, IR(160, 3), IR(36848, 25), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpAbsISubINTEL, true, true, IR(172, 4), IR(36873, 13), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpAbsUSubINTEL, true, true, IR(172, 4), IR(36886, 13), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpIAddSatINTEL, true, true, IR(172, 4), IR(36899, 13), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpUAddSatINTEL, true, true, IR(172, 4), IR(36912, 13), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpIAverageINTEL, true, true, IR(172, 4), IR(36925, 14), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpUAverageINTEL, true, true, IR(172, 4), IR(36939, 14), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpIAverageRoundedINTEL, true, true, IR(172, 4), IR(36953, 21), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpUAverageRoundedINTEL, true, true, IR(172, 4), IR(36974, 21), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpISubSatINTEL, true, true, IR(172, 4), IR(36995, 13), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpUSubSatINTEL, true, true, IR(172, 4), IR(37008, 13), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpIMul32x16INTEL, true, true, IR(172, 4), IR(37021, 15), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpUMul32x16INTEL, true, true, IR(172, 4), IR(37036, 15), IR(0, 0), IR(274, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpConstantFunctionPointerINTEL, true, true, IR(160, 3), IR(37051, 29), IR(0, 0), IR(198, 1), IR(95, 1), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpFunctionPointerCallINTEL, true, true, IR(107, 3), IR(37080, 25), IR(0, 0), IR(198, 1), IR(95, 1), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpAsmTargetINTEL, true, false, IR(50, 2), IR(37105, 15), IR(0, 0), IR(130, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpAsmINTEL, true, true, IR(639, 6), IR(12240, 9), IR(0, 0), IR(130, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpAsmCallINTEL, true, true, IR(122, 4), IR(37120, 13), IR(0, 0), IR(130, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpAtomicFMinEXT, true, true, IR(235, 6), IR(37133, 14), IR(0, 0), IR(275, 4), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAtomicFMaxEXT, true, true, IR(235, 6), IR(37147, 14), IR(0, 0), IR(275, 4), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpAssumeTrueKHR, false, false, IR(10, 1), IR(37161, 14), IR(0, 0), IR(279, 1), IR(99, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kMiscellaneous}, + {spv::Op::OpExpectKHR, true, true, IR(172, 4), IR(37175, 10), IR(0, 0), IR(279, 1), IR(99, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kMiscellaneous}, + {spv::Op::OpDecorateString, false, false, IR(163, 2), IR(37185, 15), IR(102, 1), IR(1, 0), IR(176, 2), SPV_SPIRV_VERSION_WORD(1,4), 0xffffffffu, PrintingClass::kAnnotation}, + {spv::Op::OpMemberDecorateString, false, false, IR(165, 3), IR(37221, 21), IR(103, 1), IR(1, 0), IR(176, 2), SPV_SPIRV_VERSION_WORD(1,4), 0xffffffffu, PrintingClass::kAnnotation}, + {spv::Op::OpVmeImageINTEL, true, true, IR(172, 4), IR(37269, 14), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpTypeVmeImageINTEL, true, false, IR(87, 2), IR(37283, 18), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpTypeAvcImePayloadINTEL, true, false, IR(68, 1), IR(37301, 23), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpTypeAvcRefPayloadINTEL, true, false, IR(68, 1), IR(37324, 23), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpTypeAvcSicPayloadINTEL, true, false, IR(68, 1), IR(37347, 23), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpTypeAvcMcePayloadINTEL, true, false, IR(68, 1), IR(37370, 23), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpTypeAvcMceResultINTEL, true, false, IR(68, 1), IR(37393, 22), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpTypeAvcImeResultINTEL, true, false, IR(68, 1), IR(37415, 22), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpTypeAvcImeResultSingleReferenceStreamoutINTEL, true, false, IR(68, 1), IR(37437, 46), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpTypeAvcImeResultDualReferenceStreamoutINTEL, true, false, IR(68, 1), IR(37483, 44), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpTypeAvcImeSingleReferenceStreaminINTEL, true, false, IR(68, 1), IR(37527, 39), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpTypeAvcImeDualReferenceStreaminINTEL, true, false, IR(68, 1), IR(37566, 37), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpTypeAvcRefResultINTEL, true, false, IR(68, 1), IR(37603, 22), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpTypeAvcSicResultINTEL, true, false, IR(68, 1), IR(37625, 22), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL, true, true, IR(172, 4), IR(37647, 60), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL, true, true, IR(172, 4), IR(37707, 53), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL, true, true, IR(172, 4), IR(37760, 47), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceSetInterShapePenaltyINTEL, true, true, IR(172, 4), IR(37807, 40), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL, true, true, IR(172, 4), IR(37847, 51), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceSetInterDirectionPenaltyINTEL, true, true, IR(172, 4), IR(37898, 44), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL, true, true, IR(172, 4), IR(37942, 51), IR(0, 0), IR(281, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL, true, true, IR(172, 4), IR(37993, 56), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL, true, true, IR(39, 2), IR(38049, 50), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL, true, true, IR(39, 2), IR(38099, 52), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL, true, true, IR(39, 2), IR(38151, 49), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL, true, true, IR(215, 6), IR(38200, 47), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL, true, true, IR(172, 4), IR(38247, 50), IR(0, 0), IR(281, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL, true, true, IR(39, 2), IR(38297, 51), IR(0, 0), IR(281, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL, true, true, IR(39, 2), IR(38348, 56), IR(0, 0), IR(283, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceSetAcOnlyHaarINTEL, true, true, IR(160, 3), IR(38404, 33), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL, true, true, IR(172, 4), IR(38437, 52), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL, true, true, IR(172, 4), IR(38489, 61), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL, true, true, IR(130, 5), IR(38550, 61), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceConvertToImePayloadINTEL, true, true, IR(160, 3), IR(38611, 39), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceConvertToImeResultINTEL, true, true, IR(160, 3), IR(38650, 38), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceConvertToRefPayloadINTEL, true, true, IR(160, 3), IR(38688, 39), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceConvertToRefResultINTEL, true, true, IR(160, 3), IR(38727, 38), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceConvertToSicPayloadINTEL, true, true, IR(160, 3), IR(38765, 39), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceConvertToSicResultINTEL, true, true, IR(160, 3), IR(38804, 38), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetMotionVectorsINTEL, true, true, IR(160, 3), IR(38842, 36), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetInterDistortionsINTEL, true, true, IR(160, 3), IR(38878, 39), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetBestInterDistortionsINTEL, true, true, IR(160, 3), IR(38917, 43), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetInterMajorShapeINTEL, true, true, IR(160, 3), IR(38960, 38), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetInterMinorShapeINTEL, true, true, IR(160, 3), IR(38998, 38), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetInterDirectionsINTEL, true, true, IR(160, 3), IR(39036, 38), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetInterMotionVectorCountINTEL, true, true, IR(160, 3), IR(39074, 45), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetInterReferenceIdsINTEL, true, true, IR(160, 3), IR(39119, 40), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL, true, true, IR(130, 5), IR(39159, 62), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeInitializeINTEL, true, true, IR(130, 5), IR(39221, 30), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeSetSingleReferenceINTEL, true, true, IR(130, 5), IR(39251, 38), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeSetDualReferenceINTEL, true, true, IR(215, 6), IR(39289, 36), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeRefWindowSizeINTEL, true, true, IR(172, 4), IR(39325, 33), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeAdjustRefOffsetINTEL, true, true, IR(215, 6), IR(39358, 35), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeConvertToMcePayloadINTEL, true, true, IR(160, 3), IR(39393, 39), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeSetMaxMotionVectorCountINTEL, true, true, IR(172, 4), IR(39432, 43), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL, true, true, IR(160, 3), IR(39475, 47), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL, true, true, IR(172, 4), IR(39522, 54), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeSetWeightedSadINTEL, true, true, IR(172, 4), IR(39576, 34), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL, true, true, IR(130, 5), IR(39610, 47), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeEvaluateWithDualReferenceINTEL, true, true, IR(215, 6), IR(39657, 45), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL, true, true, IR(215, 6), IR(39702, 55), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL, true, true, IR(325, 7), IR(39757, 53), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL, true, true, IR(130, 5), IR(39810, 56), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL, true, true, IR(215, 6), IR(39866, 54), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL, true, true, IR(215, 6), IR(39920, 58), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL, true, true, IR(325, 7), IR(39978, 56), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeConvertToMceResultINTEL, true, true, IR(160, 3), IR(40034, 38), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeGetSingleReferenceStreaminINTEL, true, true, IR(160, 3), IR(40072, 46), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeGetDualReferenceStreaminINTEL, true, true, IR(160, 3), IR(40118, 44), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL, true, true, IR(160, 3), IR(40162, 49), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeStripDualReferenceStreamoutINTEL, true, true, IR(160, 3), IR(40211, 47), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL, true, true, IR(172, 4), IR(40258, 70), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL, true, true, IR(172, 4), IR(40328, 68), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL, true, true, IR(172, 4), IR(40396, 69), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL, true, true, IR(130, 5), IR(40465, 68), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL, true, true, IR(130, 5), IR(40533, 66), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL, true, true, IR(130, 5), IR(40599, 67), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeGetBorderReachedINTEL, true, true, IR(172, 4), IR(40666, 36), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL, true, true, IR(160, 3), IR(40702, 48), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL, true, true, IR(160, 3), IR(40750, 59), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL, true, true, IR(160, 3), IR(40809, 58), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL, true, true, IR(160, 3), IR(40867, 56), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcFmeInitializeINTEL, true, true, IR(645, 9), IR(40923, 30), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcBmeInitializeINTEL, true, true, IR(654, 10), IR(40953, 30), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcRefConvertToMcePayloadINTEL, true, true, IR(160, 3), IR(40983, 39), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcRefSetBidirectionalMixDisableINTEL, true, true, IR(160, 3), IR(41022, 46), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcRefSetBilinearFilterEnableINTEL, true, true, IR(160, 3), IR(41068, 43), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL, true, true, IR(130, 5), IR(41111, 47), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcRefEvaluateWithDualReferenceINTEL, true, true, IR(215, 6), IR(41158, 45), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL, true, true, IR(130, 5), IR(41203, 46), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL, true, true, IR(215, 6), IR(41249, 56), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcRefConvertToMceResultINTEL, true, true, IR(160, 3), IR(41305, 38), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicInitializeINTEL, true, true, IR(160, 3), IR(41343, 30), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicConfigureSkcINTEL, true, true, IR(288, 8), IR(41373, 32), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicConfigureIpeLumaINTEL, true, true, IR(654, 10), IR(41405, 36), IR(0, 0), IR(281, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicConfigureIpeLumaChromaINTEL, true, true, IR(664, 13), IR(41441, 42), IR(0, 0), IR(283, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicGetMotionVectorMaskINTEL, true, true, IR(172, 4), IR(41483, 39), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicConvertToMcePayloadINTEL, true, true, IR(160, 3), IR(41522, 39), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL, true, true, IR(172, 4), IR(41561, 44), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL, true, true, IR(215, 6), IR(41605, 48), IR(0, 0), IR(281, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL, true, true, IR(172, 4), IR(41653, 50), IR(0, 0), IR(283, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicSetBilinearFilterEnableINTEL, true, true, IR(160, 3), IR(41703, 43), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL, true, true, IR(172, 4), IR(41746, 48), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL, true, true, IR(172, 4), IR(41794, 43), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicEvaluateIpeINTEL, true, true, IR(172, 4), IR(41837, 31), IR(0, 0), IR(281, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL, true, true, IR(130, 5), IR(41868, 47), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicEvaluateWithDualReferenceINTEL, true, true, IR(215, 6), IR(41915, 45), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL, true, true, IR(130, 5), IR(41960, 46), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL, true, true, IR(215, 6), IR(42006, 56), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicConvertToMceResultINTEL, true, true, IR(160, 3), IR(42062, 38), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicGetIpeLumaShapeINTEL, true, true, IR(160, 3), IR(42100, 35), IR(0, 0), IR(281, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL, true, true, IR(160, 3), IR(42135, 44), IR(0, 0), IR(281, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL, true, true, IR(160, 3), IR(42179, 46), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicGetPackedIpeLumaModesINTEL, true, true, IR(160, 3), IR(42225, 41), IR(0, 0), IR(281, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicGetIpeChromaModeINTEL, true, true, IR(160, 3), IR(42266, 36), IR(0, 0), IR(283, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL, true, true, IR(160, 3), IR(42302, 50), IR(0, 0), IR(281, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL, true, true, IR(160, 3), IR(42352, 48), IR(0, 0), IR(281, 2), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpSubgroupAvcSicGetInterRawSadsINTEL, true, true, IR(160, 3), IR(42400, 35), IR(0, 0), IR(280, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpVariableLengthArrayINTEL, true, true, IR(160, 3), IR(12478, 25), IR(0, 0), IR(285, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpSaveMemoryINTEL, true, true, IR(39, 2), IR(42435, 16), IR(0, 0), IR(285, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpRestoreMemoryINTEL, false, false, IR(10, 1), IR(42451, 19), IR(0, 0), IR(285, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpArbitraryFloatSinCosPiINTEL, true, true, IR(677, 8), IR(42470, 28), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatCastINTEL, true, true, IR(677, 8), IR(42498, 24), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatCastFromIntINTEL, true, true, IR(677, 8), IR(42522, 31), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatCastToIntINTEL, true, true, IR(677, 8), IR(42553, 29), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatAddINTEL, true, true, IR(685, 10), IR(42582, 23), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatSubINTEL, true, true, IR(685, 10), IR(42605, 23), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatMulINTEL, true, true, IR(685, 10), IR(42628, 23), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatDivINTEL, true, true, IR(685, 10), IR(42651, 23), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatGTINTEL, true, true, IR(695, 6), IR(42674, 22), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatGEINTEL, true, true, IR(695, 6), IR(42696, 22), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatLTINTEL, true, true, IR(695, 6), IR(42718, 22), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatLEINTEL, true, true, IR(695, 6), IR(42740, 22), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatEQINTEL, true, true, IR(695, 6), IR(42762, 22), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatRecipINTEL, true, true, IR(677, 8), IR(42784, 25), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatRSqrtINTEL, true, true, IR(677, 8), IR(42809, 25), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatCbrtINTEL, true, true, IR(677, 8), IR(42834, 24), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatHypotINTEL, true, true, IR(685, 10), IR(42858, 25), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatSqrtINTEL, true, true, IR(677, 8), IR(42883, 24), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatLogINTEL, true, true, IR(677, 8), IR(42907, 23), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatLog2INTEL, true, true, IR(677, 8), IR(42930, 24), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatLog10INTEL, true, true, IR(677, 8), IR(42954, 25), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatLog1pINTEL, true, true, IR(677, 8), IR(42979, 25), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatExpINTEL, true, true, IR(677, 8), IR(43004, 23), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatExp2INTEL, true, true, IR(677, 8), IR(43027, 24), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatExp10INTEL, true, true, IR(677, 8), IR(43051, 25), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatExpm1INTEL, true, true, IR(677, 8), IR(43076, 25), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatSinINTEL, true, true, IR(677, 8), IR(43101, 23), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatCosINTEL, true, true, IR(677, 8), IR(43124, 23), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatSinCosINTEL, true, true, IR(677, 8), IR(43147, 26), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatSinPiINTEL, true, true, IR(677, 8), IR(43173, 25), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatCosPiINTEL, true, true, IR(677, 8), IR(43198, 25), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatASinINTEL, true, true, IR(677, 8), IR(43223, 24), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatASinPiINTEL, true, true, IR(677, 8), IR(43247, 26), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatACosINTEL, true, true, IR(677, 8), IR(43273, 24), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatACosPiINTEL, true, true, IR(677, 8), IR(43297, 26), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatATanINTEL, true, true, IR(677, 8), IR(43323, 24), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatATanPiINTEL, true, true, IR(677, 8), IR(43347, 26), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatATan2INTEL, true, true, IR(685, 10), IR(43373, 25), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatPowINTEL, true, true, IR(685, 10), IR(43398, 23), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatPowRINTEL, true, true, IR(685, 10), IR(43421, 24), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpArbitraryFloatPowNINTEL, true, true, IR(685, 10), IR(43445, 24), IR(0, 0), IR(286, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpLoopControlINTEL, false, false, IR(18, 1), IR(43469, 17), IR(0, 0), IR(287, 1), IR(106, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpAliasDomainDeclINTEL, true, false, IR(701, 2), IR(43486, 21), IR(0, 0), IR(136, 1), IR(113, 1), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpAliasScopeDeclINTEL, true, false, IR(703, 3), IR(43507, 20), IR(0, 0), IR(136, 1), IR(113, 1), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpAliasScopeListDeclINTEL, true, false, IR(92, 2), IR(43527, 24), IR(0, 0), IR(136, 1), IR(113, 1), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpFixedSqrtINTEL, true, true, IR(677, 8), IR(43551, 15), IR(0, 0), IR(188, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpFixedRecipINTEL, true, true, IR(677, 8), IR(43566, 16), IR(0, 0), IR(188, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpFixedRsqrtINTEL, true, true, IR(677, 8), IR(43582, 16), IR(0, 0), IR(188, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpFixedSinINTEL, true, true, IR(677, 8), IR(43598, 14), IR(0, 0), IR(188, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpFixedCosINTEL, true, true, IR(677, 8), IR(43612, 14), IR(0, 0), IR(188, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpFixedSinCosINTEL, true, true, IR(677, 8), IR(43626, 17), IR(0, 0), IR(188, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpFixedSinPiINTEL, true, true, IR(677, 8), IR(43643, 16), IR(0, 0), IR(188, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpFixedCosPiINTEL, true, true, IR(677, 8), IR(43659, 16), IR(0, 0), IR(188, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpFixedSinCosPiINTEL, true, true, IR(677, 8), IR(43675, 19), IR(0, 0), IR(188, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpFixedLogINTEL, true, true, IR(677, 8), IR(43694, 14), IR(0, 0), IR(188, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpFixedExpINTEL, true, true, IR(677, 8), IR(43708, 14), IR(0, 0), IR(188, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpPtrCastToCrossWorkgroupINTEL, true, true, IR(160, 3), IR(43722, 29), IR(0, 0), IR(199, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpCrossWorkgroupCastToPtrINTEL, true, true, IR(160, 3), IR(43751, 29), IR(0, 0), IR(199, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::k_exclude}, + {spv::Op::OpReadPipeBlockingINTEL, true, true, IR(172, 4), IR(43780, 22), IR(0, 0), IR(288, 1), IR(120, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpWritePipeBlockingINTEL, true, true, IR(172, 4), IR(43802, 23), IR(0, 0), IR(288, 1), IR(120, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kPipe}, + {spv::Op::OpFPGARegINTEL, true, true, IR(160, 3), IR(13037, 13), IR(0, 0), IR(289, 1), IR(121, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetRayTMinKHR, true, true, IR(160, 3), IR(43825, 22), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetRayFlagsKHR, true, true, IR(160, 3), IR(43847, 23), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionTKHR, true, true, IR(172, 4), IR(43870, 28), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR, true, true, IR(172, 4), IR(43898, 46), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionInstanceIdKHR, true, true, IR(172, 4), IR(43944, 37), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR, true, true, IR(172, 4), IR(43981, 65), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionGeometryIndexKHR, true, true, IR(172, 4), IR(44046, 40), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionPrimitiveIndexKHR, true, true, IR(172, 4), IR(44086, 41), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionBarycentricsKHR, true, true, IR(172, 4), IR(44127, 39), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionFrontFaceKHR, true, true, IR(172, 4), IR(44166, 36), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR, true, true, IR(160, 3), IR(44202, 46), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionObjectRayDirectionKHR, true, true, IR(172, 4), IR(44248, 45), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionObjectRayOriginKHR, true, true, IR(172, 4), IR(44293, 42), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetWorldRayDirectionKHR, true, true, IR(160, 3), IR(44335, 32), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetWorldRayOriginKHR, true, true, IR(160, 3), IR(44367, 29), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionObjectToWorldKHR, true, true, IR(172, 4), IR(44396, 40), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpRayQueryGetIntersectionWorldToObjectKHR, true, true, IR(172, 4), IR(44436, 40), IR(0, 0), IR(192, 1), IR(48, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpAtomicFAddEXT, true, true, IR(235, 6), IR(44476, 14), IR(0, 0), IR(290, 4), IR(129, 1), 0xffffffffu, 0xffffffffu, PrintingClass::kAtomic}, + {spv::Op::OpTypeBufferSurfaceINTEL, true, false, IR(100, 2), IR(44490, 23), IR(0, 0), IR(128, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpTypeStructContinuedINTEL, false, false, IR(706, 1), IR(44513, 25), IR(0, 0), IR(294, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpConstantCompositeContinuedINTEL, false, false, IR(706, 1), IR(44538, 32), IR(0, 0), IR(294, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpSpecConstantCompositeContinuedINTEL, false, false, IR(706, 1), IR(44570, 36), IR(0, 0), IR(294, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpCompositeConstructContinuedINTEL, true, true, IR(107, 3), IR(44606, 33), IR(0, 0), IR(294, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpConvertFToBF16INTEL, true, true, IR(160, 3), IR(44639, 20), IR(0, 0), IR(295, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpConvertBF16ToFINTEL, true, true, IR(160, 3), IR(44659, 20), IR(0, 0), IR(295, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpControlBarrierArriveINTEL, false, false, IR(221, 3), IR(44679, 26), IR(0, 0), IR(296, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kBarrier}, + {spv::Op::OpControlBarrierWaitINTEL, false, false, IR(221, 3), IR(44705, 24), IR(0, 0), IR(296, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kBarrier}, + {spv::Op::OpArithmeticFenceEXT, true, true, IR(160, 3), IR(13476, 19), IR(0, 0), IR(297, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMiscellaneous}, + {spv::Op::OpTaskSequenceCreateINTEL, true, true, IR(707, 7), IR(44729, 24), IR(0, 0), IR(298, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTaskSequenceAsyncINTEL, false, false, IR(168, 2), IR(44753, 23), IR(0, 0), IR(298, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTaskSequenceGetINTEL, true, true, IR(160, 3), IR(44776, 21), IR(0, 0), IR(298, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTaskSequenceReleaseINTEL, false, false, IR(10, 1), IR(44797, 25), IR(0, 0), IR(298, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kReserved}, + {spv::Op::OpTypeTaskSequenceINTEL, true, false, IR(68, 1), IR(44822, 22), IR(0, 0), IR(298, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kType_Declaration}, + {spv::Op::OpSubgroupBlockPrefetchINTEL, false, false, IR(139, 3), IR(44844, 27), IR(0, 0), IR(299, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroup2DBlockLoadINTEL, false, false, IR(714, 10), IR(44871, 25), IR(0, 0), IR(108, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroup2DBlockLoadTransformINTEL, false, false, IR(714, 10), IR(44896, 34), IR(0, 0), IR(300, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroup2DBlockLoadTransposeINTEL, false, false, IR(714, 10), IR(44930, 34), IR(0, 0), IR(301, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroup2DBlockPrefetchINTEL, false, false, IR(724, 9), IR(44964, 29), IR(0, 0), IR(108, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroup2DBlockStoreINTEL, false, false, IR(714, 10), IR(44993, 26), IR(0, 0), IR(108, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpSubgroupMatrixMultiplyAccumulateINTEL, true, true, IR(733, 7), IR(13814, 38), IR(0, 0), IR(302, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpBitwiseFunctionINTEL, true, true, IR(215, 6), IR(45081, 21), IR(0, 0), IR(303, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kBit}, + {spv::Op::OpUntypedVariableLengthArrayINTEL, true, true, IR(172, 4), IR(13880, 32), IR(0, 0), IR(304, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpConditionalExtensionINTEL, false, false, IR(45, 2), IR(45102, 26), IR(0, 0), IR(111, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kExtension}, + {spv::Op::OpConditionalEntryPointINTEL, false, false, IR(740, 5), IR(45128, 27), IR(0, 0), IR(111, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMode_Setting}, + {spv::Op::OpConditionalCapabilityINTEL, false, false, IR(745, 2), IR(45155, 27), IR(0, 0), IR(111, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMode_Setting}, + {spv::Op::OpSpecConstantTargetINTEL, true, true, IR(747, 4), IR(45182, 24), IR(0, 0), IR(305, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpSpecConstantArchitectureINTEL, true, true, IR(751, 6), IR(45206, 30), IR(0, 0), IR(305, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpSpecConstantCapabilitiesINTEL, true, true, IR(757, 3), IR(45273, 30), IR(0, 0), IR(305, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConstant_Creation}, + {spv::Op::OpConditionalCopyObjectINTEL, true, true, IR(107, 3), IR(45303, 27), IR(0, 0), IR(111, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kComposite}, + {spv::Op::OpGroupIMulKHR, true, true, IR(283, 5), IR(45330, 13), IR(0, 0), IR(306, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupFMulKHR, true, true, IR(283, 5), IR(45343, 13), IR(0, 0), IR(306, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupBitwiseAndKHR, true, true, IR(283, 5), IR(45356, 19), IR(0, 0), IR(306, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupBitwiseOrKHR, true, true, IR(283, 5), IR(45375, 18), IR(0, 0), IR(306, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupBitwiseXorKHR, true, true, IR(283, 5), IR(45393, 19), IR(0, 0), IR(306, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupLogicalAndKHR, true, true, IR(283, 5), IR(45412, 19), IR(0, 0), IR(306, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupLogicalOrKHR, true, true, IR(283, 5), IR(45431, 18), IR(0, 0), IR(306, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpGroupLogicalXorKHR, true, true, IR(283, 5), IR(45449, 19), IR(0, 0), IR(306, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kGroup}, + {spv::Op::OpRoundFToTF32INTEL, true, true, IR(160, 3), IR(45468, 18), IR(0, 0), IR(307, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kConversion}, + {spv::Op::OpMaskedGatherINTEL, true, true, IR(760, 6), IR(45486, 18), IR(0, 0), IR(308, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpMaskedScatterINTEL, false, false, IR(766, 4), IR(45504, 19), IR(0, 0), IR(308, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kMemory}, + {spv::Op::OpConvertHandleToImageINTEL, true, true, IR(160, 3), IR(45523, 26), IR(0, 0), IR(309, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpConvertHandleToSamplerINTEL, true, true, IR(160, 3), IR(45549, 28), IR(0, 0), IR(309, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, + {spv::Op::OpConvertHandleToSampledImageINTEL, true, true, IR(160, 3), IR(45577, 33), IR(0, 0), IR(309, 1), IR(0, 0), 0xffffffffu, 0xffffffffu, PrintingClass::kImage}, }}; // Opcode strings (without the 'Op' prefix) and opcode values, ordered by name. // The fields in order are: // name, either the primary name or an alias, indexing into kStrings // index into kInstructionDesc -static const std::array kInstructionNames{{ - {IR(36385, 13), 541}, // 0 AbsISubINTEL - {IR(36398, 13), 542}, // 1 AbsUSubINTEL - {IR(26453, 12), 58}, // 2 AccessChain - {IR(42998, 21), 727}, // 3 AliasDomainDeclINTEL - {IR(43019, 20), 728}, // 4 AliasScopeDeclINTEL - {IR(43039, 24), 729}, // 5 AliasScopeListDeclINTEL - {IR(27750, 4), 143}, // 6 All - {IR(32909, 25), 413}, // 7 AllocateNodePayloadsAMDX - {IR(27746, 4), 142}, // 8 Any - {IR(42785, 24), 718}, // 9 ArbitraryFloatACosINTEL - {IR(42809, 26), 719}, // 10 ArbitraryFloatACosPiINTEL - {IR(42735, 24), 716}, // 11 ArbitraryFloatASinINTEL - {IR(42759, 26), 717}, // 12 ArbitraryFloatASinPiINTEL - {IR(42885, 25), 722}, // 13 ArbitraryFloatATan2INTEL - {IR(42835, 24), 720}, // 14 ArbitraryFloatATanINTEL - {IR(42859, 26), 721}, // 15 ArbitraryFloatATanPiINTEL - {IR(42094, 23), 689}, // 16 ArbitraryFloatAddINTEL - {IR(42034, 31), 687}, // 17 ArbitraryFloatCastFromIntINTEL - {IR(42010, 24), 686}, // 18 ArbitraryFloatCastINTEL - {IR(42065, 29), 688}, // 19 ArbitraryFloatCastToIntINTEL - {IR(42346, 24), 700}, // 20 ArbitraryFloatCbrtINTEL - {IR(42636, 23), 712}, // 21 ArbitraryFloatCosINTEL - {IR(42710, 25), 715}, // 22 ArbitraryFloatCosPiINTEL - {IR(42163, 23), 692}, // 23 ArbitraryFloatDivINTEL - {IR(42274, 22), 697}, // 24 ArbitraryFloatEQINTEL - {IR(42563, 25), 709}, // 25 ArbitraryFloatExp10INTEL - {IR(42539, 24), 708}, // 26 ArbitraryFloatExp2INTEL - {IR(42516, 23), 707}, // 27 ArbitraryFloatExpINTEL - {IR(42588, 25), 710}, // 28 ArbitraryFloatExpm1INTEL - {IR(42208, 22), 694}, // 29 ArbitraryFloatGEINTEL - {IR(42186, 22), 693}, // 30 ArbitraryFloatGTINTEL - {IR(42370, 25), 701}, // 31 ArbitraryFloatHypotINTEL - {IR(42252, 22), 696}, // 32 ArbitraryFloatLEINTEL - {IR(42230, 22), 695}, // 33 ArbitraryFloatLTINTEL - {IR(42466, 25), 705}, // 34 ArbitraryFloatLog10INTEL - {IR(42491, 25), 706}, // 35 ArbitraryFloatLog1pINTEL - {IR(42442, 24), 704}, // 36 ArbitraryFloatLog2INTEL - {IR(42419, 23), 703}, // 37 ArbitraryFloatLogINTEL - {IR(42140, 23), 691}, // 38 ArbitraryFloatMulINTEL - {IR(42910, 23), 723}, // 39 ArbitraryFloatPowINTEL - {IR(42957, 24), 725}, // 40 ArbitraryFloatPowNINTEL - {IR(42933, 24), 724}, // 41 ArbitraryFloatPowRINTEL - {IR(42321, 25), 699}, // 42 ArbitraryFloatRSqrtINTEL - {IR(42296, 25), 698}, // 43 ArbitraryFloatRecipINTEL - {IR(42659, 26), 713}, // 44 ArbitraryFloatSinCosINTEL - {IR(41982, 28), 685}, // 45 ArbitraryFloatSinCosPiINTEL - {IR(42613, 23), 711}, // 46 ArbitraryFloatSinINTEL - {IR(42685, 25), 714}, // 47 ArbitraryFloatSinPiINTEL - {IR(42395, 24), 702}, // 48 ArbitraryFloatSqrtINTEL - {IR(42117, 23), 690}, // 49 ArbitraryFloatSubINTEL - {IR(13335, 19), 773}, // 50 ArithmeticFenceEXT - {IR(26500, 12), 61}, // 51 ArrayLength - {IR(36632, 13), 557}, // 52 AsmCallINTEL - {IR(12106, 9), 556}, // 53 AsmINTEL - {IR(36617, 15), 555}, // 54 AsmTargetINTEL - {IR(36673, 14), 560}, // 55 AssumeTrueKHR - {IR(28772, 10), 220}, // 56 AtomicAnd - {IR(28624, 22), 210}, // 57 AtomicCompareExchange - {IR(28646, 26), 211}, // 58 AtomicCompareExchangeWeak - {IR(28609, 15), 209}, // 59 AtomicExchange - {IR(43988, 14), 763}, // 60 AtomicFAddEXT - {IR(36659, 14), 559}, // 61 AtomicFMaxEXT - {IR(36645, 14), 558}, // 62 AtomicFMinEXT - {IR(30157, 16), 292}, // 63 AtomicFlagClear - {IR(30136, 21), 291}, // 64 AtomicFlagTestAndSet - {IR(28706, 11), 214}, // 65 AtomicIAdd - {IR(28689, 17), 213}, // 66 AtomicIDecrement - {IR(28672, 17), 212}, // 67 AtomicIIncrement - {IR(28717, 11), 215}, // 68 AtomicISub - {IR(28586, 11), 207}, // 69 AtomicLoad - {IR(28782, 9), 221}, // 70 AtomicOr - {IR(28750, 11), 218}, // 71 AtomicSMax - {IR(28728, 11), 216}, // 72 AtomicSMin - {IR(28597, 12), 208}, // 73 AtomicStore - {IR(28761, 11), 219}, // 74 AtomicUMax - {IR(28739, 11), 217}, // 75 AtomicUMin - {IR(28791, 10), 222}, // 76 AtomicXor - {IR(34881, 28), 487}, // 77 BeginInvocationInterlockEXT - {IR(28370, 9), 191}, // 78 BitCount - {IR(28310, 15), 187}, // 79 BitFieldInsert - {IR(28325, 17), 188}, // 80 BitFieldSExtract - {IR(28342, 17), 189}, // 81 BitFieldUExtract - {IR(28359, 11), 190}, // 82 BitReverse - {IR(27498, 8), 114}, // 83 Bitcast - {IR(28295, 11), 185}, // 84 BitwiseAnd - {IR(44593, 21), 786}, // 85 BitwiseFunctionINTEL - {IR(28274, 10), 183}, // 86 BitwiseOr - {IR(28284, 11), 184}, // 87 BitwiseXor - {IR(28901, 7), 227}, // 88 Branch - {IR(28908, 18), 228}, // 89 BranchConditional - {IR(29769, 13), 277}, // 90 BuildNDRange - {IR(25514, 11), 15}, // 91 Capability - {IR(29727, 26), 275}, // 92 CaptureEventProfilingInfo - {IR(31233, 23), 344}, // 93 ColorAttachmentReadEXT - {IR(29319, 15), 255}, // 94 CommitReadPipe - {IR(29334, 16), 256}, // 95 CommitWritePipe - {IR(26760, 19), 72}, // 96 CompositeConstruct - {IR(44118, 33), 768}, // 97 CompositeConstructContinuedINTEL - {IR(32266, 31), 386}, // 98 CompositeConstructReplicateEXT - {IR(26779, 17), 73}, // 99 CompositeExtract - {IR(26796, 16), 74}, // 100 CompositeInsert - {IR(15254, 9), 39}, // 101 Constant - {IR(26020, 18), 40}, // 102 ConstantComposite - {IR(44050, 32), 766}, // 103 ConstantCompositeContinuedINTEL - {IR(32202, 30), 384}, // 104 ConstantCompositeReplicateEXT - {IR(25968, 14), 38}, // 105 ConstantFalse - {IR(36563, 29), 553}, // 106 ConstantFunctionPointerINTEL - {IR(26132, 13), 42}, // 107 ConstantNull - {IR(30212, 20), 296}, // 108 ConstantPipeStorage - {IR(26116, 16), 41}, // 109 ConstantSampler - {IR(33062, 19), 419}, // 110 ConstantStringAMDX - {IR(25955, 13), 37}, // 111 ConstantTrue - {IR(28557, 15), 205}, // 112 ControlBarrier - {IR(44191, 26), 771}, // 113 ControlBarrierArriveINTEL - {IR(44217, 24), 772}, // 114 ControlBarrierWaitINTEL - {IR(44171, 20), 770}, // 115 ConvertBF16ToFINTEL - {IR(44151, 20), 769}, // 116 ConvertFToBF16INTEL - {IR(27304, 12), 100}, // 117 ConvertFToS - {IR(27292, 12), 99}, // 118 ConvertFToU - {IR(44807, 26), 798}, // 119 ConvertHandleToImageINTEL - {IR(44861, 33), 800}, // 120 ConvertHandleToSampledImageINTEL - {IR(44833, 28), 799}, // 121 ConvertHandleToSamplerINTEL - {IR(35530, 18), 510}, // 122 ConvertImageToUNV - {IR(27381, 14), 107}, // 123 ConvertPtrToU - {IR(27316, 12), 101}, // 124 ConvertSToF - {IR(35593, 25), 513}, // 125 ConvertSampledImageToUNV - {IR(35548, 20), 511}, // 126 ConvertSamplerToUNV - {IR(31780, 35), 370}, // 127 ConvertUToAccelerationStructureKHR - {IR(27328, 12), 102}, // 128 ConvertUToF - {IR(35492, 18), 508}, // 129 ConvertUToImageNV - {IR(27425, 14), 110}, // 130 ConvertUToPtr - {IR(35568, 25), 512}, // 131 ConvertUToSampledImageNV - {IR(35510, 20), 509}, // 132 ConvertUToSamplerNV - {IR(34222, 27), 462}, // 133 CooperativeMatrixConvertNV - {IR(32175, 27), 383}, // 134 CooperativeMatrixLengthKHR - {IR(34855, 26), 486}, // 135 CooperativeMatrixLengthNV - {IR(32043, 25), 380}, // 136 CooperativeMatrixLoadKHR - {IR(34780, 24), 483}, // 137 CooperativeMatrixLoadNV - {IR(35079, 30), 490}, // 138 CooperativeMatrixLoadTensorNV - {IR(32148, 27), 382}, // 139 CooperativeMatrixMulAddKHR - {IR(34829, 26), 485}, // 140 CooperativeMatrixMulAddNV - {IR(35140, 32), 492}, // 141 CooperativeMatrixPerElementOpNV - {IR(34978, 26), 489}, // 142 CooperativeMatrixReduceNV - {IR(32068, 26), 381}, // 143 CooperativeMatrixStoreKHR - {IR(34804, 25), 484}, // 144 CooperativeMatrixStoreNV - {IR(35109, 31), 491}, // 145 CooperativeMatrixStoreTensorNV - {IR(35463, 29), 507}, // 146 CooperativeMatrixTransposeNV - {IR(34417, 24), 469}, // 147 CooperativeVectorLoadNV - {IR(34190, 32), 461}, // 148 CooperativeVectorMatrixMulAddNV - {IR(34080, 29), 458}, // 149 CooperativeVectorMatrixMulNV - {IR(34109, 42), 459}, // 150 CooperativeVectorOuterProductAccumulateNV - {IR(34151, 39), 460}, // 151 CooperativeVectorReduceSumAccumulateNV - {IR(34441, 25), 470}, // 152 CooperativeVectorStoreNV - {IR(31192, 12), 340}, // 153 CopyLogical - {IR(26426, 11), 56}, // 154 CopyMemory - {IR(26437, 16), 57}, // 155 CopyMemorySized - {IR(26812, 11), 75}, // 156 CopyObject - {IR(30232, 26), 297}, // 157 CreatePipeFromPipeStorage - {IR(35208, 21), 495}, // 158 CreateTensorLayoutNV - {IR(35328, 19), 500}, // 159 CreateTensorViewNV - {IR(29679, 16), 272}, // 160 CreateUserEvent - {IR(43263, 29), 742}, // 161 CrossWorkgroupCastToPtrINTEL - {IR(28379, 5), 192}, // 162 DPdx - {IR(28425, 11), 198}, // 163 DPdxCoarse - {IR(28396, 9), 195}, // 164 DPdxFine - {IR(28384, 5), 193}, // 165 DPdy - {IR(28436, 11), 199}, // 166 DPdyCoarse - {IR(28405, 9), 196}, // 167 DPdyFine - {IR(26586, 9), 64}, // 168 Decorate - {IR(30409, 11), 305}, // 169 DecorateId - {IR(36697, 15), 562}, // 170 DecorateString - {IR(36712, 21), 562}, // 171 DecorateStringGOOGLE - {IR(26610, 16), 66}, // 172 DecorationGroup - {IR(11440, 25), 503}, // 173 DemoteToHelperInvocation - {IR(11465, 28), 503}, // 174 DemoteToHelperInvocationEXT - {IR(31256, 23), 345}, // 175 DepthAttachmentReadEXT - {IR(27695, 4), 137}, // 176 Dot - {IR(34249, 17), 463}, // 177 EmitMeshTasksEXT - {IR(28484, 17), 203}, // 178 EmitStreamVertex - {IR(28460, 11), 201}, // 179 EmitVertex - {IR(34909, 26), 488}, // 180 EndInvocationInterlockEXT - {IR(28471, 13), 202}, // 181 EndPrimitive - {IR(28501, 19), 204}, // 182 EndStreamPrimitive - {IR(29515, 14), 265}, // 183 EnqueueKernel - {IR(29501, 14), 264}, // 184 EnqueueMarker - {IR(32934, 24), 414}, // 185 EnqueueNodePayloadsAMDX - {IR(25429, 11), 13}, // 186 EntryPoint - {IR(31761, 19), 369}, // 187 ExecuteCallableKHR - {IR(34691, 18), 479}, // 188 ExecuteCallableNV - {IR(25472, 14), 14}, // 189 ExecutionMode - {IR(30393, 16), 304}, // 190 ExecutionModeId - {IR(36687, 10), 561}, // 191 ExpectKHR - {IR(25283, 8), 11}, // 192 ExtInst - {IR(25223, 14), 10}, // 193 ExtInstImport - {IR(31723, 26), 367}, // 194 ExtInstWithForwardRefsKHR - {IR(25213, 10), 9}, // 195 Extension - {IR(27527, 5), 118}, // 196 FAdd - {IR(27358, 9), 105}, // 197 FConvert - {IR(27562, 5), 125}, // 198 FDiv - {IR(27587, 5), 130}, // 199 FMod - {IR(27547, 5), 122}, // 200 FMul - {IR(27514, 8), 116}, // 201 FNegate - {IR(28024, 10), 168}, // 202 FOrdEqual - {IR(28102, 16), 174}, // 203 FOrdGreaterThan - {IR(28174, 21), 178}, // 204 FOrdGreaterThanEqual - {IR(28074, 13), 172}, // 205 FOrdLessThan - {IR(28136, 18), 176}, // 206 FOrdLessThanEqual - {IR(28046, 13), 170}, // 207 FOrdNotEqual - {IR(12903, 13), 745}, // 208 FPGARegINTEL - {IR(27582, 5), 129}, // 209 FRem - {IR(27537, 5), 120}, // 210 FSub - {IR(28034, 12), 169}, // 211 FUnordEqual - {IR(28118, 18), 175}, // 212 FUnordGreaterThan - {IR(28195, 23), 179}, // 213 FUnordGreaterThanEqual - {IR(28087, 15), 173}, // 214 FUnordLessThan - {IR(28154, 20), 177}, // 215 FUnordLessThanEqual - {IR(28059, 15), 171}, // 216 FUnordNotEqual - {IR(34379, 38), 468}, // 217 FetchMicroTriangleVertexBarycentricNV - {IR(34344, 35), 467}, // 218 FetchMicroTriangleVertexPositionNV - {IR(32983, 29), 416}, // 219 FinishWritingNodePayloadAMDX - {IR(43124, 14), 734}, // 220 FixedCosINTEL - {IR(43171, 16), 737}, // 221 FixedCosPiINTEL - {IR(43220, 14), 740}, // 222 FixedExpINTEL - {IR(43206, 14), 739}, // 223 FixedLogINTEL - {IR(43078, 16), 731}, // 224 FixedRecipINTEL - {IR(43094, 16), 732}, // 225 FixedRsqrtINTEL - {IR(43138, 17), 735}, // 226 FixedSinCosINTEL - {IR(43187, 19), 738}, // 227 FixedSinCosPiINTEL - {IR(43110, 14), 733}, // 228 FixedSinINTEL - {IR(43155, 16), 736}, // 229 FixedSinPiINTEL - {IR(43063, 15), 730}, // 230 FixedSqrtINTEL - {IR(32879, 17), 411}, // 231 FragmentFetchAMD - {IR(32858, 21), 410}, // 232 FragmentMaskFetchAMD - {IR(24333, 9), 48}, // 233 Function - {IR(26335, 13), 51}, // 234 FunctionCall - {IR(26323, 12), 50}, // 235 FunctionEnd - {IR(26305, 18), 49}, // 236 FunctionParameter - {IR(36592, 25), 554}, // 237 FunctionPointerCallINTEL - {IR(28389, 7), 194}, // 238 Fwidth - {IR(28447, 13), 200}, // 239 FwidthCoarse - {IR(28414, 11), 197}, // 240 FwidthFine - {IR(27456, 17), 112}, // 241 GenericCastToPtr - {IR(27473, 25), 113}, // 242 GenericCastToPtrExplicit - {IR(26512, 23), 62}, // 243 GenericPtrMemSemantics - {IR(29753, 16), 276}, // 244 GetDefaultQueue - {IR(30258, 35), 298}, // 245 GetKernelLocalSizeForSubgroupCount - {IR(30293, 25), 299}, // 246 GetKernelMaxNumSubgroups - {IR(29559, 32), 267}, // 247 GetKernelNDrangeMaxSubGroupSize - {IR(29529, 30), 266}, // 248 GetKernelNDrangeSubGroupCount - {IR(29614, 40), 269}, // 249 GetKernelPreferredWorkGroupSizeMultiple - {IR(29591, 23), 268}, // 250 GetKernelWorkGroupSize - {IR(29385, 18), 259}, // 251 GetMaxPipePackets - {IR(29367, 18), 258}, // 252 GetNumPipePackets - {IR(29072, 9), 238}, // 253 GroupAll - {IR(29081, 9), 239}, // 254 GroupAny - {IR(29041, 15), 236}, // 255 GroupAsyncCopy - {IR(44640, 19), 789}, // 256 GroupBitwiseAndKHR - {IR(44659, 18), 790}, // 257 GroupBitwiseOrKHR - {IR(44677, 19), 791}, // 258 GroupBitwiseXorKHR - {IR(29090, 15), 240}, // 259 GroupBroadcast - {IR(29460, 20), 262}, // 260 GroupCommitReadPipe - {IR(29480, 21), 263}, // 261 GroupCommitWritePipe - {IR(26626, 14), 67}, // 262 GroupDecorate - {IR(29148, 10), 242}, // 263 GroupFAdd - {IR(32697, 23), 403}, // 264 GroupFAddNonUniformAMD - {IR(29188, 10), 246}, // 265 GroupFMax - {IR(32789, 23), 407}, // 266 GroupFMaxNonUniformAMD - {IR(29158, 10), 243}, // 267 GroupFMin - {IR(32720, 23), 404}, // 268 GroupFMinNonUniformAMD - {IR(44627, 13), 788}, // 269 GroupFMulKHR - {IR(29138, 10), 241}, // 270 GroupIAdd - {IR(32674, 23), 402}, // 271 GroupIAddNonUniformAMD - {IR(44614, 13), 787}, // 272 GroupIMulKHR - {IR(44696, 19), 792}, // 273 GroupLogicalAndKHR - {IR(44715, 18), 793}, // 274 GroupLogicalOrKHR - {IR(44733, 19), 794}, // 275 GroupLogicalXorKHR - {IR(26685, 20), 68}, // 276 GroupMemberDecorate - {IR(30441, 19), 307}, // 277 GroupNonUniformAll - {IR(30479, 24), 309}, // 278 GroupNonUniformAllEqual - {IR(30460, 19), 308}, // 279 GroupNonUniformAny - {IR(5569, 22), 312}, // 280 GroupNonUniformBallot - {IR(30619, 30), 315}, // 281 GroupNonUniformBallotBitCount - {IR(30587, 32), 314}, // 282 GroupNonUniformBallotBitExtract - {IR(30649, 29), 316}, // 283 GroupNonUniformBallotFindLSB - {IR(30678, 29), 317}, // 284 GroupNonUniformBallotFindMSB - {IR(30985, 26), 332}, // 285 GroupNonUniformBitwiseAnd - {IR(31011, 25), 333}, // 286 GroupNonUniformBitwiseOr - {IR(31036, 26), 334}, // 287 GroupNonUniformBitwiseXor - {IR(30503, 25), 310}, // 288 GroupNonUniformBroadcast - {IR(30528, 30), 311}, // 289 GroupNonUniformBroadcastFirst - {IR(30420, 21), 306}, // 290 GroupNonUniformElect - {IR(30805, 20), 323}, // 291 GroupNonUniformFAdd - {IR(30965, 20), 331}, // 292 GroupNonUniformFMax - {IR(30905, 20), 328}, // 293 GroupNonUniformFMin - {IR(30845, 20), 325}, // 294 GroupNonUniformFMul - {IR(30785, 20), 322}, // 295 GroupNonUniformIAdd - {IR(30825, 20), 324}, // 296 GroupNonUniformIMul - {IR(30558, 29), 313}, // 297 GroupNonUniformInverseBallot - {IR(31062, 26), 335}, // 298 GroupNonUniformLogicalAnd - {IR(31088, 25), 336}, // 299 GroupNonUniformLogicalOr - {IR(31113, 26), 337}, // 300 GroupNonUniformLogicalXor - {IR(34284, 27), 465}, // 301 GroupNonUniformPartitionNV - {IR(33104, 26), 421}, // 302 GroupNonUniformQuadAllKHR - {IR(33130, 26), 422}, // 303 GroupNonUniformQuadAnyKHR - {IR(31139, 29), 338}, // 304 GroupNonUniformQuadBroadcast - {IR(31168, 24), 339}, // 305 GroupNonUniformQuadSwap - {IR(13128, 25), 365}, // 306 GroupNonUniformRotateKHR - {IR(30925, 20), 329}, // 307 GroupNonUniformSMax - {IR(30865, 20), 326}, // 308 GroupNonUniformSMin - {IR(8659, 23), 318}, // 309 GroupNonUniformShuffle - {IR(30758, 27), 321}, // 310 GroupNonUniformShuffleDown - {IR(30733, 25), 320}, // 311 GroupNonUniformShuffleUp - {IR(30707, 26), 319}, // 312 GroupNonUniformShuffleXor - {IR(30945, 20), 330}, // 313 GroupNonUniformUMax - {IR(30885, 20), 327}, // 314 GroupNonUniformUMin - {IR(29403, 28), 260}, // 315 GroupReserveReadPipePackets - {IR(29431, 29), 261}, // 316 GroupReserveWritePipePackets - {IR(29208, 10), 248}, // 317 GroupSMax - {IR(32835, 23), 409}, // 318 GroupSMaxNonUniformAMD - {IR(29178, 10), 245}, // 319 GroupSMin - {IR(32766, 23), 406}, // 320 GroupSMinNonUniformAMD - {IR(29198, 10), 247}, // 321 GroupUMax - {IR(32812, 23), 408}, // 322 GroupUMaxNonUniformAMD - {IR(29168, 10), 244}, // 323 GroupUMin - {IR(32743, 23), 405}, // 324 GroupUMinNonUniformAMD - {IR(29056, 16), 237}, // 325 GroupWaitEvents - {IR(33591, 25), 438}, // 326 HitObjectExecuteShaderNV - {IR(33642, 25), 440}, // 327 HitObjectGetAttributesNV - {IR(34732, 24), 481}, // 328 HitObjectGetClusterIdNV - {IR(33616, 26), 439}, // 329 HitObjectGetCurrentTimeNV - {IR(33718, 28), 443}, // 330 HitObjectGetGeometryIndexNV - {IR(33667, 22), 441}, // 331 HitObjectGetHitKindNV - {IR(33771, 34), 445}, // 332 HitObjectGetInstanceCustomIndexNV - {IR(33746, 25), 444}, // 333 HitObjectGetInstanceIdNV - {IR(35959, 27), 523}, // 334 HitObjectGetLSSPositionsNV - {IR(35986, 23), 524}, // 335 HitObjectGetLSSRadiiNV - {IR(33303, 33), 428}, // 336 HitObjectGetObjectRayDirectionNV - {IR(33336, 30), 429}, // 337 HitObjectGetObjectRayOriginNV - {IR(33275, 28), 427}, // 338 HitObjectGetObjectToWorldNV - {IR(33689, 29), 442}, // 339 HitObjectGetPrimitiveIndexNV - {IR(33866, 22), 448}, // 340 HitObjectGetRayTMaxNV - {IR(33888, 22), 449}, // 341 HitObjectGetRayTMinNV - {IR(33431, 44), 432}, // 342 HitObjectGetShaderBindingTableRecordIndexNV - {IR(33392, 39), 431}, // 343 HitObjectGetShaderRecordBufferHandleNV - {IR(35903, 29), 521}, // 344 HitObjectGetSpherePositionNV - {IR(35932, 27), 522}, // 345 HitObjectGetSphereRadiusNV - {IR(33805, 32), 446}, // 346 HitObjectGetWorldRayDirectionNV - {IR(33837, 29), 447}, // 347 HitObjectGetWorldRayOriginNV - {IR(33247, 28), 426}, // 348 HitObjectGetWorldToObjectNV - {IR(33910, 19), 450}, // 349 HitObjectIsEmptyNV - {IR(33929, 17), 451}, // 350 HitObjectIsHitNV - {IR(36032, 20), 526}, // 351 HitObjectIsLSSHitNV - {IR(33946, 18), 452}, // 352 HitObjectIsMissNV - {IR(36009, 23), 525}, // 353 HitObjectIsSphereHitNV - {IR(33475, 23), 433}, // 354 HitObjectRecordEmptyNV - {IR(33156, 27), 423}, // 355 HitObjectRecordHitMotionNV - {IR(33518, 21), 435}, // 356 HitObjectRecordHitNV - {IR(33183, 36), 424}, // 357 HitObjectRecordHitWithIndexMotionNV - {IR(33539, 30), 436}, // 358 HitObjectRecordHitWithIndexNV - {IR(33219, 28), 425}, // 359 HitObjectRecordMissMotionNV - {IR(33569, 22), 437}, // 360 HitObjectRecordMissNV - {IR(33366, 26), 430}, // 361 HitObjectTraceRayMotionNV - {IR(33498, 20), 434}, // 362 HitObjectTraceRayNV - {IR(27522, 5), 117}, // 363 IAdd - {IR(27699, 10), 138}, // 364 IAddCarry - {IR(36411, 13), 543}, // 365 IAddSatINTEL - {IR(36437, 14), 545}, // 366 IAverageINTEL - {IR(36465, 21), 547}, // 367 IAverageRoundedINTEL - {IR(27895, 7), 158}, // 368 IEqual - {IR(27542, 5), 121}, // 369 IMul - {IR(36533, 15), 551}, // 370 IMul32x16INTEL - {IR(27902, 10), 159}, // 371 INotEqual - {IR(27532, 5), 119}, // 372 ISub - {IR(27709, 11), 139}, // 373 ISubBorrow - {IR(36507, 13), 549}, // 374 ISubSatINTEL - {IR(31815, 22), 371}, // 375 IgnoreIntersectionKHR - {IR(34509, 21), 472}, // 376 IgnoreIntersectionNV - {IR(24377, 6), 91}, // 377 Image - {IR(32645, 29), 401}, // 378 ImageBlockMatchGatherSADQCOM - {IR(32616, 29), 400}, // 379 ImageBlockMatchGatherSSDQCOM - {IR(32535, 23), 397}, // 380 ImageBlockMatchSADQCOM - {IR(32512, 23), 396}, // 381 ImageBlockMatchSSDQCOM - {IR(32587, 29), 399}, // 382 ImageBlockMatchWindowSADQCOM - {IR(32558, 29), 398}, // 383 ImageBlockMatchWindowSSDQCOM - {IR(32493, 19), 395}, // 384 ImageBoxFilterQCOM - {IR(27140, 16), 88}, // 385 ImageDrefGather - {IR(27117, 11), 86}, // 386 ImageFetch - {IR(27128, 12), 87}, // 387 ImageGather - {IR(27177, 17), 92}, // 388 ImageQueryFormat - {IR(27257, 17), 97}, // 389 ImageQueryLevels - {IR(27243, 14), 96}, // 390 ImageQueryLod - {IR(27194, 16), 93}, // 391 ImageQueryOrder - {IR(27274, 18), 98}, // 392 ImageQuerySamples - {IR(27228, 15), 95}, // 393 ImageQuerySize - {IR(27210, 18), 94}, // 394 ImageQuerySizeLod - {IR(27156, 10), 89}, // 395 ImageRead - {IR(26974, 27), 81}, // 396 ImageSampleDrefExplicitLod - {IR(26947, 27), 80}, // 397 ImageSampleDrefImplicitLod - {IR(26924, 23), 79}, // 398 ImageSampleExplicitLod - {IR(34033, 23), 456}, // 399 ImageSampleFootprintNV - {IR(26878, 23), 78}, // 400 ImageSampleImplicitLod - {IR(27086, 31), 85}, // 401 ImageSampleProjDrefExplicitLod - {IR(27055, 31), 84}, // 402 ImageSampleProjDrefImplicitLod - {IR(27028, 27), 83}, // 403 ImageSampleProjExplicitLod - {IR(27001, 27), 82}, // 404 ImageSampleProjImplicitLod - {IR(32469, 24), 394}, // 405 ImageSampleWeightedQCOM - {IR(30081, 22), 288}, // 406 ImageSparseDrefGather - {IR(30046, 17), 286}, // 407 ImageSparseFetch - {IR(30063, 18), 287}, // 408 ImageSparseGather - {IR(30173, 16), 293}, // 409 ImageSparseRead - {IR(29873, 33), 281}, // 410 ImageSparseSampleDrefExplicitLod - {IR(29840, 33), 280}, // 411 ImageSparseSampleDrefImplicitLod - {IR(29811, 29), 279}, // 412 ImageSparseSampleExplicitLod - {IR(29782, 29), 278}, // 413 ImageSparseSampleImplicitLod - {IR(30009, 37), 285}, // 414 ImageSparseSampleProjDrefExplicitLod - {IR(29972, 37), 284}, // 415 ImageSparseSampleProjDrefImplicitLod - {IR(29939, 33), 283}, // 416 ImageSparseSampleProjExplicitLod - {IR(29906, 33), 282}, // 417 ImageSparseSampleProjImplicitLod - {IR(30103, 26), 289}, // 418 ImageSparseTexelsResident - {IR(26357, 18), 53}, // 419 ImageTexelPointer - {IR(27166, 11), 90}, // 420 ImageWrite - {IR(26465, 20), 59}, // 421 InBoundsAccessChain - {IR(26535, 23), 63}, // 422 InBoundsPtrAccessChain - {IR(27766, 9), 146}, // 423 IsFinite - {IR(35394, 22), 504}, // 424 IsHelperInvocationEXT - {IR(27760, 6), 145}, // 425 IsInf - {IR(27754, 6), 144}, // 426 IsNan - {IR(33039, 23), 418}, // 427 IsNodePayloadValidAMDX - {IR(27775, 9), 147}, // 428 IsNormal - {IR(29695, 13), 273}, // 429 IsValidEvent - {IR(29350, 17), 257}, // 430 IsValidReserveId - {IR(28978, 5), 230}, // 431 Kill - {IR(28895, 6), 226}, // 432 Label - {IR(27795, 14), 149}, // 433 LessOrGreater - {IR(29014, 14), 234}, // 434 LifetimeStart - {IR(29028, 13), 235}, // 435 LifetimeStop - {IR(25208, 5), 8}, // 436 Line - {IR(26415, 5), 54}, // 437 Load - {IR(27866, 11), 155}, // 438 LogicalAnd - {IR(27827, 13), 152}, // 439 LogicalEqual - {IR(27877, 11), 156}, // 440 LogicalNot - {IR(27840, 16), 153}, // 441 LogicalNotEqual - {IR(27856, 10), 154}, // 442 LogicalOr - {IR(42981, 17), 726}, // 443 LoopControlINTEL - {IR(28835, 10), 224}, // 444 LoopMerge - {IR(44770, 18), 796}, // 445 MaskedGatherINTEL - {IR(44788, 19), 797}, // 446 MaskedScatterINTEL - {IR(27664, 18), 135}, // 447 MatrixTimesMatrix - {IR(27610, 18), 132}, // 448 MatrixTimesScalar - {IR(27646, 18), 134}, // 449 MatrixTimesVector - {IR(26595, 15), 65}, // 450 MemberDecorate - {IR(36733, 21), 563}, // 451 MemberDecorateString - {IR(36754, 27), 563}, // 452 MemberDecorateStringGOOGLE - {IR(25190, 11), 6}, // 453 MemberName - {IR(28572, 14), 206}, // 454 MemoryBarrier - {IR(25355, 12), 12}, // 455 MemoryModel - {IR(30358, 19), 302}, // 456 MemoryNamedBarrier - {IR(30377, 16), 303}, // 457 ModuleProcessed - {IR(25185, 5), 5}, // 458 Name - {IR(30335, 23), 301}, // 459 NamedBarrierInitialize - {IR(30129, 7), 290}, // 460 NoLine - {IR(33012, 27), 417}, // 461 NodePayloadArrayLengthAMDX - {IR(24981, 4), 0}, // 462 Nop - {IR(28306, 4), 186}, // 463 Not - {IR(27809, 8), 150}, // 464 Ordered - {IR(27682, 13), 136}, // 465 OuterProduct - {IR(28801, 4), 223}, // 466 Phi - {IR(26485, 15), 60}, // 467 PtrAccessChain - {IR(43234, 29), 741}, // 468 PtrCastToCrossWorkgroupINTEL - {IR(27439, 17), 111}, // 469 PtrCastToGeneric - {IR(31225, 8), 343}, // 470 PtrDiff - {IR(31204, 9), 341}, // 471 PtrEqual - {IR(31213, 12), 342}, // 472 PtrNotEqual - {IR(27367, 14), 106}, // 473 QuantizeToF16 - {IR(35699, 17), 515}, // 474 RawAccessChainNV - {IR(32388, 31), 391}, // 475 RayQueryConfirmIntersectionKHR - {IR(32356, 32), 390}, // 476 RayQueryGenerateIntersectionKHR - {IR(34709, 23), 480}, // 477 RayQueryGetClusterIdNV - {IR(43639, 39), 754}, // 478 RayQueryGetIntersectionBarycentricsKHR - {IR(43714, 46), 756}, // 479 RayQueryGetIntersectionCandidateAABBOpaqueKHR - {IR(43678, 36), 755}, // 480 RayQueryGetIntersectionFrontFaceKHR - {IR(43558, 40), 752}, // 481 RayQueryGetIntersectionGeometryIndexKHR - {IR(43410, 46), 749}, // 482 RayQueryGetIntersectionInstanceCustomIndexKHR - {IR(43456, 37), 750}, // 483 RayQueryGetIntersectionInstanceIdKHR - {IR(43493, 65), 751}, // 484 RayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR - {IR(35866, 37), 520}, // 485 RayQueryGetIntersectionLSSHitValueNV - {IR(35794, 38), 518}, // 486 RayQueryGetIntersectionLSSPositionsNV - {IR(35832, 34), 519}, // 487 RayQueryGetIntersectionLSSRadiiNV - {IR(43760, 45), 757}, // 488 RayQueryGetIntersectionObjectRayDirectionKHR - {IR(43805, 42), 758}, // 489 RayQueryGetIntersectionObjectRayOriginKHR - {IR(43908, 40), 761}, // 490 RayQueryGetIntersectionObjectToWorldKHR - {IR(43598, 41), 753}, // 491 RayQueryGetIntersectionPrimitiveIndexKHR - {IR(35716, 40), 516}, // 492 RayQueryGetIntersectionSpherePositionNV - {IR(35756, 38), 517}, // 493 RayQueryGetIntersectionSphereRadiusNV - {IR(43382, 28), 748}, // 494 RayQueryGetIntersectionTKHR - {IR(34584, 50), 477}, // 495 RayQueryGetIntersectionTriangleVertexPositionsKHR - {IR(32438, 31), 393}, // 496 RayQueryGetIntersectionTypeKHR - {IR(43948, 40), 762}, // 497 RayQueryGetIntersectionWorldToObjectKHR - {IR(43359, 23), 747}, // 498 RayQueryGetRayFlagsKHR - {IR(43337, 22), 746}, // 499 RayQueryGetRayTMinKHR - {IR(43847, 32), 759}, // 500 RayQueryGetWorldRayDirectionKHR - {IR(43879, 29), 760}, // 501 RayQueryGetWorldRayOriginKHR - {IR(32313, 22), 388}, // 502 RayQueryInitializeKHR - {IR(36074, 19), 528}, // 503 RayQueryIsLSSHitNV - {IR(36052, 22), 527}, // 504 RayQueryIsSphereHitNV - {IR(32419, 19), 392}, // 505 RayQueryProceedKHR - {IR(32335, 21), 389}, // 506 RayQueryTerminateKHR - {IR(32896, 13), 412}, // 507 ReadClockKHR - {IR(29218, 9), 249}, // 508 ReadPipe - {IR(43292, 22), 743}, // 509 ReadPipeBlockingINTEL - {IR(29666, 13), 271}, // 510 ReleaseEvent - {IR(33993, 24), 454}, // 511 ReorderThreadWithHintNV - {IR(33964, 29), 453}, // 512 ReorderThreadWithHitObjectNV - {IR(34466, 22), 471}, // 513 ReportIntersectionKHR - {IR(34488, 21), 471}, // 514 ReportIntersectionNV - {IR(29272, 23), 253}, // 515 ReserveReadPipePackets - {IR(29295, 24), 254}, // 516 ReserveWritePipePackets - {IR(29237, 17), 251}, // 517 ReservedReadPipe - {IR(29254, 18), 252}, // 518 ReservedWritePipe - {IR(41963, 19), 684}, // 519 RestoreMemoryINTEL - {IR(29654, 12), 270}, // 520 RetainEvent - {IR(28983, 7), 231}, // 521 Return - {IR(28990, 12), 232}, // 522 ReturnValue - {IR(44752, 18), 795}, // 523 RoundFToTF32INTEL - {IR(27349, 9), 104}, // 524 SConvert - {IR(27557, 5), 124}, // 525 SDiv - {IR(31900, 5), 373}, // 526 SDot - {IR(31941, 11), 376}, // 527 SDotAccSat - {IR(31952, 14), 376}, // 528 SDotAccSatKHR - {IR(31905, 8), 373}, // 529 SDotKHR - {IR(27925, 13), 161}, // 530 SGreaterThan - {IR(27956, 18), 163}, // 531 SGreaterThanEqual - {IR(27984, 10), 165}, // 532 SLessThan - {IR(28009, 15), 167}, // 533 SLessThanEqual - {IR(27577, 5), 128}, // 534 SMod - {IR(27733, 13), 141}, // 535 SMulExtended - {IR(27506, 8), 115}, // 536 SNegate - {IR(27572, 5), 127}, // 537 SRem - {IR(31926, 6), 375}, // 538 SUDot - {IR(31991, 12), 378}, // 539 SUDotAccSat - {IR(32003, 15), 378}, // 540 SUDotAccSatKHR - {IR(31932, 9), 375}, // 541 SUDotKHR - {IR(26833, 13), 77}, // 542 SampledImage - {IR(35618, 29), 514}, // 543 SamplerImageAddressingModeNV - {IR(27395, 15), 108}, // 544 SatConvertSToU - {IR(27410, 15), 109}, // 545 SatConvertUToS - {IR(41947, 16), 683}, // 546 SaveMemoryINTEL - {IR(27888, 7), 157}, // 547 Select - {IR(28880, 15), 225}, // 548 SelectionMerge - {IR(34266, 18), 464}, // 549 SetMeshOutputsEXT - {IR(29708, 19), 274}, // 550 SetUserEventStatus - {IR(28257, 17), 182}, // 551 ShiftLeftLogical - {IR(28236, 21), 181}, // 552 ShiftRightArithmetic - {IR(28218, 18), 180}, // 553 ShiftRightLogical - {IR(27784, 11), 148}, // 554 SignBitSet - {IR(30189, 7), 294}, // 555 SizeOf - {IR(25162, 7), 3}, // 556 Source - {IR(25043, 16), 2}, // 557 SourceContinued - {IR(25169, 16), 4}, // 558 SourceExtension - {IR(26180, 13), 45}, // 559 SpecConstant - {IR(26193, 22), 46}, // 560 SpecConstantComposite - {IR(44082, 36), 767}, // 561 SpecConstantCompositeContinuedINTEL - {IR(32232, 34), 385}, // 562 SpecConstantCompositeReplicateEXT - {IR(26162, 18), 44}, // 563 SpecConstantFalse - {IR(26256, 15), 47}, // 564 SpecConstantOp - {IR(33081, 23), 420}, // 565 SpecConstantStringAMDX - {IR(26145, 17), 43}, // 566 SpecConstantTrue - {IR(31279, 25), 346}, // 567 StencilAttachmentReadEXT - {IR(26420, 6), 55}, // 568 Store - {IR(25201, 7), 7}, // 569 String - {IR(44383, 25), 780}, // 570 Subgroup2DBlockLoadINTEL - {IR(44408, 34), 781}, // 571 Subgroup2DBlockLoadTransformINTEL - {IR(44442, 34), 782}, // 572 Subgroup2DBlockLoadTransposeINTEL - {IR(44476, 29), 783}, // 573 Subgroup2DBlockPrefetchINTEL - {IR(44505, 26), 784}, // 574 Subgroup2DBlockStoreINTEL - {IR(31677, 20), 364}, // 575 SubgroupAllEqualKHR - {IR(31647, 15), 362}, // 576 SubgroupAllKHR - {IR(31662, 15), 363}, // 577 SubgroupAnyKHR - {IR(40465, 30), 647}, // 578 SubgroupAvcBmeInitializeINTEL - {IR(40435, 30), 646}, // 579 SubgroupAvcFmeInitializeINTEL - {IR(38870, 35), 616}, // 580 SubgroupAvcImeAdjustRefOffsetINTEL - {IR(38905, 39), 617}, // 581 SubgroupAvcImeConvertToMcePayloadINTEL - {IR(39546, 38), 630}, // 582 SubgroupAvcImeConvertToMceResultINTEL - {IR(39169, 45), 623}, // 583 SubgroupAvcImeEvaluateWithDualReferenceINTEL - {IR(39269, 53), 625}, // 584 SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL - {IR(39490, 56), 629}, // 585 SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL - {IR(39378, 54), 627}, // 586 SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL - {IR(39122, 47), 622}, // 587 SubgroupAvcImeEvaluateWithSingleReferenceINTEL - {IR(39214, 55), 624}, // 588 SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL - {IR(39432, 58), 628}, // 589 SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL - {IR(39322, 56), 626}, // 590 SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL - {IR(40178, 36), 641}, // 591 SubgroupAvcImeGetBorderReachedINTEL - {IR(39630, 44), 632}, // 592 SubgroupAvcImeGetDualReferenceStreaminINTEL - {IR(39584, 46), 631}, // 593 SubgroupAvcImeGetSingleReferenceStreaminINTEL - {IR(40045, 66), 639}, // 594 SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL - {IR(39977, 68), 638}, // 595 SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL - {IR(40111, 67), 640}, // 596 SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL - {IR(39840, 68), 636}, // 597 SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL - {IR(39770, 70), 635}, // 598 SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL - {IR(39908, 69), 637}, // 599 SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL - {IR(40214, 48), 642}, // 600 SubgroupAvcImeGetTruncatedSearchIndicationINTEL - {IR(40262, 59), 643}, // 601 SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL - {IR(40379, 56), 645}, // 602 SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL - {IR(40321, 58), 644}, // 603 SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL - {IR(38733, 30), 612}, // 604 SubgroupAvcImeInitializeINTEL - {IR(38837, 33), 615}, // 605 SubgroupAvcImeRefWindowSizeINTEL - {IR(38801, 36), 614}, // 606 SubgroupAvcImeSetDualReferenceINTEL - {IR(39034, 54), 620}, // 607 SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL - {IR(38944, 43), 618}, // 608 SubgroupAvcImeSetMaxMotionVectorCountINTEL - {IR(38763, 38), 613}, // 609 SubgroupAvcImeSetSingleReferenceINTEL - {IR(38987, 47), 619}, // 610 SubgroupAvcImeSetUnidirectionalMixDisableINTEL - {IR(39088, 34), 621}, // 611 SubgroupAvcImeSetWeightedSadINTEL - {IR(39723, 47), 634}, // 612 SubgroupAvcImeStripDualReferenceStreamoutINTEL - {IR(39674, 49), 633}, // 613 SubgroupAvcImeStripSingleReferenceStreamoutINTEL - {IR(38123, 39), 597}, // 614 SubgroupAvcMceConvertToImePayloadINTEL - {IR(38162, 38), 598}, // 615 SubgroupAvcMceConvertToImeResultINTEL - {IR(38200, 39), 599}, // 616 SubgroupAvcMceConvertToRefPayloadINTEL - {IR(38239, 38), 600}, // 617 SubgroupAvcMceConvertToRefResultINTEL - {IR(38277, 39), 601}, // 618 SubgroupAvcMceConvertToSicPayloadINTEL - {IR(38316, 38), 602}, // 619 SubgroupAvcMceConvertToSicResultINTEL - {IR(38429, 43), 605}, // 620 SubgroupAvcMceGetBestInterDistortionsINTEL - {IR(37561, 50), 586}, // 621 SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL - {IR(37159, 60), 578}, // 622 SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL - {IR(37359, 51), 582}, // 623 SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL - {IR(37505, 56), 585}, // 624 SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL - {IR(37272, 47), 580}, // 625 SubgroupAvcMceGetDefaultInterShapePenaltyINTEL - {IR(37860, 56), 592}, // 626 SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL - {IR(37759, 50), 590}, // 627 SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL - {IR(37454, 51), 584}, // 628 SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL - {IR(37663, 49), 588}, // 629 SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL - {IR(37611, 52), 587}, // 630 SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL - {IR(37809, 51), 591}, // 631 SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL - {IR(38548, 38), 608}, // 632 SubgroupAvcMceGetInterDirectionsINTEL - {IR(38390, 39), 604}, // 633 SubgroupAvcMceGetInterDistortionsINTEL - {IR(38472, 38), 606}, // 634 SubgroupAvcMceGetInterMajorShapeINTEL - {IR(38510, 38), 607}, // 635 SubgroupAvcMceGetInterMinorShapeINTEL - {IR(38586, 45), 609}, // 636 SubgroupAvcMceGetInterMotionVectorCountINTEL - {IR(38631, 40), 610}, // 637 SubgroupAvcMceGetInterReferenceIdsINTEL - {IR(38671, 62), 611}, // 638 SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL - {IR(38354, 36), 603}, // 639 SubgroupAvcMceGetMotionVectorsINTEL - {IR(37916, 33), 593}, // 640 SubgroupAvcMceSetAcOnlyHaarINTEL - {IR(38062, 61), 596}, // 641 SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL - {IR(37219, 53), 579}, // 642 SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL - {IR(37410, 44), 583}, // 643 SubgroupAvcMceSetInterDirectionPenaltyINTEL - {IR(37319, 40), 581}, // 644 SubgroupAvcMceSetInterShapePenaltyINTEL - {IR(37712, 47), 589}, // 645 SubgroupAvcMceSetMotionVectorCostFunctionINTEL - {IR(38001, 61), 595}, // 646 SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL - {IR(37949, 52), 594}, // 647 SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL - {IR(40495, 39), 648}, // 648 SubgroupAvcRefConvertToMcePayloadINTEL - {IR(40817, 38), 655}, // 649 SubgroupAvcRefConvertToMceResultINTEL - {IR(40670, 45), 652}, // 650 SubgroupAvcRefEvaluateWithDualReferenceINTEL - {IR(40715, 46), 653}, // 651 SubgroupAvcRefEvaluateWithMultiReferenceINTEL - {IR(40761, 56), 654}, // 652 SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL - {IR(40623, 47), 651}, // 653 SubgroupAvcRefEvaluateWithSingleReferenceINTEL - {IR(40534, 46), 649}, // 654 SubgroupAvcRefSetBidirectionalMixDisableINTEL - {IR(40580, 43), 650}, // 655 SubgroupAvcRefSetBilinearFilterEnableINTEL - {IR(40953, 42), 659}, // 656 SubgroupAvcSicConfigureIpeLumaChromaINTEL - {IR(40917, 36), 658}, // 657 SubgroupAvcSicConfigureIpeLumaINTEL - {IR(40885, 32), 657}, // 658 SubgroupAvcSicConfigureSkcINTEL - {IR(41034, 39), 661}, // 659 SubgroupAvcSicConvertToMcePayloadINTEL - {IR(41574, 38), 673}, // 660 SubgroupAvcSicConvertToMceResultINTEL - {IR(41349, 31), 668}, // 661 SubgroupAvcSicEvaluateIpeINTEL - {IR(41427, 45), 670}, // 662 SubgroupAvcSicEvaluateWithDualReferenceINTEL - {IR(41472, 46), 671}, // 663 SubgroupAvcSicEvaluateWithMultiReferenceINTEL - {IR(41518, 56), 672}, // 664 SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL - {IR(41380, 47), 669}, // 665 SubgroupAvcSicEvaluateWithSingleReferenceINTEL - {IR(41691, 46), 676}, // 666 SubgroupAvcSicGetBestIpeChromaDistortionINTEL - {IR(41647, 44), 675}, // 667 SubgroupAvcSicGetBestIpeLumaDistortionINTEL - {IR(41912, 35), 681}, // 668 SubgroupAvcSicGetInterRawSadsINTEL - {IR(41778, 36), 678}, // 669 SubgroupAvcSicGetIpeChromaModeINTEL - {IR(41612, 35), 674}, // 670 SubgroupAvcSicGetIpeLumaShapeINTEL - {IR(40995, 39), 660}, // 671 SubgroupAvcSicGetMotionVectorMaskINTEL - {IR(41737, 41), 677}, // 672 SubgroupAvcSicGetPackedIpeLumaModesINTEL - {IR(41814, 50), 679}, // 673 SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL - {IR(41864, 48), 680}, // 674 SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL - {IR(40855, 30), 656}, // 675 SubgroupAvcSicInitializeINTEL - {IR(41215, 43), 665}, // 676 SubgroupAvcSicSetBilinearFilterEnableINTEL - {IR(41306, 43), 667}, // 677 SubgroupAvcSicSetBlockBasedRawSkipSadINTEL - {IR(41165, 50), 664}, // 678 SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL - {IR(41117, 48), 663}, // 679 SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL - {IR(41073, 44), 662}, // 680 SubgroupAvcSicSetIntraLumaShapePenaltyINTEL - {IR(41258, 48), 666}, // 681 SubgroupAvcSicSetSkcForwardTransformEnableINTEL - {IR(5330, 18), 356}, // 682 SubgroupBallotKHR - {IR(44356, 27), 779}, // 683 SubgroupBlockPrefetchINTEL - {IR(36165, 23), 533}, // 684 SubgroupBlockReadINTEL - {IR(36188, 24), 534}, // 685 SubgroupBlockWriteINTEL - {IR(31521, 27), 357}, // 686 SubgroupFirstInvocationKHR - {IR(36212, 28), 535}, // 687 SubgroupImageBlockReadINTEL - {IR(36240, 29), 536}, // 688 SubgroupImageBlockWriteINTEL - {IR(36269, 33), 537}, // 689 SubgroupImageMediaBlockReadINTEL - {IR(36302, 34), 538}, // 690 SubgroupImageMediaBlockWriteINTEL - {IR(13673, 38), 785}, // 691 SubgroupMatrixMultiplyAccumulateINTEL - {IR(31697, 26), 366}, // 692 SubgroupReadInvocationKHR - {IR(36093, 25), 530}, // 693 SubgroupShuffleDownINTEL - {IR(11888, 21), 529}, // 694 SubgroupShuffleINTEL - {IR(36118, 23), 531}, // 695 SubgroupShuffleUpINTEL - {IR(36141, 24), 532}, // 696 SubgroupShuffleXorINTEL - {IR(28971, 7), 229}, // 697 Switch - {IR(44265, 23), 775}, // 698 TaskSequenceAsyncINTEL - {IR(44241, 24), 774}, // 699 TaskSequenceCreateINTEL - {IR(44288, 21), 776}, // 700 TaskSequenceGetINTEL - {IR(44309, 25), 777}, // 701 TaskSequenceReleaseINTEL - {IR(35436, 27), 506}, // 702 TensorLayoutSetBlockSizeNV - {IR(35300, 28), 499}, // 703 TensorLayoutSetClampValueNV - {IR(35229, 27), 496}, // 704 TensorLayoutSetDimensionNV - {IR(35256, 24), 497}, // 705 TensorLayoutSetStrideNV - {IR(35280, 20), 498}, // 706 TensorLayoutSliceNV - {IR(31389, 19), 350}, // 707 TensorQuerySizeARM - {IR(31360, 14), 348}, // 708 TensorReadARM - {IR(35416, 20), 505}, // 709 TensorViewSetClipNV - {IR(35347, 25), 501}, // 710 TensorViewSetDimensionNV - {IR(35372, 22), 502}, // 711 TensorViewSetStrideNV - {IR(31374, 15), 349}, // 712 TensorWriteARM - {IR(31408, 20), 351}, // 713 TerminateInvocation - {IR(31837, 16), 372}, // 714 TerminateRayKHR - {IR(34530, 15), 473}, // 715 TerminateRayNV - {IR(34553, 14), 475}, // 716 TraceMotionNV - {IR(34545, 8), 474}, // 717 TraceNV - {IR(31749, 12), 368}, // 718 TraceRayKHR - {IR(34567, 17), 476}, // 719 TraceRayMotionNV - {IR(26823, 10), 76}, // 720 Transpose - {IR(34634, 29), 478}, // 721 TypeAccelerationStructureKHR - {IR(34663, 28), 478}, // 722 TypeAccelerationStructureNV - {IR(25772, 10), 25}, // 723 TypeArray - {IR(37078, 37), 575}, // 724 TypeAvcImeDualReferenceStreaminINTEL - {IR(36813, 23), 566}, // 725 TypeAvcImePayloadINTEL - {IR(36995, 44), 573}, // 726 TypeAvcImeResultDualReferenceStreamoutINTEL - {IR(36927, 22), 571}, // 727 TypeAvcImeResultINTEL - {IR(36949, 46), 572}, // 728 TypeAvcImeResultSingleReferenceStreamoutINTEL - {IR(37039, 39), 574}, // 729 TypeAvcImeSingleReferenceStreaminINTEL - {IR(36882, 23), 569}, // 730 TypeAvcMcePayloadINTEL - {IR(36905, 22), 570}, // 731 TypeAvcMceResultINTEL - {IR(36836, 23), 567}, // 732 TypeAvcRefPayloadINTEL - {IR(37115, 22), 576}, // 733 TypeAvcRefResultINTEL - {IR(36859, 23), 568}, // 734 TypeAvcSicPayloadINTEL - {IR(37137, 22), 577}, // 735 TypeAvcSicResultINTEL - {IR(25534, 9), 17}, // 736 TypeBool - {IR(44002, 23), 764}, // 737 TypeBufferSurfaceINTEL - {IR(32018, 25), 379}, // 738 TypeCooperativeMatrixKHR - {IR(34756, 24), 482}, // 739 TypeCooperativeMatrixNV - {IR(34056, 24), 457}, // 740 TypeCooperativeVectorNV - {IR(25887, 16), 32}, // 741 TypeDeviceEvent - {IR(25877, 10), 31}, // 742 TypeEvent - {IR(25588, 10), 19}, // 743 TypeFloat - {IR(25936, 19), 36}, // 744 TypeForwardPointer - {IR(25864, 13), 30}, // 745 TypeFunction - {IR(34017, 16), 455}, // 746 TypeHitObjectNV - {IR(25733, 10), 22}, // 747 TypeImage - {IR(25543, 8), 18}, // 748 TypeInt - {IR(25609, 11), 21}, // 749 TypeMatrix - {IR(30318, 17), 300}, // 750 TypeNamedBarrier - {IR(32958, 25), 415}, // 751 TypeNodePayloadArrayAMDX - {IR(25810, 11), 28}, // 752 TypeOpaque - {IR(25927, 9), 35}, // 753 TypePipe - {IR(30196, 16), 295}, // 754 TypePipeStorage - {IR(25852, 12), 29}, // 755 TypePointer - {IR(25917, 10), 34}, // 756 TypeQueue - {IR(32297, 16), 387}, // 757 TypeRayQueryKHR - {IR(25903, 14), 33}, // 758 TypeReserveId - {IR(25782, 17), 26}, // 759 TypeRuntimeArray - {IR(25755, 17), 24}, // 760 TypeSampledImage - {IR(25743, 12), 23}, // 761 TypeSampler - {IR(25799, 11), 27}, // 762 TypeStruct - {IR(44025, 25), 765}, // 763 TypeStructContinuedINTEL - {IR(44334, 22), 778}, // 764 TypeTaskSequenceINTEL - {IR(31304, 14), 347}, // 765 TypeTensorARM - {IR(35172, 19), 493}, // 766 TypeTensorLayoutNV - {IR(35191, 17), 494}, // 767 TypeTensorViewNV - {IR(31428, 22), 352}, // 768 TypeUntypedPointerKHR - {IR(25598, 11), 20}, // 769 TypeVector - {IR(36795, 18), 565}, // 770 TypeVmeImageINTEL - {IR(25525, 9), 16}, // 771 TypeVoid - {IR(36424, 13), 544}, // 772 UAddSatINTEL - {IR(36451, 14), 546}, // 773 UAverageINTEL - {IR(36486, 21), 548}, // 774 UAverageRoundedINTEL - {IR(27340, 9), 103}, // 775 UConvert - {IR(36336, 24), 539}, // 776 UCountLeadingZerosINTEL - {IR(36360, 25), 540}, // 777 UCountTrailingZerosINTEL - {IR(27552, 5), 123}, // 778 UDiv - {IR(31913, 5), 374}, // 779 UDot - {IR(31966, 11), 377}, // 780 UDotAccSat - {IR(31977, 14), 377}, // 781 UDotAccSatKHR - {IR(31918, 8), 374}, // 782 UDotKHR - {IR(27912, 13), 160}, // 783 UGreaterThan - {IR(27938, 18), 162}, // 784 UGreaterThanEqual - {IR(27974, 10), 164}, // 785 ULessThan - {IR(27994, 15), 166}, // 786 ULessThanEqual - {IR(27567, 5), 126}, // 787 UMod - {IR(36548, 15), 552}, // 788 UMul32x16INTEL - {IR(27720, 13), 140}, // 789 UMulExtended - {IR(36520, 13), 550}, // 790 USubSatINTEL - {IR(25037, 6), 1}, // 791 Undef - {IR(27817, 10), 151}, // 792 Unordered - {IR(29002, 12), 233}, // 793 Unreachable - {IR(31469, 22), 354}, // 794 UntypedAccessChainKHR - {IR(31606, 22), 360}, // 795 UntypedArrayLengthKHR - {IR(31491, 30), 355}, // 796 UntypedInBoundsAccessChainKHR - {IR(31573, 33), 359}, // 797 UntypedInBoundsPtrAccessChainKHR - {IR(31628, 19), 361}, // 798 UntypedPrefetchKHR - {IR(31548, 25), 358}, // 799 UntypedPtrAccessChainKHR - {IR(31450, 19), 353}, // 800 UntypedVariableKHR - {IR(26348, 9), 52}, // 801 Variable - {IR(12344, 25), 682}, // 802 VariableLengthArrayINTEL - {IR(26705, 21), 69}, // 803 VectorExtractDynamic - {IR(26726, 20), 70}, // 804 VectorInsertDynamic - {IR(26746, 14), 71}, // 805 VectorShuffle - {IR(27628, 18), 133}, // 806 VectorTimesMatrix - {IR(27592, 18), 131}, // 807 VectorTimesScalar - {IR(36781, 14), 564}, // 808 VmeImageINTEL - {IR(34311, 33), 466}, // 809 WritePackedPrimitiveIndices4x8NV - {IR(29227, 10), 250}, // 810 WritePipe - {IR(43314, 23), 744}, // 811 WritePipeBlockingINTEL +static const std::array kInstructionNames{{ + {IR(36873, 13), 554}, // 0 AbsISubINTEL + {IR(36886, 13), 555}, // 1 AbsUSubINTEL + {IR(26686, 12), 58}, // 2 AccessChain + {IR(43486, 21), 740}, // 3 AliasDomainDeclINTEL + {IR(43507, 20), 741}, // 4 AliasScopeDeclINTEL + {IR(43527, 24), 742}, // 5 AliasScopeListDeclINTEL + {IR(27983, 4), 143}, // 6 All + {IR(33362, 25), 426}, // 7 AllocateNodePayloadsAMDX + {IR(27979, 4), 142}, // 8 Any + {IR(43273, 24), 731}, // 9 ArbitraryFloatACosINTEL + {IR(43297, 26), 732}, // 10 ArbitraryFloatACosPiINTEL + {IR(43223, 24), 729}, // 11 ArbitraryFloatASinINTEL + {IR(43247, 26), 730}, // 12 ArbitraryFloatASinPiINTEL + {IR(43373, 25), 735}, // 13 ArbitraryFloatATan2INTEL + {IR(43323, 24), 733}, // 14 ArbitraryFloatATanINTEL + {IR(43347, 26), 734}, // 15 ArbitraryFloatATanPiINTEL + {IR(42582, 23), 702}, // 16 ArbitraryFloatAddINTEL + {IR(42522, 31), 700}, // 17 ArbitraryFloatCastFromIntINTEL + {IR(42498, 24), 699}, // 18 ArbitraryFloatCastINTEL + {IR(42553, 29), 701}, // 19 ArbitraryFloatCastToIntINTEL + {IR(42834, 24), 713}, // 20 ArbitraryFloatCbrtINTEL + {IR(43124, 23), 725}, // 21 ArbitraryFloatCosINTEL + {IR(43198, 25), 728}, // 22 ArbitraryFloatCosPiINTEL + {IR(42651, 23), 705}, // 23 ArbitraryFloatDivINTEL + {IR(42762, 22), 710}, // 24 ArbitraryFloatEQINTEL + {IR(43051, 25), 722}, // 25 ArbitraryFloatExp10INTEL + {IR(43027, 24), 721}, // 26 ArbitraryFloatExp2INTEL + {IR(43004, 23), 720}, // 27 ArbitraryFloatExpINTEL + {IR(43076, 25), 723}, // 28 ArbitraryFloatExpm1INTEL + {IR(42696, 22), 707}, // 29 ArbitraryFloatGEINTEL + {IR(42674, 22), 706}, // 30 ArbitraryFloatGTINTEL + {IR(42858, 25), 714}, // 31 ArbitraryFloatHypotINTEL + {IR(42740, 22), 709}, // 32 ArbitraryFloatLEINTEL + {IR(42718, 22), 708}, // 33 ArbitraryFloatLTINTEL + {IR(42954, 25), 718}, // 34 ArbitraryFloatLog10INTEL + {IR(42979, 25), 719}, // 35 ArbitraryFloatLog1pINTEL + {IR(42930, 24), 717}, // 36 ArbitraryFloatLog2INTEL + {IR(42907, 23), 716}, // 37 ArbitraryFloatLogINTEL + {IR(42628, 23), 704}, // 38 ArbitraryFloatMulINTEL + {IR(43398, 23), 736}, // 39 ArbitraryFloatPowINTEL + {IR(43445, 24), 738}, // 40 ArbitraryFloatPowNINTEL + {IR(43421, 24), 737}, // 41 ArbitraryFloatPowRINTEL + {IR(42809, 25), 712}, // 42 ArbitraryFloatRSqrtINTEL + {IR(42784, 25), 711}, // 43 ArbitraryFloatRecipINTEL + {IR(43147, 26), 726}, // 44 ArbitraryFloatSinCosINTEL + {IR(42470, 28), 698}, // 45 ArbitraryFloatSinCosPiINTEL + {IR(43101, 23), 724}, // 46 ArbitraryFloatSinINTEL + {IR(43173, 25), 727}, // 47 ArbitraryFloatSinPiINTEL + {IR(42883, 24), 715}, // 48 ArbitraryFloatSqrtINTEL + {IR(42605, 23), 703}, // 49 ArbitraryFloatSubINTEL + {IR(13476, 19), 786}, // 50 ArithmeticFenceEXT + {IR(26733, 12), 61}, // 51 ArrayLength + {IR(37120, 13), 570}, // 52 AsmCallINTEL + {IR(12240, 9), 569}, // 53 AsmINTEL + {IR(37105, 15), 568}, // 54 AsmTargetINTEL + {IR(37161, 14), 573}, // 55 AssumeTrueKHR + {IR(29005, 10), 220}, // 56 AtomicAnd + {IR(28857, 22), 210}, // 57 AtomicCompareExchange + {IR(28879, 26), 211}, // 58 AtomicCompareExchangeWeak + {IR(28842, 15), 209}, // 59 AtomicExchange + {IR(44476, 14), 776}, // 60 AtomicFAddEXT + {IR(37147, 14), 572}, // 61 AtomicFMaxEXT + {IR(37133, 14), 571}, // 62 AtomicFMinEXT + {IR(30390, 16), 292}, // 63 AtomicFlagClear + {IR(30369, 21), 291}, // 64 AtomicFlagTestAndSet + {IR(28939, 11), 214}, // 65 AtomicIAdd + {IR(28922, 17), 213}, // 66 AtomicIDecrement + {IR(28905, 17), 212}, // 67 AtomicIIncrement + {IR(28950, 11), 215}, // 68 AtomicISub + {IR(28819, 11), 207}, // 69 AtomicLoad + {IR(29015, 9), 221}, // 70 AtomicOr + {IR(28983, 11), 218}, // 71 AtomicSMax + {IR(28961, 11), 216}, // 72 AtomicSMin + {IR(28830, 12), 208}, // 73 AtomicStore + {IR(28994, 11), 219}, // 74 AtomicUMax + {IR(28972, 11), 217}, // 75 AtomicUMin + {IR(29024, 10), 222}, // 76 AtomicXor + {IR(35369, 28), 500}, // 77 BeginInvocationInterlockEXT + {IR(32916, 17), 407}, // 78 BitCastArrayQCOM + {IR(28603, 9), 191}, // 79 BitCount + {IR(28543, 15), 187}, // 80 BitFieldInsert + {IR(28558, 17), 188}, // 81 BitFieldSExtract + {IR(28575, 17), 189}, // 82 BitFieldUExtract + {IR(28592, 11), 190}, // 83 BitReverse + {IR(27731, 8), 114}, // 84 Bitcast + {IR(28528, 11), 185}, // 85 BitwiseAnd + {IR(45081, 21), 799}, // 86 BitwiseFunctionINTEL + {IR(28507, 10), 183}, // 87 BitwiseOr + {IR(28517, 11), 184}, // 88 BitwiseXor + {IR(29134, 7), 227}, // 89 Branch + {IR(29141, 18), 228}, // 90 BranchConditional + {IR(30002, 13), 277}, // 91 BuildNDRange + {IR(25747, 11), 15}, // 92 Capability + {IR(29960, 26), 275}, // 93 CaptureEventProfilingInfo + {IR(31466, 23), 344}, // 94 ColorAttachmentReadEXT + {IR(29552, 15), 255}, // 95 CommitReadPipe + {IR(29567, 16), 256}, // 96 CommitWritePipe + {IR(26993, 19), 72}, // 97 CompositeConstruct + {IR(44606, 33), 781}, // 98 CompositeConstructContinuedINTEL + {IR(33049, 30), 412}, // 99 CompositeConstructCoopMatQCOM + {IR(32624, 31), 395}, // 100 CompositeConstructReplicateEXT + {IR(27012, 17), 73}, // 101 CompositeExtract + {IR(33079, 28), 413}, // 102 CompositeExtractCoopMatQCOM + {IR(27029, 16), 74}, // 103 CompositeInsert + {IR(45155, 27), 803}, // 104 ConditionalCapabilityINTEL + {IR(45303, 27), 807}, // 105 ConditionalCopyObjectINTEL + {IR(45128, 27), 802}, // 106 ConditionalEntryPointINTEL + {IR(45102, 26), 801}, // 107 ConditionalExtensionINTEL + {IR(15470, 9), 39}, // 108 Constant + {IR(26253, 18), 40}, // 109 ConstantComposite + {IR(44538, 32), 779}, // 110 ConstantCompositeContinuedINTEL + {IR(32560, 30), 393}, // 111 ConstantCompositeReplicateEXT + {IR(26201, 14), 38}, // 112 ConstantFalse + {IR(37051, 29), 566}, // 113 ConstantFunctionPointerINTEL + {IR(26365, 13), 42}, // 114 ConstantNull + {IR(30445, 20), 296}, // 115 ConstantPipeStorage + {IR(26349, 16), 41}, // 116 ConstantSampler + {IR(33515, 19), 432}, // 117 ConstantStringAMDX + {IR(26188, 13), 37}, // 118 ConstantTrue + {IR(28790, 15), 205}, // 119 ControlBarrier + {IR(44679, 26), 784}, // 120 ControlBarrierArriveINTEL + {IR(44705, 24), 785}, // 121 ControlBarrierWaitINTEL + {IR(44659, 20), 783}, // 122 ConvertBF16ToFINTEL + {IR(44639, 20), 782}, // 123 ConvertFToBF16INTEL + {IR(27537, 12), 100}, // 124 ConvertFToS + {IR(27525, 12), 99}, // 125 ConvertFToU + {IR(45523, 26), 819}, // 126 ConvertHandleToImageINTEL + {IR(45577, 33), 821}, // 127 ConvertHandleToSampledImageINTEL + {IR(45549, 28), 820}, // 128 ConvertHandleToSamplerINTEL + {IR(36018, 18), 523}, // 129 ConvertImageToUNV + {IR(27614, 14), 107}, // 130 ConvertPtrToU + {IR(27549, 12), 101}, // 131 ConvertSToF + {IR(36081, 25), 526}, // 132 ConvertSampledImageToUNV + {IR(36036, 20), 524}, // 133 ConvertSamplerToUNV + {IR(32138, 35), 379}, // 134 ConvertUToAccelerationStructureKHR + {IR(27561, 12), 102}, // 135 ConvertUToF + {IR(35980, 18), 521}, // 136 ConvertUToImageNV + {IR(27658, 14), 110}, // 137 ConvertUToPtr + {IR(36056, 25), 525}, // 138 ConvertUToSampledImageNV + {IR(35998, 20), 522}, // 139 ConvertUToSamplerNV + {IR(34675, 27), 475}, // 140 CooperativeMatrixConvertNV + {IR(32533, 27), 392}, // 141 CooperativeMatrixLengthKHR + {IR(35343, 26), 499}, // 142 CooperativeMatrixLengthNV + {IR(32401, 25), 389}, // 143 CooperativeMatrixLoadKHR + {IR(35268, 24), 496}, // 144 CooperativeMatrixLoadNV + {IR(35567, 30), 503}, // 145 CooperativeMatrixLoadTensorNV + {IR(32506, 27), 391}, // 146 CooperativeMatrixMulAddKHR + {IR(35317, 26), 498}, // 147 CooperativeMatrixMulAddNV + {IR(35628, 32), 505}, // 148 CooperativeMatrixPerElementOpNV + {IR(35466, 26), 502}, // 149 CooperativeMatrixReduceNV + {IR(32426, 26), 390}, // 150 CooperativeMatrixStoreKHR + {IR(35292, 25), 497}, // 151 CooperativeMatrixStoreNV + {IR(35597, 31), 504}, // 152 CooperativeMatrixStoreTensorNV + {IR(35951, 29), 520}, // 153 CooperativeMatrixTransposeNV + {IR(34870, 24), 482}, // 154 CooperativeVectorLoadNV + {IR(34643, 32), 474}, // 155 CooperativeVectorMatrixMulAddNV + {IR(34533, 29), 471}, // 156 CooperativeVectorMatrixMulNV + {IR(34562, 42), 472}, // 157 CooperativeVectorOuterProductAccumulateNV + {IR(34604, 39), 473}, // 158 CooperativeVectorReduceSumAccumulateNV + {IR(34894, 25), 483}, // 159 CooperativeVectorStoreNV + {IR(31425, 12), 340}, // 160 CopyLogical + {IR(26659, 11), 56}, // 161 CopyMemory + {IR(26670, 16), 57}, // 162 CopyMemorySized + {IR(27045, 11), 75}, // 163 CopyObject + {IR(30465, 26), 297}, // 164 CreatePipeFromPipeStorage + {IR(35696, 21), 508}, // 165 CreateTensorLayoutNV + {IR(35816, 19), 513}, // 166 CreateTensorViewNV + {IR(29912, 16), 272}, // 167 CreateUserEvent + {IR(43751, 29), 755}, // 168 CrossWorkgroupCastToPtrINTEL + {IR(28612, 5), 192}, // 169 DPdx + {IR(28658, 11), 198}, // 170 DPdxCoarse + {IR(28629, 9), 195}, // 171 DPdxFine + {IR(28617, 5), 193}, // 172 DPdy + {IR(28669, 11), 199}, // 173 DPdyCoarse + {IR(28638, 9), 196}, // 174 DPdyFine + {IR(26819, 9), 64}, // 175 Decorate + {IR(30642, 11), 305}, // 176 DecorateId + {IR(37185, 15), 575}, // 177 DecorateString + {IR(37200, 21), 575}, // 178 DecorateStringGOOGLE + {IR(26843, 16), 66}, // 179 DecorationGroup + {IR(11574, 25), 516}, // 180 DemoteToHelperInvocation + {IR(11599, 28), 516}, // 181 DemoteToHelperInvocationEXT + {IR(31489, 23), 345}, // 182 DepthAttachmentReadEXT + {IR(27928, 4), 137}, // 183 Dot + {IR(34702, 17), 476}, // 184 EmitMeshTasksEXT + {IR(28717, 17), 203}, // 185 EmitStreamVertex + {IR(28693, 11), 201}, // 186 EmitVertex + {IR(35397, 26), 501}, // 187 EndInvocationInterlockEXT + {IR(28704, 13), 202}, // 188 EndPrimitive + {IR(28734, 19), 204}, // 189 EndStreamPrimitive + {IR(29748, 14), 265}, // 190 EnqueueKernel + {IR(29734, 14), 264}, // 191 EnqueueMarker + {IR(33387, 24), 427}, // 192 EnqueueNodePayloadsAMDX + {IR(25662, 11), 13}, // 193 EntryPoint + {IR(32119, 19), 378}, // 194 ExecuteCallableKHR + {IR(35144, 18), 492}, // 195 ExecuteCallableNV + {IR(25705, 14), 14}, // 196 ExecutionMode + {IR(30626, 16), 304}, // 197 ExecutionModeId + {IR(37175, 10), 574}, // 198 ExpectKHR + {IR(25516, 8), 11}, // 199 ExtInst + {IR(25456, 14), 10}, // 200 ExtInstImport + {IR(32056, 26), 375}, // 201 ExtInstWithForwardRefsKHR + {IR(25446, 10), 9}, // 202 Extension + {IR(33107, 20), 414}, // 203 ExtractSubArrayQCOM + {IR(27760, 5), 118}, // 204 FAdd + {IR(27591, 9), 105}, // 205 FConvert + {IR(27795, 5), 125}, // 206 FDiv + {IR(27820, 5), 130}, // 207 FMod + {IR(27780, 5), 122}, // 208 FMul + {IR(27747, 8), 116}, // 209 FNegate + {IR(28257, 10), 168}, // 210 FOrdEqual + {IR(28335, 16), 174}, // 211 FOrdGreaterThan + {IR(28407, 21), 178}, // 212 FOrdGreaterThanEqual + {IR(28307, 13), 172}, // 213 FOrdLessThan + {IR(28369, 18), 176}, // 214 FOrdLessThanEqual + {IR(28279, 13), 170}, // 215 FOrdNotEqual + {IR(13037, 13), 758}, // 216 FPGARegINTEL + {IR(27815, 5), 129}, // 217 FRem + {IR(27770, 5), 120}, // 218 FSub + {IR(28267, 12), 169}, // 219 FUnordEqual + {IR(28351, 18), 175}, // 220 FUnordGreaterThan + {IR(28428, 23), 179}, // 221 FUnordGreaterThanEqual + {IR(28320, 15), 173}, // 222 FUnordLessThan + {IR(28387, 20), 177}, // 223 FUnordLessThanEqual + {IR(28292, 15), 171}, // 224 FUnordNotEqual + {IR(34832, 38), 481}, // 225 FetchMicroTriangleVertexBarycentricNV + {IR(34797, 35), 480}, // 226 FetchMicroTriangleVertexPositionNV + {IR(33436, 29), 429}, // 227 FinishWritingNodePayloadAMDX + {IR(43612, 14), 747}, // 228 FixedCosINTEL + {IR(43659, 16), 750}, // 229 FixedCosPiINTEL + {IR(43708, 14), 753}, // 230 FixedExpINTEL + {IR(43694, 14), 752}, // 231 FixedLogINTEL + {IR(43566, 16), 744}, // 232 FixedRecipINTEL + {IR(43582, 16), 745}, // 233 FixedRsqrtINTEL + {IR(43626, 17), 748}, // 234 FixedSinCosINTEL + {IR(43675, 19), 751}, // 235 FixedSinCosPiINTEL + {IR(43598, 14), 746}, // 236 FixedSinINTEL + {IR(43643, 16), 749}, // 237 FixedSinPiINTEL + {IR(43551, 15), 743}, // 238 FixedSqrtINTEL + {IR(31973, 7), 369}, // 239 FmaKHR + {IR(33332, 17), 424}, // 240 FragmentFetchAMD + {IR(33311, 21), 423}, // 241 FragmentMaskFetchAMD + {IR(24566, 9), 48}, // 242 Function + {IR(26568, 13), 51}, // 243 FunctionCall + {IR(26556, 12), 50}, // 244 FunctionEnd + {IR(26538, 18), 49}, // 245 FunctionParameter + {IR(37080, 25), 567}, // 246 FunctionPointerCallINTEL + {IR(28622, 7), 194}, // 247 Fwidth + {IR(28680, 13), 200}, // 248 FwidthCoarse + {IR(28647, 11), 197}, // 249 FwidthFine + {IR(27689, 17), 112}, // 250 GenericCastToPtr + {IR(27706, 25), 113}, // 251 GenericCastToPtrExplicit + {IR(26745, 23), 62}, // 252 GenericPtrMemSemantics + {IR(29986, 16), 276}, // 253 GetDefaultQueue + {IR(30491, 35), 298}, // 254 GetKernelLocalSizeForSubgroupCount + {IR(30526, 25), 299}, // 255 GetKernelMaxNumSubgroups + {IR(29792, 32), 267}, // 256 GetKernelNDrangeMaxSubGroupSize + {IR(29762, 30), 266}, // 257 GetKernelNDrangeSubGroupCount + {IR(29847, 40), 269}, // 258 GetKernelPreferredWorkGroupSizeMultiple + {IR(29824, 23), 268}, // 259 GetKernelWorkGroupSize + {IR(29618, 18), 259}, // 260 GetMaxPipePackets + {IR(29600, 18), 258}, // 261 GetNumPipePackets + {IR(9043, 9), 353}, // 262 GraphARM + {IR(31641, 17), 351}, // 263 GraphConstantARM + {IR(31709, 12), 356}, // 264 GraphEndARM + {IR(31658, 19), 352}, // 265 GraphEntryPointARM + {IR(31677, 14), 354}, // 266 GraphInputARM + {IR(31691, 18), 355}, // 267 GraphSetOutputARM + {IR(29305, 9), 238}, // 268 GroupAll + {IR(29314, 9), 239}, // 269 GroupAny + {IR(29274, 15), 236}, // 270 GroupAsyncCopy + {IR(45356, 19), 810}, // 271 GroupBitwiseAndKHR + {IR(45375, 18), 811}, // 272 GroupBitwiseOrKHR + {IR(45393, 19), 812}, // 273 GroupBitwiseXorKHR + {IR(29323, 15), 240}, // 274 GroupBroadcast + {IR(29693, 20), 262}, // 275 GroupCommitReadPipe + {IR(29713, 21), 263}, // 276 GroupCommitWritePipe + {IR(26859, 14), 67}, // 277 GroupDecorate + {IR(29381, 10), 242}, // 278 GroupFAdd + {IR(33150, 23), 416}, // 279 GroupFAddNonUniformAMD + {IR(29421, 10), 246}, // 280 GroupFMax + {IR(33242, 23), 420}, // 281 GroupFMaxNonUniformAMD + {IR(29391, 10), 243}, // 282 GroupFMin + {IR(33173, 23), 417}, // 283 GroupFMinNonUniformAMD + {IR(45343, 13), 809}, // 284 GroupFMulKHR + {IR(29371, 10), 241}, // 285 GroupIAdd + {IR(33127, 23), 415}, // 286 GroupIAddNonUniformAMD + {IR(45330, 13), 808}, // 287 GroupIMulKHR + {IR(45412, 19), 813}, // 288 GroupLogicalAndKHR + {IR(45431, 18), 814}, // 289 GroupLogicalOrKHR + {IR(45449, 19), 815}, // 290 GroupLogicalXorKHR + {IR(26918, 20), 68}, // 291 GroupMemberDecorate + {IR(30674, 19), 307}, // 292 GroupNonUniformAll + {IR(30712, 24), 309}, // 293 GroupNonUniformAllEqual + {IR(30693, 19), 308}, // 294 GroupNonUniformAny + {IR(5662, 22), 312}, // 295 GroupNonUniformBallot + {IR(30852, 30), 315}, // 296 GroupNonUniformBallotBitCount + {IR(30820, 32), 314}, // 297 GroupNonUniformBallotBitExtract + {IR(30882, 29), 316}, // 298 GroupNonUniformBallotFindLSB + {IR(30911, 29), 317}, // 299 GroupNonUniformBallotFindMSB + {IR(31218, 26), 332}, // 300 GroupNonUniformBitwiseAnd + {IR(31244, 25), 333}, // 301 GroupNonUniformBitwiseOr + {IR(31269, 26), 334}, // 302 GroupNonUniformBitwiseXor + {IR(30736, 25), 310}, // 303 GroupNonUniformBroadcast + {IR(30761, 30), 311}, // 304 GroupNonUniformBroadcastFirst + {IR(30653, 21), 306}, // 305 GroupNonUniformElect + {IR(31038, 20), 323}, // 306 GroupNonUniformFAdd + {IR(31198, 20), 331}, // 307 GroupNonUniformFMax + {IR(31138, 20), 328}, // 308 GroupNonUniformFMin + {IR(31078, 20), 325}, // 309 GroupNonUniformFMul + {IR(31018, 20), 322}, // 310 GroupNonUniformIAdd + {IR(31058, 20), 324}, // 311 GroupNonUniformIMul + {IR(30791, 29), 313}, // 312 GroupNonUniformInverseBallot + {IR(31295, 26), 335}, // 313 GroupNonUniformLogicalAnd + {IR(31321, 25), 336}, // 314 GroupNonUniformLogicalOr + {IR(31346, 26), 337}, // 315 GroupNonUniformLogicalXor + {IR(34737, 27), 478}, // 316 GroupNonUniformPartitionNV + {IR(33557, 26), 434}, // 317 GroupNonUniformQuadAllKHR + {IR(33583, 26), 435}, // 318 GroupNonUniformQuadAnyKHR + {IR(31372, 29), 338}, // 319 GroupNonUniformQuadBroadcast + {IR(31401, 24), 339}, // 320 GroupNonUniformQuadSwap + {IR(13262, 25), 373}, // 321 GroupNonUniformRotateKHR + {IR(31158, 20), 329}, // 322 GroupNonUniformSMax + {IR(31098, 20), 326}, // 323 GroupNonUniformSMin + {IR(8752, 23), 318}, // 324 GroupNonUniformShuffle + {IR(30991, 27), 321}, // 325 GroupNonUniformShuffleDown + {IR(30966, 25), 320}, // 326 GroupNonUniformShuffleUp + {IR(30940, 26), 319}, // 327 GroupNonUniformShuffleXor + {IR(31178, 20), 330}, // 328 GroupNonUniformUMax + {IR(31118, 20), 327}, // 329 GroupNonUniformUMin + {IR(29636, 28), 260}, // 330 GroupReserveReadPipePackets + {IR(29664, 29), 261}, // 331 GroupReserveWritePipePackets + {IR(29441, 10), 248}, // 332 GroupSMax + {IR(33288, 23), 422}, // 333 GroupSMaxNonUniformAMD + {IR(29411, 10), 245}, // 334 GroupSMin + {IR(33219, 23), 419}, // 335 GroupSMinNonUniformAMD + {IR(29431, 10), 247}, // 336 GroupUMax + {IR(33265, 23), 421}, // 337 GroupUMaxNonUniformAMD + {IR(29401, 10), 244}, // 338 GroupUMin + {IR(33196, 23), 418}, // 339 GroupUMinNonUniformAMD + {IR(29289, 16), 237}, // 340 GroupWaitEvents + {IR(34044, 25), 451}, // 341 HitObjectExecuteShaderNV + {IR(34095, 25), 453}, // 342 HitObjectGetAttributesNV + {IR(35220, 24), 494}, // 343 HitObjectGetClusterIdNV + {IR(34069, 26), 452}, // 344 HitObjectGetCurrentTimeNV + {IR(34171, 28), 456}, // 345 HitObjectGetGeometryIndexNV + {IR(34120, 22), 454}, // 346 HitObjectGetHitKindNV + {IR(34224, 34), 458}, // 347 HitObjectGetInstanceCustomIndexNV + {IR(34199, 25), 457}, // 348 HitObjectGetInstanceIdNV + {IR(36447, 27), 536}, // 349 HitObjectGetLSSPositionsNV + {IR(36474, 23), 537}, // 350 HitObjectGetLSSRadiiNV + {IR(33756, 33), 441}, // 351 HitObjectGetObjectRayDirectionNV + {IR(33789, 30), 442}, // 352 HitObjectGetObjectRayOriginNV + {IR(33728, 28), 440}, // 353 HitObjectGetObjectToWorldNV + {IR(34142, 29), 455}, // 354 HitObjectGetPrimitiveIndexNV + {IR(34319, 22), 461}, // 355 HitObjectGetRayTMaxNV + {IR(34341, 22), 462}, // 356 HitObjectGetRayTMinNV + {IR(33884, 44), 445}, // 357 HitObjectGetShaderBindingTableRecordIndexNV + {IR(33845, 39), 444}, // 358 HitObjectGetShaderRecordBufferHandleNV + {IR(36391, 29), 534}, // 359 HitObjectGetSpherePositionNV + {IR(36420, 27), 535}, // 360 HitObjectGetSphereRadiusNV + {IR(34258, 32), 459}, // 361 HitObjectGetWorldRayDirectionNV + {IR(34290, 29), 460}, // 362 HitObjectGetWorldRayOriginNV + {IR(33700, 28), 439}, // 363 HitObjectGetWorldToObjectNV + {IR(34363, 19), 463}, // 364 HitObjectIsEmptyNV + {IR(34382, 17), 464}, // 365 HitObjectIsHitNV + {IR(36520, 20), 539}, // 366 HitObjectIsLSSHitNV + {IR(34399, 18), 465}, // 367 HitObjectIsMissNV + {IR(36497, 23), 538}, // 368 HitObjectIsSphereHitNV + {IR(33928, 23), 446}, // 369 HitObjectRecordEmptyNV + {IR(33609, 27), 436}, // 370 HitObjectRecordHitMotionNV + {IR(33971, 21), 448}, // 371 HitObjectRecordHitNV + {IR(33636, 36), 437}, // 372 HitObjectRecordHitWithIndexMotionNV + {IR(33992, 30), 449}, // 373 HitObjectRecordHitWithIndexNV + {IR(33672, 28), 438}, // 374 HitObjectRecordMissMotionNV + {IR(34022, 22), 450}, // 375 HitObjectRecordMissNV + {IR(33819, 26), 443}, // 376 HitObjectTraceRayMotionNV + {IR(33951, 20), 447}, // 377 HitObjectTraceRayNV + {IR(27755, 5), 117}, // 378 IAdd + {IR(27932, 10), 138}, // 379 IAddCarry + {IR(36899, 13), 556}, // 380 IAddSatINTEL + {IR(36925, 14), 558}, // 381 IAverageINTEL + {IR(36953, 21), 560}, // 382 IAverageRoundedINTEL + {IR(28128, 7), 158}, // 383 IEqual + {IR(27775, 5), 121}, // 384 IMul + {IR(37021, 15), 564}, // 385 IMul32x16INTEL + {IR(28135, 10), 159}, // 386 INotEqual + {IR(27765, 5), 119}, // 387 ISub + {IR(27942, 11), 139}, // 388 ISubBorrow + {IR(36995, 13), 562}, // 389 ISubSatINTEL + {IR(32173, 22), 380}, // 390 IgnoreIntersectionKHR + {IR(34962, 21), 485}, // 391 IgnoreIntersectionNV + {IR(24610, 6), 91}, // 392 Image + {IR(33020, 29), 411}, // 393 ImageBlockMatchGatherSADQCOM + {IR(32991, 29), 410}, // 394 ImageBlockMatchGatherSSDQCOM + {IR(32893, 23), 406}, // 395 ImageBlockMatchSADQCOM + {IR(32870, 23), 405}, // 396 ImageBlockMatchSSDQCOM + {IR(32962, 29), 409}, // 397 ImageBlockMatchWindowSADQCOM + {IR(32933, 29), 408}, // 398 ImageBlockMatchWindowSSDQCOM + {IR(32851, 19), 404}, // 399 ImageBoxFilterQCOM + {IR(27373, 16), 88}, // 400 ImageDrefGather + {IR(27350, 11), 86}, // 401 ImageFetch + {IR(27361, 12), 87}, // 402 ImageGather + {IR(27410, 17), 92}, // 403 ImageQueryFormat + {IR(27490, 17), 97}, // 404 ImageQueryLevels + {IR(27476, 14), 96}, // 405 ImageQueryLod + {IR(27427, 16), 93}, // 406 ImageQueryOrder + {IR(27507, 18), 98}, // 407 ImageQuerySamples + {IR(27461, 15), 95}, // 408 ImageQuerySize + {IR(27443, 18), 94}, // 409 ImageQuerySizeLod + {IR(27389, 10), 89}, // 410 ImageRead + {IR(27207, 27), 81}, // 411 ImageSampleDrefExplicitLod + {IR(27180, 27), 80}, // 412 ImageSampleDrefImplicitLod + {IR(27157, 23), 79}, // 413 ImageSampleExplicitLod + {IR(34486, 23), 469}, // 414 ImageSampleFootprintNV + {IR(27111, 23), 78}, // 415 ImageSampleImplicitLod + {IR(27319, 31), 85}, // 416 ImageSampleProjDrefExplicitLod + {IR(27288, 31), 84}, // 417 ImageSampleProjDrefImplicitLod + {IR(27261, 27), 83}, // 418 ImageSampleProjExplicitLod + {IR(27234, 27), 82}, // 419 ImageSampleProjImplicitLod + {IR(32827, 24), 403}, // 420 ImageSampleWeightedQCOM + {IR(30314, 22), 288}, // 421 ImageSparseDrefGather + {IR(30279, 17), 286}, // 422 ImageSparseFetch + {IR(30296, 18), 287}, // 423 ImageSparseGather + {IR(30406, 16), 293}, // 424 ImageSparseRead + {IR(30106, 33), 281}, // 425 ImageSparseSampleDrefExplicitLod + {IR(30073, 33), 280}, // 426 ImageSparseSampleDrefImplicitLod + {IR(30044, 29), 279}, // 427 ImageSparseSampleExplicitLod + {IR(30015, 29), 278}, // 428 ImageSparseSampleImplicitLod + {IR(30242, 37), 285}, // 429 ImageSparseSampleProjDrefExplicitLod + {IR(30205, 37), 284}, // 430 ImageSparseSampleProjDrefImplicitLod + {IR(30172, 33), 283}, // 431 ImageSparseSampleProjExplicitLod + {IR(30139, 33), 282}, // 432 ImageSparseSampleProjImplicitLod + {IR(30336, 26), 289}, // 433 ImageSparseTexelsResident + {IR(26590, 18), 53}, // 434 ImageTexelPointer + {IR(27399, 11), 90}, // 435 ImageWrite + {IR(26698, 20), 59}, // 436 InBoundsAccessChain + {IR(26768, 23), 63}, // 437 InBoundsPtrAccessChain + {IR(27999, 9), 146}, // 438 IsFinite + {IR(35882, 22), 517}, // 439 IsHelperInvocationEXT + {IR(27993, 6), 145}, // 440 IsInf + {IR(27987, 6), 144}, // 441 IsNan + {IR(33492, 23), 431}, // 442 IsNodePayloadValidAMDX + {IR(28008, 9), 147}, // 443 IsNormal + {IR(29928, 13), 273}, // 444 IsValidEvent + {IR(29583, 17), 257}, // 445 IsValidReserveId + {IR(29211, 5), 230}, // 446 Kill + {IR(29128, 6), 226}, // 447 Label + {IR(28028, 14), 149}, // 448 LessOrGreater + {IR(29247, 14), 234}, // 449 LifetimeStart + {IR(29261, 13), 235}, // 450 LifetimeStop + {IR(25441, 5), 8}, // 451 Line + {IR(26648, 5), 54}, // 452 Load + {IR(28099, 11), 155}, // 453 LogicalAnd + {IR(28060, 13), 152}, // 454 LogicalEqual + {IR(28110, 11), 156}, // 455 LogicalNot + {IR(28073, 16), 153}, // 456 LogicalNotEqual + {IR(28089, 10), 154}, // 457 LogicalOr + {IR(43469, 17), 739}, // 458 LoopControlINTEL + {IR(29068, 10), 224}, // 459 LoopMerge + {IR(45486, 18), 817}, // 460 MaskedGatherINTEL + {IR(45504, 19), 818}, // 461 MaskedScatterINTEL + {IR(27897, 18), 135}, // 462 MatrixTimesMatrix + {IR(27843, 18), 132}, // 463 MatrixTimesScalar + {IR(27879, 18), 134}, // 464 MatrixTimesVector + {IR(26828, 15), 65}, // 465 MemberDecorate + {IR(37221, 21), 576}, // 466 MemberDecorateString + {IR(37242, 27), 576}, // 467 MemberDecorateStringGOOGLE + {IR(25423, 11), 6}, // 468 MemberName + {IR(28805, 14), 206}, // 469 MemoryBarrier + {IR(25588, 12), 12}, // 470 MemoryModel + {IR(30591, 19), 302}, // 471 MemoryNamedBarrier + {IR(30610, 16), 303}, // 472 ModuleProcessed + {IR(25418, 5), 5}, // 473 Name + {IR(30568, 23), 301}, // 474 NamedBarrierInitialize + {IR(30362, 7), 290}, // 475 NoLine + {IR(33465, 27), 430}, // 476 NodePayloadArrayLengthAMDX + {IR(25214, 4), 0}, // 477 Nop + {IR(28539, 4), 186}, // 478 Not + {IR(28042, 8), 150}, // 479 Ordered + {IR(27915, 13), 136}, // 480 OuterProduct + {IR(29034, 4), 223}, // 481 Phi + {IR(26718, 15), 60}, // 482 PtrAccessChain + {IR(43722, 29), 754}, // 483 PtrCastToCrossWorkgroupINTEL + {IR(27672, 17), 111}, // 484 PtrCastToGeneric + {IR(31458, 8), 343}, // 485 PtrDiff + {IR(31437, 9), 341}, // 486 PtrEqual + {IR(31446, 12), 342}, // 487 PtrNotEqual + {IR(27600, 14), 106}, // 488 QuantizeToF16 + {IR(36187, 17), 528}, // 489 RawAccessChainNV + {IR(32746, 31), 400}, // 490 RayQueryConfirmIntersectionKHR + {IR(32714, 32), 399}, // 491 RayQueryGenerateIntersectionKHR + {IR(35197, 23), 493}, // 492 RayQueryGetClusterIdNV + {IR(44127, 39), 767}, // 493 RayQueryGetIntersectionBarycentricsKHR + {IR(44202, 46), 769}, // 494 RayQueryGetIntersectionCandidateAABBOpaqueKHR + {IR(35162, 35), 493}, // 495 RayQueryGetIntersectionClusterIdNV + {IR(44166, 36), 768}, // 496 RayQueryGetIntersectionFrontFaceKHR + {IR(44046, 40), 765}, // 497 RayQueryGetIntersectionGeometryIndexKHR + {IR(43898, 46), 762}, // 498 RayQueryGetIntersectionInstanceCustomIndexKHR + {IR(43944, 37), 763}, // 499 RayQueryGetIntersectionInstanceIdKHR + {IR(43981, 65), 764}, // 500 RayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR + {IR(36354, 37), 533}, // 501 RayQueryGetIntersectionLSSHitValueNV + {IR(36282, 38), 531}, // 502 RayQueryGetIntersectionLSSPositionsNV + {IR(36320, 34), 532}, // 503 RayQueryGetIntersectionLSSRadiiNV + {IR(44248, 45), 770}, // 504 RayQueryGetIntersectionObjectRayDirectionKHR + {IR(44293, 42), 771}, // 505 RayQueryGetIntersectionObjectRayOriginKHR + {IR(44396, 40), 774}, // 506 RayQueryGetIntersectionObjectToWorldKHR + {IR(44086, 41), 766}, // 507 RayQueryGetIntersectionPrimitiveIndexKHR + {IR(36204, 40), 529}, // 508 RayQueryGetIntersectionSpherePositionNV + {IR(36244, 38), 530}, // 509 RayQueryGetIntersectionSphereRadiusNV + {IR(43870, 28), 761}, // 510 RayQueryGetIntersectionTKHR + {IR(35037, 50), 490}, // 511 RayQueryGetIntersectionTriangleVertexPositionsKHR + {IR(32796, 31), 402}, // 512 RayQueryGetIntersectionTypeKHR + {IR(44436, 40), 775}, // 513 RayQueryGetIntersectionWorldToObjectKHR + {IR(43847, 23), 760}, // 514 RayQueryGetRayFlagsKHR + {IR(43825, 22), 759}, // 515 RayQueryGetRayTMinKHR + {IR(44335, 32), 772}, // 516 RayQueryGetWorldRayDirectionKHR + {IR(44367, 29), 773}, // 517 RayQueryGetWorldRayOriginKHR + {IR(32671, 22), 397}, // 518 RayQueryInitializeKHR + {IR(36562, 19), 541}, // 519 RayQueryIsLSSHitNV + {IR(36540, 22), 540}, // 520 RayQueryIsSphereHitNV + {IR(32777, 19), 401}, // 521 RayQueryProceedKHR + {IR(32693, 21), 398}, // 522 RayQueryTerminateKHR + {IR(33349, 13), 425}, // 523 ReadClockKHR + {IR(29451, 9), 249}, // 524 ReadPipe + {IR(43780, 22), 756}, // 525 ReadPipeBlockingINTEL + {IR(29899, 13), 271}, // 526 ReleaseEvent + {IR(34446, 24), 467}, // 527 ReorderThreadWithHintNV + {IR(34417, 29), 466}, // 528 ReorderThreadWithHitObjectNV + {IR(34919, 22), 484}, // 529 ReportIntersectionKHR + {IR(34941, 21), 484}, // 530 ReportIntersectionNV + {IR(29505, 23), 253}, // 531 ReserveReadPipePackets + {IR(29528, 24), 254}, // 532 ReserveWritePipePackets + {IR(29470, 17), 251}, // 533 ReservedReadPipe + {IR(29487, 18), 252}, // 534 ReservedWritePipe + {IR(42451, 19), 697}, // 535 RestoreMemoryINTEL + {IR(29887, 12), 270}, // 536 RetainEvent + {IR(29216, 7), 231}, // 537 Return + {IR(29223, 12), 232}, // 538 ReturnValue + {IR(45468, 18), 816}, // 539 RoundFToTF32INTEL + {IR(27582, 9), 104}, // 540 SConvert + {IR(27790, 5), 124}, // 541 SDiv + {IR(32258, 5), 382}, // 542 SDot + {IR(32299, 11), 385}, // 543 SDotAccSat + {IR(32310, 14), 385}, // 544 SDotAccSatKHR + {IR(32263, 8), 382}, // 545 SDotKHR + {IR(28158, 13), 161}, // 546 SGreaterThan + {IR(28189, 18), 163}, // 547 SGreaterThanEqual + {IR(28217, 10), 165}, // 548 SLessThan + {IR(28242, 15), 167}, // 549 SLessThanEqual + {IR(27810, 5), 128}, // 550 SMod + {IR(27966, 13), 141}, // 551 SMulExtended + {IR(27739, 8), 115}, // 552 SNegate + {IR(27805, 5), 127}, // 553 SRem + {IR(32284, 6), 384}, // 554 SUDot + {IR(32349, 12), 387}, // 555 SUDotAccSat + {IR(32361, 15), 387}, // 556 SUDotAccSatKHR + {IR(32290, 9), 384}, // 557 SUDotKHR + {IR(27066, 13), 77}, // 558 SampledImage + {IR(36106, 29), 527}, // 559 SamplerImageAddressingModeNV + {IR(27628, 15), 108}, // 560 SatConvertSToU + {IR(27643, 15), 109}, // 561 SatConvertUToS + {IR(42435, 16), 696}, // 562 SaveMemoryINTEL + {IR(28121, 7), 157}, // 563 Select + {IR(29113, 15), 225}, // 564 SelectionMerge + {IR(34719, 18), 477}, // 565 SetMeshOutputsEXT + {IR(29941, 19), 274}, // 566 SetUserEventStatus + {IR(28490, 17), 182}, // 567 ShiftLeftLogical + {IR(28469, 21), 181}, // 568 ShiftRightArithmetic + {IR(28451, 18), 180}, // 569 ShiftRightLogical + {IR(28017, 11), 148}, // 570 SignBitSet + {IR(30422, 7), 294}, // 571 SizeOf + {IR(25395, 7), 3}, // 572 Source + {IR(25276, 16), 2}, // 573 SourceContinued + {IR(25402, 16), 4}, // 574 SourceExtension + {IR(26413, 13), 45}, // 575 SpecConstant + {IR(45206, 30), 805}, // 576 SpecConstantArchitectureINTEL + {IR(45273, 30), 806}, // 577 SpecConstantCapabilitiesINTEL + {IR(26426, 22), 46}, // 578 SpecConstantComposite + {IR(44570, 36), 780}, // 579 SpecConstantCompositeContinuedINTEL + {IR(32590, 34), 394}, // 580 SpecConstantCompositeReplicateEXT + {IR(26395, 18), 44}, // 581 SpecConstantFalse + {IR(26489, 15), 47}, // 582 SpecConstantOp + {IR(33534, 23), 433}, // 583 SpecConstantStringAMDX + {IR(45182, 24), 804}, // 584 SpecConstantTargetINTEL + {IR(26378, 17), 43}, // 585 SpecConstantTrue + {IR(31512, 25), 346}, // 586 StencilAttachmentReadEXT + {IR(26653, 6), 55}, // 587 Store + {IR(25434, 7), 7}, // 588 String + {IR(44871, 25), 793}, // 589 Subgroup2DBlockLoadINTEL + {IR(44896, 34), 794}, // 590 Subgroup2DBlockLoadTransformINTEL + {IR(44930, 34), 795}, // 591 Subgroup2DBlockLoadTransposeINTEL + {IR(44964, 29), 796}, // 592 Subgroup2DBlockPrefetchINTEL + {IR(44993, 26), 797}, // 593 Subgroup2DBlockStoreINTEL + {IR(32010, 20), 372}, // 594 SubgroupAllEqualKHR + {IR(31980, 15), 370}, // 595 SubgroupAllKHR + {IR(31995, 15), 371}, // 596 SubgroupAnyKHR + {IR(40953, 30), 660}, // 597 SubgroupAvcBmeInitializeINTEL + {IR(40923, 30), 659}, // 598 SubgroupAvcFmeInitializeINTEL + {IR(39358, 35), 629}, // 599 SubgroupAvcImeAdjustRefOffsetINTEL + {IR(39393, 39), 630}, // 600 SubgroupAvcImeConvertToMcePayloadINTEL + {IR(40034, 38), 643}, // 601 SubgroupAvcImeConvertToMceResultINTEL + {IR(39657, 45), 636}, // 602 SubgroupAvcImeEvaluateWithDualReferenceINTEL + {IR(39757, 53), 638}, // 603 SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL + {IR(39978, 56), 642}, // 604 SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL + {IR(39866, 54), 640}, // 605 SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL + {IR(39610, 47), 635}, // 606 SubgroupAvcImeEvaluateWithSingleReferenceINTEL + {IR(39702, 55), 637}, // 607 SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL + {IR(39920, 58), 641}, // 608 SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL + {IR(39810, 56), 639}, // 609 SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL + {IR(40666, 36), 654}, // 610 SubgroupAvcImeGetBorderReachedINTEL + {IR(40118, 44), 645}, // 611 SubgroupAvcImeGetDualReferenceStreaminINTEL + {IR(40072, 46), 644}, // 612 SubgroupAvcImeGetSingleReferenceStreaminINTEL + {IR(40533, 66), 652}, // 613 SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL + {IR(40465, 68), 651}, // 614 SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL + {IR(40599, 67), 653}, // 615 SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL + {IR(40328, 68), 649}, // 616 SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL + {IR(40258, 70), 648}, // 617 SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL + {IR(40396, 69), 650}, // 618 SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL + {IR(40702, 48), 655}, // 619 SubgroupAvcImeGetTruncatedSearchIndicationINTEL + {IR(40750, 59), 656}, // 620 SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL + {IR(40867, 56), 658}, // 621 SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL + {IR(40809, 58), 657}, // 622 SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL + {IR(39221, 30), 625}, // 623 SubgroupAvcImeInitializeINTEL + {IR(39325, 33), 628}, // 624 SubgroupAvcImeRefWindowSizeINTEL + {IR(39289, 36), 627}, // 625 SubgroupAvcImeSetDualReferenceINTEL + {IR(39522, 54), 633}, // 626 SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL + {IR(39432, 43), 631}, // 627 SubgroupAvcImeSetMaxMotionVectorCountINTEL + {IR(39251, 38), 626}, // 628 SubgroupAvcImeSetSingleReferenceINTEL + {IR(39475, 47), 632}, // 629 SubgroupAvcImeSetUnidirectionalMixDisableINTEL + {IR(39576, 34), 634}, // 630 SubgroupAvcImeSetWeightedSadINTEL + {IR(40211, 47), 647}, // 631 SubgroupAvcImeStripDualReferenceStreamoutINTEL + {IR(40162, 49), 646}, // 632 SubgroupAvcImeStripSingleReferenceStreamoutINTEL + {IR(38611, 39), 610}, // 633 SubgroupAvcMceConvertToImePayloadINTEL + {IR(38650, 38), 611}, // 634 SubgroupAvcMceConvertToImeResultINTEL + {IR(38688, 39), 612}, // 635 SubgroupAvcMceConvertToRefPayloadINTEL + {IR(38727, 38), 613}, // 636 SubgroupAvcMceConvertToRefResultINTEL + {IR(38765, 39), 614}, // 637 SubgroupAvcMceConvertToSicPayloadINTEL + {IR(38804, 38), 615}, // 638 SubgroupAvcMceConvertToSicResultINTEL + {IR(38917, 43), 618}, // 639 SubgroupAvcMceGetBestInterDistortionsINTEL + {IR(38049, 50), 599}, // 640 SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL + {IR(37647, 60), 591}, // 641 SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL + {IR(37847, 51), 595}, // 642 SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL + {IR(37993, 56), 598}, // 643 SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL + {IR(37760, 47), 593}, // 644 SubgroupAvcMceGetDefaultInterShapePenaltyINTEL + {IR(38348, 56), 605}, // 645 SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL + {IR(38247, 50), 603}, // 646 SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL + {IR(37942, 51), 597}, // 647 SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL + {IR(38151, 49), 601}, // 648 SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL + {IR(38099, 52), 600}, // 649 SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL + {IR(38297, 51), 604}, // 650 SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL + {IR(39036, 38), 621}, // 651 SubgroupAvcMceGetInterDirectionsINTEL + {IR(38878, 39), 617}, // 652 SubgroupAvcMceGetInterDistortionsINTEL + {IR(38960, 38), 619}, // 653 SubgroupAvcMceGetInterMajorShapeINTEL + {IR(38998, 38), 620}, // 654 SubgroupAvcMceGetInterMinorShapeINTEL + {IR(39074, 45), 622}, // 655 SubgroupAvcMceGetInterMotionVectorCountINTEL + {IR(39119, 40), 623}, // 656 SubgroupAvcMceGetInterReferenceIdsINTEL + {IR(39159, 62), 624}, // 657 SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL + {IR(38842, 36), 616}, // 658 SubgroupAvcMceGetMotionVectorsINTEL + {IR(38404, 33), 606}, // 659 SubgroupAvcMceSetAcOnlyHaarINTEL + {IR(38550, 61), 609}, // 660 SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL + {IR(37707, 53), 592}, // 661 SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL + {IR(37898, 44), 596}, // 662 SubgroupAvcMceSetInterDirectionPenaltyINTEL + {IR(37807, 40), 594}, // 663 SubgroupAvcMceSetInterShapePenaltyINTEL + {IR(38200, 47), 602}, // 664 SubgroupAvcMceSetMotionVectorCostFunctionINTEL + {IR(38489, 61), 608}, // 665 SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL + {IR(38437, 52), 607}, // 666 SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL + {IR(40983, 39), 661}, // 667 SubgroupAvcRefConvertToMcePayloadINTEL + {IR(41305, 38), 668}, // 668 SubgroupAvcRefConvertToMceResultINTEL + {IR(41158, 45), 665}, // 669 SubgroupAvcRefEvaluateWithDualReferenceINTEL + {IR(41203, 46), 666}, // 670 SubgroupAvcRefEvaluateWithMultiReferenceINTEL + {IR(41249, 56), 667}, // 671 SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL + {IR(41111, 47), 664}, // 672 SubgroupAvcRefEvaluateWithSingleReferenceINTEL + {IR(41022, 46), 662}, // 673 SubgroupAvcRefSetBidirectionalMixDisableINTEL + {IR(41068, 43), 663}, // 674 SubgroupAvcRefSetBilinearFilterEnableINTEL + {IR(41441, 42), 672}, // 675 SubgroupAvcSicConfigureIpeLumaChromaINTEL + {IR(41405, 36), 671}, // 676 SubgroupAvcSicConfigureIpeLumaINTEL + {IR(41373, 32), 670}, // 677 SubgroupAvcSicConfigureSkcINTEL + {IR(41522, 39), 674}, // 678 SubgroupAvcSicConvertToMcePayloadINTEL + {IR(42062, 38), 686}, // 679 SubgroupAvcSicConvertToMceResultINTEL + {IR(41837, 31), 681}, // 680 SubgroupAvcSicEvaluateIpeINTEL + {IR(41915, 45), 683}, // 681 SubgroupAvcSicEvaluateWithDualReferenceINTEL + {IR(41960, 46), 684}, // 682 SubgroupAvcSicEvaluateWithMultiReferenceINTEL + {IR(42006, 56), 685}, // 683 SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL + {IR(41868, 47), 682}, // 684 SubgroupAvcSicEvaluateWithSingleReferenceINTEL + {IR(42179, 46), 689}, // 685 SubgroupAvcSicGetBestIpeChromaDistortionINTEL + {IR(42135, 44), 688}, // 686 SubgroupAvcSicGetBestIpeLumaDistortionINTEL + {IR(42400, 35), 694}, // 687 SubgroupAvcSicGetInterRawSadsINTEL + {IR(42266, 36), 691}, // 688 SubgroupAvcSicGetIpeChromaModeINTEL + {IR(42100, 35), 687}, // 689 SubgroupAvcSicGetIpeLumaShapeINTEL + {IR(41483, 39), 673}, // 690 SubgroupAvcSicGetMotionVectorMaskINTEL + {IR(42225, 41), 690}, // 691 SubgroupAvcSicGetPackedIpeLumaModesINTEL + {IR(42302, 50), 692}, // 692 SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL + {IR(42352, 48), 693}, // 693 SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL + {IR(41343, 30), 669}, // 694 SubgroupAvcSicInitializeINTEL + {IR(41703, 43), 678}, // 695 SubgroupAvcSicSetBilinearFilterEnableINTEL + {IR(41794, 43), 680}, // 696 SubgroupAvcSicSetBlockBasedRawSkipSadINTEL + {IR(41653, 50), 677}, // 697 SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL + {IR(41605, 48), 676}, // 698 SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL + {IR(41561, 44), 675}, // 699 SubgroupAvcSicSetIntraLumaShapePenaltyINTEL + {IR(41746, 48), 679}, // 700 SubgroupAvcSicSetSkcForwardTransformEnableINTEL + {IR(5423, 18), 363}, // 701 SubgroupBallotKHR + {IR(44844, 27), 792}, // 702 SubgroupBlockPrefetchINTEL + {IR(36653, 23), 546}, // 703 SubgroupBlockReadINTEL + {IR(36676, 24), 547}, // 704 SubgroupBlockWriteINTEL + {IR(31847, 27), 364}, // 705 SubgroupFirstInvocationKHR + {IR(36700, 28), 548}, // 706 SubgroupImageBlockReadINTEL + {IR(36728, 29), 549}, // 707 SubgroupImageBlockWriteINTEL + {IR(36757, 33), 550}, // 708 SubgroupImageMediaBlockReadINTEL + {IR(36790, 34), 551}, // 709 SubgroupImageMediaBlockWriteINTEL + {IR(13814, 38), 798}, // 710 SubgroupMatrixMultiplyAccumulateINTEL + {IR(32030, 26), 374}, // 711 SubgroupReadInvocationKHR + {IR(36581, 25), 543}, // 712 SubgroupShuffleDownINTEL + {IR(12022, 21), 542}, // 713 SubgroupShuffleINTEL + {IR(36606, 23), 544}, // 714 SubgroupShuffleUpINTEL + {IR(36629, 24), 545}, // 715 SubgroupShuffleXorINTEL + {IR(29204, 7), 229}, // 716 Switch + {IR(44753, 23), 788}, // 717 TaskSequenceAsyncINTEL + {IR(44729, 24), 787}, // 718 TaskSequenceCreateINTEL + {IR(44776, 21), 789}, // 719 TaskSequenceGetINTEL + {IR(44797, 25), 790}, // 720 TaskSequenceReleaseINTEL + {IR(35924, 27), 519}, // 721 TensorLayoutSetBlockSizeNV + {IR(35788, 28), 512}, // 722 TensorLayoutSetClampValueNV + {IR(35717, 27), 509}, // 723 TensorLayoutSetDimensionNV + {IR(35744, 24), 510}, // 724 TensorLayoutSetStrideNV + {IR(35768, 20), 511}, // 725 TensorLayoutSliceNV + {IR(31622, 19), 350}, // 726 TensorQuerySizeARM + {IR(31593, 14), 348}, // 727 TensorReadARM + {IR(35904, 20), 518}, // 728 TensorViewSetClipNV + {IR(35835, 25), 514}, // 729 TensorViewSetDimensionNV + {IR(35860, 22), 515}, // 730 TensorViewSetStrideNV + {IR(31607, 15), 349}, // 731 TensorWriteARM + {IR(31734, 20), 358}, // 732 TerminateInvocation + {IR(32195, 16), 381}, // 733 TerminateRayKHR + {IR(34983, 15), 486}, // 734 TerminateRayNV + {IR(35006, 14), 488}, // 735 TraceMotionNV + {IR(34998, 8), 487}, // 736 TraceNV + {IR(32107, 12), 377}, // 737 TraceRayKHR + {IR(35020, 17), 489}, // 738 TraceRayMotionNV + {IR(27056, 10), 76}, // 739 Transpose + {IR(35087, 29), 491}, // 740 TypeAccelerationStructureKHR + {IR(35116, 28), 491}, // 741 TypeAccelerationStructureNV + {IR(26005, 10), 25}, // 742 TypeArray + {IR(37566, 37), 588}, // 743 TypeAvcImeDualReferenceStreaminINTEL + {IR(37301, 23), 579}, // 744 TypeAvcImePayloadINTEL + {IR(37483, 44), 586}, // 745 TypeAvcImeResultDualReferenceStreamoutINTEL + {IR(37415, 22), 584}, // 746 TypeAvcImeResultINTEL + {IR(37437, 46), 585}, // 747 TypeAvcImeResultSingleReferenceStreamoutINTEL + {IR(37527, 39), 587}, // 748 TypeAvcImeSingleReferenceStreaminINTEL + {IR(37370, 23), 582}, // 749 TypeAvcMcePayloadINTEL + {IR(37393, 22), 583}, // 750 TypeAvcMceResultINTEL + {IR(37324, 23), 580}, // 751 TypeAvcRefPayloadINTEL + {IR(37603, 22), 589}, // 752 TypeAvcRefResultINTEL + {IR(37347, 23), 581}, // 753 TypeAvcSicPayloadINTEL + {IR(37625, 22), 590}, // 754 TypeAvcSicResultINTEL + {IR(25767, 9), 17}, // 755 TypeBool + {IR(44490, 23), 777}, // 756 TypeBufferSurfaceINTEL + {IR(32376, 25), 388}, // 757 TypeCooperativeMatrixKHR + {IR(35244, 24), 495}, // 758 TypeCooperativeMatrixNV + {IR(34509, 24), 470}, // 759 TypeCooperativeVectorNV + {IR(26120, 16), 32}, // 760 TypeDeviceEvent + {IR(26110, 10), 31}, // 761 TypeEvent + {IR(25821, 10), 19}, // 762 TypeFloat + {IR(26169, 19), 36}, // 763 TypeForwardPointer + {IR(26097, 13), 30}, // 764 TypeFunction + {IR(31721, 13), 357}, // 765 TypeGraphARM + {IR(34470, 16), 468}, // 766 TypeHitObjectNV + {IR(25966, 10), 22}, // 767 TypeImage + {IR(25776, 8), 18}, // 768 TypeInt + {IR(25842, 11), 21}, // 769 TypeMatrix + {IR(30551, 17), 300}, // 770 TypeNamedBarrier + {IR(33411, 25), 428}, // 771 TypeNodePayloadArrayAMDX + {IR(26043, 11), 28}, // 772 TypeOpaque + {IR(26160, 9), 35}, // 773 TypePipe + {IR(30429, 16), 295}, // 774 TypePipeStorage + {IR(26085, 12), 29}, // 775 TypePointer + {IR(26150, 10), 34}, // 776 TypeQueue + {IR(32655, 16), 396}, // 777 TypeRayQueryKHR + {IR(26136, 14), 33}, // 778 TypeReserveId + {IR(26015, 17), 26}, // 779 TypeRuntimeArray + {IR(25988, 17), 24}, // 780 TypeSampledImage + {IR(25976, 12), 23}, // 781 TypeSampler + {IR(26032, 11), 27}, // 782 TypeStruct + {IR(44513, 25), 778}, // 783 TypeStructContinuedINTEL + {IR(44822, 22), 791}, // 784 TypeTaskSequenceINTEL + {IR(31537, 14), 347}, // 785 TypeTensorARM + {IR(35660, 19), 506}, // 786 TypeTensorLayoutNV + {IR(35679, 17), 507}, // 787 TypeTensorViewNV + {IR(31754, 22), 359}, // 788 TypeUntypedPointerKHR + {IR(25831, 11), 20}, // 789 TypeVector + {IR(37283, 18), 578}, // 790 TypeVmeImageINTEL + {IR(25758, 9), 16}, // 791 TypeVoid + {IR(36912, 13), 557}, // 792 UAddSatINTEL + {IR(36939, 14), 559}, // 793 UAverageINTEL + {IR(36974, 21), 561}, // 794 UAverageRoundedINTEL + {IR(27573, 9), 103}, // 795 UConvert + {IR(36824, 24), 552}, // 796 UCountLeadingZerosINTEL + {IR(36848, 25), 553}, // 797 UCountTrailingZerosINTEL + {IR(27785, 5), 123}, // 798 UDiv + {IR(32271, 5), 383}, // 799 UDot + {IR(32324, 11), 386}, // 800 UDotAccSat + {IR(32335, 14), 386}, // 801 UDotAccSatKHR + {IR(32276, 8), 383}, // 802 UDotKHR + {IR(28145, 13), 160}, // 803 UGreaterThan + {IR(28171, 18), 162}, // 804 UGreaterThanEqual + {IR(28207, 10), 164}, // 805 ULessThan + {IR(28227, 15), 166}, // 806 ULessThanEqual + {IR(27800, 5), 126}, // 807 UMod + {IR(37036, 15), 565}, // 808 UMul32x16INTEL + {IR(27953, 13), 140}, // 809 UMulExtended + {IR(37008, 13), 563}, // 810 USubSatINTEL + {IR(25270, 6), 1}, // 811 Undef + {IR(28050, 10), 151}, // 812 Unordered + {IR(29235, 12), 233}, // 813 Unreachable + {IR(31795, 22), 361}, // 814 UntypedAccessChainKHR + {IR(31932, 22), 367}, // 815 UntypedArrayLengthKHR + {IR(32082, 25), 376}, // 816 UntypedGroupAsyncCopyKHR + {IR(31817, 30), 362}, // 817 UntypedInBoundsAccessChainKHR + {IR(31899, 33), 366}, // 818 UntypedInBoundsPtrAccessChainKHR + {IR(31954, 19), 368}, // 819 UntypedPrefetchKHR + {IR(31874, 25), 365}, // 820 UntypedPtrAccessChainKHR + {IR(31776, 19), 360}, // 821 UntypedVariableKHR + {IR(13880, 32), 800}, // 822 UntypedVariableLengthArrayINTEL + {IR(26581, 9), 52}, // 823 Variable + {IR(12478, 25), 695}, // 824 VariableLengthArrayINTEL + {IR(26938, 21), 69}, // 825 VectorExtractDynamic + {IR(26959, 20), 70}, // 826 VectorInsertDynamic + {IR(26979, 14), 71}, // 827 VectorShuffle + {IR(27861, 18), 133}, // 828 VectorTimesMatrix + {IR(27825, 18), 131}, // 829 VectorTimesScalar + {IR(37269, 14), 577}, // 830 VmeImageINTEL + {IR(34764, 33), 479}, // 831 WritePackedPrimitiveIndices4x8NV + {IR(29460, 10), 250}, // 832 WritePipe + {IR(43802, 23), 757}, // 833 WritePipeBlockingINTEL }}; // Extended instruction descriptions, ordered by (extinst enum, opcode value). @@ -4636,431 +4703,431 @@ static const std::array kInstructionNames{{ // name, a character-counting IndexRange into kStrings // capabilities, an IndexRange into kCapabilitySpans static const std::array kExtInstByValue{{ - {0,IR(0, 0),IR(44894, 14),IR(1, 0)}, // DebugInfoNone in debuginfo - {1,IR(52, 3),IR(44908, 21),IR(1, 0)}, // DebugCompilationUnit in debuginfo - {2,IR(727, 3),IR(44981, 15),IR(1, 0)}, // DebugTypeBasic in debuginfo - {3,IR(730, 3),IR(45030, 17),IR(1, 0)}, // DebugTypePointer in debuginfo - {4,IR(733, 2),IR(45085, 19),IR(1, 0)}, // DebugTypeQualifier in debuginfo - {5,IR(168, 2),IR(45104, 15),IR(1, 0)}, // DebugTypeArray in debuginfo - {6,IR(261, 2),IR(45119, 16),IR(1, 0)}, // DebugTypeVector in debuginfo - {7,IR(735, 6),IR(45135, 13),IR(1, 0)}, // DebugTypedef in debuginfo - {8,IR(168, 2),IR(45148, 18),IR(1, 0)}, // DebugTypeFunction in debuginfo - {9,IR(741, 9),IR(45166, 14),IR(1, 0)}, // DebugTypeEnum in debuginfo - {10,IR(750, 9),IR(45218, 19),IR(1, 0)}, // DebugTypeComposite in debuginfo - {11,IR(759, 10),IR(45237, 16),IR(1, 0)}, // DebugTypeMember in debuginfo - {12,IR(769, 5),IR(45253, 21),IR(1, 0)}, // DebugTypeInheritance in debuginfo - {13,IR(36, 2),IR(45274, 21),IR(1, 0)}, // DebugTypePtrToMember in debuginfo - {14,IR(168, 2),IR(45295, 18),IR(1, 0)}, // DebugTypeTemplate in debuginfo - {15,IR(774, 6),IR(45313, 27),IR(1, 0)}, // DebugTypeTemplateParameter in debuginfo - {16,IR(780, 5),IR(45340, 35),IR(1, 0)}, // DebugTypeTemplateTemplateParameter in debuginfo - {17,IR(785, 5),IR(45375, 31),IR(1, 0)}, // DebugTypeTemplateParameterPack in debuginfo - {18,IR(759, 10),IR(45406, 20),IR(1, 0)}, // DebugGlobalVariable in debuginfo - {19,IR(790, 8),IR(45426, 25),IR(1, 0)}, // DebugFunctionDeclaration in debuginfo - {20,IR(798, 11),IR(45451, 14),IR(1, 0)}, // DebugFunction in debuginfo - {21,IR(809, 5),IR(45465, 18),IR(1, 0)}, // DebugLexicalBlock in debuginfo - {22,IR(814, 3),IR(45483, 31),IR(1, 0)}, // DebugLexicalBlockDiscriminator in debuginfo - {23,IR(817, 2),IR(45514, 11),IR(1, 0)}, // DebugScope in debuginfo - {24,IR(0, 0),IR(45525, 13),IR(1, 0)}, // DebugNoScope in debuginfo - {25,IR(819, 3),IR(45538, 15),IR(1, 0)}, // DebugInlinedAt in debuginfo - {26,IR(822, 7),IR(45595, 19),IR(1, 0)}, // DebugLocalVariable in debuginfo - {27,IR(36, 2),IR(45614, 21),IR(1, 0)}, // DebugInlinedVariable in debuginfo - {28,IR(33, 3),IR(45635, 13),IR(1, 0)}, // DebugDeclare in debuginfo - {29,IR(829, 3),IR(45648, 11),IR(1, 0)}, // DebugValue in debuginfo - {30,IR(832, 2),IR(45692, 15),IR(1, 0)}, // DebugOperation in debuginfo - {31,IR(683, 1),IR(45707, 16),IR(1, 0)}, // DebugExpression in debuginfo - {32,IR(834, 4),IR(45723, 14),IR(1, 0)}, // DebugMacroDef in debuginfo - {33,IR(814, 3),IR(45737, 16),IR(1, 0)}, // DebugMacroUndef in debuginfo - {1,IR(10, 1),IR(45753, 6),IR(1, 0)}, // Round in glsl_std_450 - {2,IR(10, 1),IR(45759, 10),IR(1, 0)}, // RoundEven in glsl_std_450 - {3,IR(10, 1),IR(45769, 6),IR(1, 0)}, // Trunc in glsl_std_450 - {4,IR(10, 1),IR(45775, 5),IR(1, 0)}, // FAbs in glsl_std_450 - {5,IR(10, 1),IR(45780, 5),IR(1, 0)}, // SAbs in glsl_std_450 - {6,IR(10, 1),IR(45785, 6),IR(1, 0)}, // FSign in glsl_std_450 - {7,IR(10, 1),IR(45791, 6),IR(1, 0)}, // SSign in glsl_std_450 - {8,IR(10, 1),IR(45797, 6),IR(1, 0)}, // Floor in glsl_std_450 - {9,IR(10, 1),IR(45803, 5),IR(1, 0)}, // Ceil in glsl_std_450 - {10,IR(10, 1),IR(45808, 6),IR(1, 0)}, // Fract in glsl_std_450 - {11,IR(10, 1),IR(45814, 8),IR(1, 0)}, // Radians in glsl_std_450 - {12,IR(10, 1),IR(45822, 8),IR(1, 0)}, // Degrees in glsl_std_450 - {13,IR(10, 1),IR(45830, 4),IR(1, 0)}, // Sin in glsl_std_450 - {14,IR(10, 1),IR(45834, 4),IR(1, 0)}, // Cos in glsl_std_450 - {15,IR(10, 1),IR(45838, 4),IR(1, 0)}, // Tan in glsl_std_450 - {16,IR(10, 1),IR(45842, 5),IR(1, 0)}, // Asin in glsl_std_450 - {17,IR(10, 1),IR(45847, 5),IR(1, 0)}, // Acos in glsl_std_450 - {18,IR(10, 1),IR(45852, 5),IR(1, 0)}, // Atan in glsl_std_450 - {19,IR(10, 1),IR(45857, 5),IR(1, 0)}, // Sinh in glsl_std_450 - {20,IR(10, 1),IR(45862, 5),IR(1, 0)}, // Cosh in glsl_std_450 - {21,IR(10, 1),IR(45867, 5),IR(1, 0)}, // Tanh in glsl_std_450 - {22,IR(10, 1),IR(45872, 6),IR(1, 0)}, // Asinh in glsl_std_450 - {23,IR(10, 1),IR(45878, 6),IR(1, 0)}, // Acosh in glsl_std_450 - {24,IR(10, 1),IR(45884, 6),IR(1, 0)}, // Atanh in glsl_std_450 - {25,IR(36, 2),IR(45890, 6),IR(1, 0)}, // Atan2 in glsl_std_450 - {26,IR(36, 2),IR(45896, 4),IR(1, 0)}, // Pow in glsl_std_450 - {27,IR(10, 1),IR(45900, 4),IR(1, 0)}, // Exp in glsl_std_450 - {28,IR(10, 1),IR(45904, 4),IR(1, 0)}, // Log in glsl_std_450 - {29,IR(10, 1),IR(45908, 5),IR(1, 0)}, // Exp2 in glsl_std_450 - {30,IR(10, 1),IR(45913, 5),IR(1, 0)}, // Log2 in glsl_std_450 - {31,IR(10, 1),IR(45918, 5),IR(1, 0)}, // Sqrt in glsl_std_450 - {32,IR(10, 1),IR(45923, 12),IR(1, 0)}, // InverseSqrt in glsl_std_450 - {33,IR(10, 1),IR(45935, 12),IR(1, 0)}, // Determinant in glsl_std_450 - {34,IR(10, 1),IR(45947, 14),IR(1, 0)}, // MatrixInverse in glsl_std_450 - {35,IR(36, 2),IR(45961, 5),IR(1, 0)}, // Modf in glsl_std_450 - {36,IR(10, 1),IR(45966, 11),IR(1, 0)}, // ModfStruct in glsl_std_450 - {37,IR(36, 2),IR(45977, 5),IR(1, 0)}, // FMin in glsl_std_450 - {38,IR(36, 2),IR(45982, 5),IR(1, 0)}, // UMin in glsl_std_450 - {39,IR(36, 2),IR(45987, 5),IR(1, 0)}, // SMin in glsl_std_450 - {40,IR(36, 2),IR(45992, 5),IR(1, 0)}, // FMax in glsl_std_450 - {41,IR(36, 2),IR(45997, 5),IR(1, 0)}, // UMax in glsl_std_450 - {42,IR(36, 2),IR(46002, 5),IR(1, 0)}, // SMax in glsl_std_450 - {43,IR(33, 3),IR(46007, 7),IR(1, 0)}, // FClamp in glsl_std_450 - {44,IR(33, 3),IR(46014, 7),IR(1, 0)}, // UClamp in glsl_std_450 - {45,IR(33, 3),IR(46021, 7),IR(1, 0)}, // SClamp in glsl_std_450 - {46,IR(33, 3),IR(46028, 5),IR(1, 0)}, // FMix in glsl_std_450 - {47,IR(33, 3),IR(46033, 5),IR(1, 0)}, // IMix in glsl_std_450 - {48,IR(36, 2),IR(46038, 5),IR(1, 0)}, // Step in glsl_std_450 - {49,IR(33, 3),IR(46043, 11),IR(1, 0)}, // SmoothStep in glsl_std_450 - {50,IR(33, 3),IR(46054, 4),IR(1, 0)}, // Fma in glsl_std_450 - {51,IR(36, 2),IR(46058, 6),IR(1, 0)}, // Frexp in glsl_std_450 - {52,IR(10, 1),IR(46064, 12),IR(1, 0)}, // FrexpStruct in glsl_std_450 - {53,IR(36, 2),IR(46076, 6),IR(1, 0)}, // Ldexp in glsl_std_450 - {54,IR(10, 1),IR(46082, 13),IR(1, 0)}, // PackSnorm4x8 in glsl_std_450 - {55,IR(10, 1),IR(46095, 13),IR(1, 0)}, // PackUnorm4x8 in glsl_std_450 - {56,IR(10, 1),IR(46108, 14),IR(1, 0)}, // PackSnorm2x16 in glsl_std_450 - {57,IR(10, 1),IR(46122, 14),IR(1, 0)}, // PackUnorm2x16 in glsl_std_450 - {58,IR(10, 1),IR(46136, 13),IR(1, 0)}, // PackHalf2x16 in glsl_std_450 - {59,IR(10, 1),IR(46149, 15),IR(302, 1)}, // PackDouble2x32 in glsl_std_450 - {60,IR(10, 1),IR(46164, 16),IR(1, 0)}, // UnpackSnorm2x16 in glsl_std_450 - {61,IR(10, 1),IR(46180, 16),IR(1, 0)}, // UnpackUnorm2x16 in glsl_std_450 - {62,IR(10, 1),IR(46196, 15),IR(1, 0)}, // UnpackHalf2x16 in glsl_std_450 - {63,IR(10, 1),IR(46211, 15),IR(1, 0)}, // UnpackSnorm4x8 in glsl_std_450 - {64,IR(10, 1),IR(46226, 15),IR(1, 0)}, // UnpackUnorm4x8 in glsl_std_450 - {65,IR(10, 1),IR(46241, 17),IR(302, 1)}, // UnpackDouble2x32 in glsl_std_450 - {66,IR(10, 1),IR(46258, 7),IR(1, 0)}, // Length in glsl_std_450 - {67,IR(36, 2),IR(46265, 9),IR(1, 0)}, // Distance in glsl_std_450 - {68,IR(36, 2),IR(46274, 6),IR(1, 0)}, // Cross in glsl_std_450 - {69,IR(10, 1),IR(46280, 10),IR(1, 0)}, // Normalize in glsl_std_450 - {70,IR(33, 3),IR(46290, 12),IR(1, 0)}, // FaceForward in glsl_std_450 - {71,IR(36, 2),IR(46302, 8),IR(1, 0)}, // Reflect in glsl_std_450 - {72,IR(33, 3),IR(46310, 8),IR(1, 0)}, // Refract in glsl_std_450 - {73,IR(10, 1),IR(46318, 9),IR(1, 0)}, // FindILsb in glsl_std_450 - {74,IR(10, 1),IR(46327, 9),IR(1, 0)}, // FindSMsb in glsl_std_450 - {75,IR(10, 1),IR(46336, 9),IR(1, 0)}, // FindUMsb in glsl_std_450 - {76,IR(10, 1),IR(46345, 22),IR(303, 1)}, // InterpolateAtCentroid in glsl_std_450 - {77,IR(36, 2),IR(46367, 20),IR(303, 1)}, // InterpolateAtSample in glsl_std_450 - {78,IR(36, 2),IR(46387, 20),IR(303, 1)}, // InterpolateAtOffset in glsl_std_450 - {79,IR(36, 2),IR(46407, 5),IR(1, 0)}, // NMin in glsl_std_450 - {80,IR(36, 2),IR(46412, 5),IR(1, 0)}, // NMax in glsl_std_450 - {81,IR(33, 3),IR(46417, 7),IR(1, 0)}, // NClamp in glsl_std_450 - {1,IR(387, 5),IR(4549, 7),IR(1, 0)}, // Kernel in nonsemantic_clspvreflection - {2,IR(838, 5),IR(46424, 13),IR(1, 0)}, // ArgumentInfo in nonsemantic_clspvreflection - {3,IR(843, 5),IR(46437, 22),IR(1, 0)}, // ArgumentStorageBuffer in nonsemantic_clspvreflection - {4,IR(843, 5),IR(46459, 16),IR(1, 0)}, // ArgumentUniform in nonsemantic_clspvreflection - {5,IR(531, 7),IR(46475, 25),IR(1, 0)}, // ArgumentPodStorageBuffer in nonsemantic_clspvreflection - {6,IR(531, 7),IR(46500, 19),IR(1, 0)}, // ArgumentPodUniform in nonsemantic_clspvreflection - {7,IR(843, 5),IR(46519, 24),IR(1, 0)}, // ArgumentPodPushConstant in nonsemantic_clspvreflection - {8,IR(843, 5),IR(46543, 21),IR(1, 0)}, // ArgumentSampledImage in nonsemantic_clspvreflection - {9,IR(843, 5),IR(46564, 21),IR(1, 0)}, // ArgumentStorageImage in nonsemantic_clspvreflection - {10,IR(843, 5),IR(46585, 16),IR(1, 0)}, // ArgumentSampler in nonsemantic_clspvreflection - {11,IR(843, 5),IR(46601, 18),IR(1, 0)}, // ArgumentWorkgroup in nonsemantic_clspvreflection - {12,IR(33, 3),IR(46619, 26),IR(1, 0)}, // SpecConstantWorkgroupSize in nonsemantic_clspvreflection - {13,IR(33, 3),IR(46645, 25),IR(1, 0)}, // SpecConstantGlobalOffset in nonsemantic_clspvreflection - {14,IR(10, 1),IR(46670, 20),IR(1, 0)}, // SpecConstantWorkDim in nonsemantic_clspvreflection - {15,IR(36, 2),IR(46690, 25),IR(1, 0)}, // PushConstantGlobalOffset in nonsemantic_clspvreflection - {16,IR(36, 2),IR(46715, 30),IR(1, 0)}, // PushConstantEnqueuedLocalSize in nonsemantic_clspvreflection - {17,IR(36, 2),IR(46745, 23),IR(1, 0)}, // PushConstantGlobalSize in nonsemantic_clspvreflection - {18,IR(36, 2),IR(46768, 25),IR(1, 0)}, // PushConstantRegionOffset in nonsemantic_clspvreflection - {19,IR(36, 2),IR(46793, 26),IR(1, 0)}, // PushConstantNumWorkgroups in nonsemantic_clspvreflection - {20,IR(36, 2),IR(46819, 30),IR(1, 0)}, // PushConstantRegionGroupOffset in nonsemantic_clspvreflection - {21,IR(33, 3),IR(46849, 26),IR(1, 0)}, // ConstantDataStorageBuffer in nonsemantic_clspvreflection - {22,IR(33, 3),IR(46875, 20),IR(1, 0)}, // ConstantDataUniform in nonsemantic_clspvreflection - {23,IR(33, 3),IR(7974, 15),IR(1, 0)}, // LiteralSampler in nonsemantic_clspvreflection - {24,IR(296, 4),IR(46895, 30),IR(1, 0)}, // PropertyRequiredWorkgroupSize in nonsemantic_clspvreflection - {25,IR(10, 1),IR(46925, 28),IR(1, 0)}, // SpecConstantSubgroupMaxSize in nonsemantic_clspvreflection - {26,IR(843, 5),IR(46953, 28),IR(1, 0)}, // ArgumentPointerPushConstant in nonsemantic_clspvreflection - {27,IR(531, 7),IR(46981, 23),IR(1, 0)}, // ArgumentPointerUniform in nonsemantic_clspvreflection - {28,IR(33, 3),IR(47004, 35),IR(1, 0)}, // ProgramScopeVariablesStorageBuffer in nonsemantic_clspvreflection - {29,IR(33, 3),IR(47039, 38),IR(1, 0)}, // ProgramScopeVariablePointerRelocation in nonsemantic_clspvreflection - {30,IR(296, 4),IR(47077, 42),IR(1, 0)}, // ImageArgumentInfoChannelOrderPushConstant in nonsemantic_clspvreflection - {31,IR(296, 4),IR(47119, 45),IR(1, 0)}, // ImageArgumentInfoChannelDataTypePushConstant in nonsemantic_clspvreflection - {32,IR(502, 6),IR(47164, 37),IR(1, 0)}, // ImageArgumentInfoChannelOrderUniform in nonsemantic_clspvreflection - {33,IR(502, 6),IR(47201, 40),IR(1, 0)}, // ImageArgumentInfoChannelDataTypeUniform in nonsemantic_clspvreflection - {34,IR(843, 5),IR(47241, 27),IR(1, 0)}, // ArgumentStorageTexelBuffer in nonsemantic_clspvreflection - {35,IR(843, 5),IR(47268, 27),IR(1, 0)}, // ArgumentUniformTexelBuffer in nonsemantic_clspvreflection - {36,IR(33, 3),IR(47295, 32),IR(1, 0)}, // ConstantDataPointerPushConstant in nonsemantic_clspvreflection - {37,IR(33, 3),IR(47327, 40),IR(1, 0)}, // ProgramScopeVariablePointerPushConstant in nonsemantic_clspvreflection - {38,IR(829, 3),IR(47367, 11),IR(1, 0)}, // PrintfInfo in nonsemantic_clspvreflection - {39,IR(33, 3),IR(47378, 26),IR(1, 0)}, // PrintfBufferStorageBuffer in nonsemantic_clspvreflection - {40,IR(33, 3),IR(47404, 32),IR(1, 0)}, // PrintfBufferPointerPushConstant in nonsemantic_clspvreflection - {41,IR(296, 4),IR(47436, 34),IR(1, 0)}, // NormalizedSamplerMaskPushConstant in nonsemantic_clspvreflection - {42,IR(36, 2),IR(47470, 22),IR(1, 0)}, // WorkgroupVariableSize in nonsemantic_clspvreflection - {0,IR(0, 0),IR(44894, 14),IR(1, 0)}, // DebugInfoNone in nonsemantic_shader_debuginfo_100 - {1,IR(296, 4),IR(44908, 21),IR(1, 0)}, // DebugCompilationUnit in nonsemantic_shader_debuginfo_100 - {2,IR(296, 4),IR(44981, 15),IR(1, 0)}, // DebugTypeBasic in nonsemantic_shader_debuginfo_100 - {3,IR(33, 3),IR(45030, 17),IR(1, 0)}, // DebugTypePointer in nonsemantic_shader_debuginfo_100 - {4,IR(36, 2),IR(45085, 19),IR(1, 0)}, // DebugTypeQualifier in nonsemantic_shader_debuginfo_100 - {5,IR(168, 2),IR(45104, 15),IR(1, 0)}, // DebugTypeArray in nonsemantic_shader_debuginfo_100 - {6,IR(36, 2),IR(45119, 16),IR(1, 0)}, // DebugTypeVector in nonsemantic_shader_debuginfo_100 - {7,IR(502, 6),IR(45135, 13),IR(1, 0)}, // DebugTypedef in nonsemantic_shader_debuginfo_100 - {8,IR(829, 3),IR(45148, 18),IR(1, 0)}, // DebugTypeFunction in nonsemantic_shader_debuginfo_100 - {9,IR(848, 9),IR(45166, 14),IR(1, 0)}, // DebugTypeEnum in nonsemantic_shader_debuginfo_100 - {10,IR(857, 10),IR(45218, 19),IR(1, 0)}, // DebugTypeComposite in nonsemantic_shader_debuginfo_100 - {11,IR(867, 9),IR(45237, 16),IR(1, 0)}, // DebugTypeMember in nonsemantic_shader_debuginfo_100 - {12,IR(296, 4),IR(45253, 21),IR(1, 0)}, // DebugTypeInheritance in nonsemantic_shader_debuginfo_100 - {13,IR(36, 2),IR(45274, 21),IR(1, 0)}, // DebugTypePtrToMember in nonsemantic_shader_debuginfo_100 - {14,IR(168, 2),IR(45295, 18),IR(1, 0)}, // DebugTypeTemplate in nonsemantic_shader_debuginfo_100 - {15,IR(502, 6),IR(45313, 27),IR(1, 0)}, // DebugTypeTemplateParameter in nonsemantic_shader_debuginfo_100 - {16,IR(611, 5),IR(45340, 35),IR(1, 0)}, // DebugTypeTemplateTemplateParameter in nonsemantic_shader_debuginfo_100 - {17,IR(876, 5),IR(45375, 31),IR(1, 0)}, // DebugTypeTemplateParameterPack in nonsemantic_shader_debuginfo_100 - {18,IR(881, 10),IR(45406, 20),IR(1, 0)}, // DebugGlobalVariable in nonsemantic_shader_debuginfo_100 - {19,IR(448, 8),IR(45426, 25),IR(1, 0)}, // DebugFunctionDeclaration in nonsemantic_shader_debuginfo_100 - {20,IR(881, 10),IR(45451, 14),IR(1, 0)}, // DebugFunction in nonsemantic_shader_debuginfo_100 - {21,IR(843, 5),IR(45465, 18),IR(1, 0)}, // DebugLexicalBlock in nonsemantic_shader_debuginfo_100 - {22,IR(33, 3),IR(45483, 31),IR(1, 0)}, // DebugLexicalBlockDiscriminator in nonsemantic_shader_debuginfo_100 - {23,IR(817, 2),IR(45514, 11),IR(1, 0)}, // DebugScope in nonsemantic_shader_debuginfo_100 - {24,IR(0, 0),IR(45525, 13),IR(1, 0)}, // DebugNoScope in nonsemantic_shader_debuginfo_100 - {25,IR(891, 3),IR(45538, 15),IR(1, 0)}, // DebugInlinedAt in nonsemantic_shader_debuginfo_100 - {26,IR(894, 8),IR(45595, 19),IR(1, 0)}, // DebugLocalVariable in nonsemantic_shader_debuginfo_100 - {27,IR(36, 2),IR(45614, 21),IR(1, 0)}, // DebugInlinedVariable in nonsemantic_shader_debuginfo_100 - {28,IR(902, 4),IR(45635, 13),IR(1, 0)}, // DebugDeclare in nonsemantic_shader_debuginfo_100 - {29,IR(902, 4),IR(45648, 11),IR(1, 0)}, // DebugValue in nonsemantic_shader_debuginfo_100 - {30,IR(168, 2),IR(45692, 15),IR(1, 0)}, // DebugOperation in nonsemantic_shader_debuginfo_100 - {31,IR(683, 1),IR(45707, 16),IR(1, 0)}, // DebugExpression in nonsemantic_shader_debuginfo_100 - {32,IR(554, 4),IR(45723, 14),IR(1, 0)}, // DebugMacroDef in nonsemantic_shader_debuginfo_100 - {33,IR(33, 3),IR(45737, 16),IR(1, 0)}, // DebugMacroUndef in nonsemantic_shader_debuginfo_100 - {34,IR(483, 7),IR(47492, 20),IR(1, 0)}, // DebugImportedEntity in nonsemantic_shader_debuginfo_100 - {35,IR(817, 2),IR(47512, 12),IR(1, 0)}, // DebugSource in nonsemantic_shader_debuginfo_100 - {101,IR(36, 2),IR(47524, 24),IR(1, 0)}, // DebugFunctionDefinition in nonsemantic_shader_debuginfo_100 - {102,IR(10, 1),IR(47548, 21),IR(1, 0)}, // DebugSourceContinued in nonsemantic_shader_debuginfo_100 - {103,IR(611, 5),IR(47569, 10),IR(1, 0)}, // DebugLine in nonsemantic_shader_debuginfo_100 - {104,IR(0, 0),IR(47579, 12),IR(1, 0)}, // DebugNoLine in nonsemantic_shader_debuginfo_100 - {105,IR(36, 2),IR(47591, 21),IR(1, 0)}, // DebugBuildIdentifier in nonsemantic_shader_debuginfo_100 - {106,IR(10, 1),IR(47612, 17),IR(1, 0)}, // DebugStoragePath in nonsemantic_shader_debuginfo_100 - {107,IR(296, 4),IR(47629, 16),IR(1, 0)}, // DebugEntryPoint in nonsemantic_shader_debuginfo_100 - {108,IR(33, 3),IR(47645, 16),IR(1, 0)}, // DebugTypeMatrix in nonsemantic_shader_debuginfo_100 - {1,IR(701, 9),IR(47661, 14),IR(1, 0)}, // Configuration in nonsemantic_vkspreflection - {2,IR(10, 1),IR(47675, 13),IR(1, 0)}, // StartCounter in nonsemantic_vkspreflection - {3,IR(10, 1),IR(47688, 12),IR(1, 0)}, // StopCounter in nonsemantic_vkspreflection - {4,IR(296, 4),IR(47700, 14),IR(1, 0)}, // PushConstants in nonsemantic_vkspreflection - {5,IR(33, 3),IR(47714, 23),IR(1, 0)}, // SpecializationMapEntry in nonsemantic_vkspreflection - {6,IR(906, 15),IR(47737, 20),IR(1, 0)}, // DescriptorSetBuffer in nonsemantic_vkspreflection - {7,IR(921, 33),IR(47757, 19),IR(1, 0)}, // DescriptorSetImage in nonsemantic_vkspreflection - {8,IR(954, 19),IR(47776, 21),IR(1, 0)}, // DescriptorSetSampler in nonsemantic_vkspreflection - {0,IR(0, 0),IR(44894, 14),IR(1, 0)}, // DebugInfoNone in opencl_debuginfo_100 - {1,IR(973, 4),IR(44908, 21),IR(1, 0)}, // DebugCompilationUnit in opencl_debuginfo_100 - {2,IR(977, 3),IR(44981, 15),IR(1, 0)}, // DebugTypeBasic in opencl_debuginfo_100 - {3,IR(980, 3),IR(45030, 17),IR(1, 0)}, // DebugTypePointer in opencl_debuginfo_100 - {4,IR(983, 2),IR(45085, 19),IR(1, 0)}, // DebugTypeQualifier in opencl_debuginfo_100 - {5,IR(168, 2),IR(45104, 15),IR(1, 0)}, // DebugTypeArray in opencl_debuginfo_100 - {6,IR(261, 2),IR(45119, 16),IR(1, 0)}, // DebugTypeVector in opencl_debuginfo_100 - {7,IR(735, 6),IR(45135, 13),IR(1, 0)}, // DebugTypedef in opencl_debuginfo_100 - {8,IR(985, 3),IR(45148, 18),IR(1, 0)}, // DebugTypeFunction in opencl_debuginfo_100 - {9,IR(988, 9),IR(45166, 14),IR(1, 0)}, // DebugTypeEnum in opencl_debuginfo_100 - {10,IR(997, 10),IR(45218, 19),IR(1, 0)}, // DebugTypeComposite in opencl_debuginfo_100 - {11,IR(1007, 10),IR(45237, 16),IR(1, 0)}, // DebugTypeMember in opencl_debuginfo_100 - {12,IR(1017, 5),IR(45253, 21),IR(1, 0)}, // DebugTypeInheritance in opencl_debuginfo_100 - {13,IR(36, 2),IR(45274, 21),IR(1, 0)}, // DebugTypePtrToMember in opencl_debuginfo_100 - {14,IR(168, 2),IR(45295, 18),IR(1, 0)}, // DebugTypeTemplate in opencl_debuginfo_100 - {15,IR(774, 6),IR(45313, 27),IR(1, 0)}, // DebugTypeTemplateParameter in opencl_debuginfo_100 - {16,IR(780, 5),IR(45340, 35),IR(1, 0)}, // DebugTypeTemplateTemplateParameter in opencl_debuginfo_100 - {17,IR(785, 5),IR(45375, 31),IR(1, 0)}, // DebugTypeTemplateParameterPack in opencl_debuginfo_100 - {18,IR(1007, 10),IR(45406, 20),IR(1, 0)}, // DebugGlobalVariable in opencl_debuginfo_100 - {19,IR(1022, 8),IR(45426, 25),IR(1, 0)}, // DebugFunctionDeclaration in opencl_debuginfo_100 - {20,IR(1030, 11),IR(45451, 14),IR(1, 0)}, // DebugFunction in opencl_debuginfo_100 - {21,IR(809, 5),IR(45465, 18),IR(1, 0)}, // DebugLexicalBlock in opencl_debuginfo_100 - {22,IR(814, 3),IR(45483, 31),IR(1, 0)}, // DebugLexicalBlockDiscriminator in opencl_debuginfo_100 - {23,IR(817, 2),IR(45514, 11),IR(1, 0)}, // DebugScope in opencl_debuginfo_100 - {24,IR(0, 0),IR(45525, 13),IR(1, 0)}, // DebugNoScope in opencl_debuginfo_100 - {25,IR(819, 3),IR(45538, 15),IR(1, 0)}, // DebugInlinedAt in opencl_debuginfo_100 - {26,IR(1041, 8),IR(45595, 19),IR(1, 0)}, // DebugLocalVariable in opencl_debuginfo_100 - {27,IR(36, 2),IR(45614, 21),IR(1, 0)}, // DebugInlinedVariable in opencl_debuginfo_100 - {28,IR(33, 3),IR(45635, 13),IR(1, 0)}, // DebugDeclare in opencl_debuginfo_100 - {29,IR(902, 4),IR(45648, 11),IR(1, 0)}, // DebugValue in opencl_debuginfo_100 - {30,IR(1049, 2),IR(45692, 15),IR(1, 0)}, // DebugOperation in opencl_debuginfo_100 - {31,IR(683, 1),IR(45707, 16),IR(1, 0)}, // DebugExpression in opencl_debuginfo_100 - {32,IR(834, 4),IR(45723, 14),IR(1, 0)}, // DebugMacroDef in opencl_debuginfo_100 - {33,IR(814, 3),IR(45737, 16),IR(1, 0)}, // DebugMacroUndef in opencl_debuginfo_100 - {34,IR(1051, 7),IR(47492, 20),IR(1, 0)}, // DebugImportedEntity in opencl_debuginfo_100 - {35,IR(817, 2),IR(47512, 12),IR(1, 0)}, // DebugSource in opencl_debuginfo_100 - {36,IR(1058, 8),IR(48097, 17),IR(1, 0)}, // DebugModuleINTEL in opencl_debuginfo_100 - {0,IR(10, 1),IR(48114, 5),IR(1, 0)}, // acos in opencl_std_100 - {1,IR(10, 1),IR(48119, 6),IR(1, 0)}, // acosh in opencl_std_100 - {2,IR(10, 1),IR(48125, 7),IR(1, 0)}, // acospi in opencl_std_100 - {3,IR(10, 1),IR(48132, 5),IR(1, 0)}, // asin in opencl_std_100 - {4,IR(10, 1),IR(48137, 6),IR(1, 0)}, // asinh in opencl_std_100 - {5,IR(10, 1),IR(48143, 7),IR(1, 0)}, // asinpi in opencl_std_100 - {6,IR(10, 1),IR(48150, 5),IR(1, 0)}, // atan in opencl_std_100 - {7,IR(36, 2),IR(48155, 6),IR(1, 0)}, // atan2 in opencl_std_100 - {8,IR(10, 1),IR(48161, 6),IR(1, 0)}, // atanh in opencl_std_100 - {9,IR(10, 1),IR(48167, 7),IR(1, 0)}, // atanpi in opencl_std_100 - {10,IR(36, 2),IR(48174, 8),IR(1, 0)}, // atan2pi in opencl_std_100 - {11,IR(10, 1),IR(48182, 5),IR(1, 0)}, // cbrt in opencl_std_100 - {12,IR(10, 1),IR(48187, 5),IR(1, 0)}, // ceil in opencl_std_100 - {13,IR(36, 2),IR(48192, 9),IR(1, 0)}, // copysign in opencl_std_100 - {14,IR(10, 1),IR(48201, 4),IR(1, 0)}, // cos in opencl_std_100 - {15,IR(10, 1),IR(48205, 5),IR(1, 0)}, // cosh in opencl_std_100 - {16,IR(10, 1),IR(48210, 6),IR(1, 0)}, // cospi in opencl_std_100 - {17,IR(10, 1),IR(48216, 5),IR(1, 0)}, // erfc in opencl_std_100 - {18,IR(10, 1),IR(48221, 4),IR(1, 0)}, // erf in opencl_std_100 - {19,IR(10, 1),IR(48225, 4),IR(1, 0)}, // exp in opencl_std_100 - {20,IR(10, 1),IR(48229, 5),IR(1, 0)}, // exp2 in opencl_std_100 - {21,IR(10, 1),IR(48234, 6),IR(1, 0)}, // exp10 in opencl_std_100 - {22,IR(10, 1),IR(48240, 6),IR(1, 0)}, // expm1 in opencl_std_100 - {23,IR(10, 1),IR(48246, 5),IR(1, 0)}, // fabs in opencl_std_100 - {24,IR(36, 2),IR(48251, 5),IR(1, 0)}, // fdim in opencl_std_100 - {25,IR(10, 1),IR(48256, 6),IR(1, 0)}, // floor in opencl_std_100 - {26,IR(33, 3),IR(48262, 4),IR(1, 0)}, // fma in opencl_std_100 - {27,IR(36, 2),IR(48266, 5),IR(1, 0)}, // fmax in opencl_std_100 - {28,IR(36, 2),IR(48271, 5),IR(1, 0)}, // fmin in opencl_std_100 - {29,IR(36, 2),IR(48276, 5),IR(1, 0)}, // fmod in opencl_std_100 - {30,IR(36, 2),IR(48281, 6),IR(1, 0)}, // fract in opencl_std_100 - {31,IR(36, 2),IR(48287, 6),IR(1, 0)}, // frexp in opencl_std_100 - {32,IR(36, 2),IR(48293, 6),IR(1, 0)}, // hypot in opencl_std_100 - {33,IR(10, 1),IR(48299, 6),IR(1, 0)}, // ilogb in opencl_std_100 - {34,IR(36, 2),IR(48305, 6),IR(1, 0)}, // ldexp in opencl_std_100 - {35,IR(10, 1),IR(48311, 7),IR(1, 0)}, // lgamma in opencl_std_100 - {36,IR(36, 2),IR(48318, 9),IR(1, 0)}, // lgamma_r in opencl_std_100 - {37,IR(10, 1),IR(48327, 4),IR(1, 0)}, // log in opencl_std_100 - {38,IR(10, 1),IR(48331, 5),IR(1, 0)}, // log2 in opencl_std_100 - {39,IR(10, 1),IR(48336, 6),IR(1, 0)}, // log10 in opencl_std_100 - {40,IR(10, 1),IR(48342, 6),IR(1, 0)}, // log1p in opencl_std_100 - {41,IR(10, 1),IR(48348, 5),IR(1, 0)}, // logb in opencl_std_100 - {42,IR(33, 3),IR(48353, 4),IR(1, 0)}, // mad in opencl_std_100 - {43,IR(36, 2),IR(48357, 7),IR(1, 0)}, // maxmag in opencl_std_100 - {44,IR(36, 2),IR(48364, 7),IR(1, 0)}, // minmag in opencl_std_100 - {45,IR(36, 2),IR(48371, 5),IR(1, 0)}, // modf in opencl_std_100 - {46,IR(10, 1),IR(48376, 4),IR(1, 0)}, // nan in opencl_std_100 - {47,IR(36, 2),IR(48380, 10),IR(1, 0)}, // nextafter in opencl_std_100 - {48,IR(36, 2),IR(48390, 4),IR(1, 0)}, // pow in opencl_std_100 - {49,IR(36, 2),IR(48394, 5),IR(1, 0)}, // pown in opencl_std_100 - {50,IR(36, 2),IR(48399, 5),IR(1, 0)}, // powr in opencl_std_100 - {51,IR(36, 2),IR(48404, 10),IR(1, 0)}, // remainder in opencl_std_100 - {52,IR(33, 3),IR(48414, 7),IR(1, 0)}, // remquo in opencl_std_100 - {53,IR(10, 1),IR(48421, 5),IR(1, 0)}, // rint in opencl_std_100 - {54,IR(36, 2),IR(48426, 6),IR(1, 0)}, // rootn in opencl_std_100 - {55,IR(10, 1),IR(48432, 6),IR(1, 0)}, // round in opencl_std_100 - {56,IR(10, 1),IR(48438, 6),IR(1, 0)}, // rsqrt in opencl_std_100 - {57,IR(10, 1),IR(48444, 4),IR(1, 0)}, // sin in opencl_std_100 - {58,IR(36, 2),IR(48448, 7),IR(1, 0)}, // sincos in opencl_std_100 - {59,IR(10, 1),IR(48455, 5),IR(1, 0)}, // sinh in opencl_std_100 - {60,IR(10, 1),IR(48460, 6),IR(1, 0)}, // sinpi in opencl_std_100 - {61,IR(10, 1),IR(48466, 5),IR(1, 0)}, // sqrt in opencl_std_100 - {62,IR(10, 1),IR(48471, 4),IR(1, 0)}, // tan in opencl_std_100 - {63,IR(10, 1),IR(48475, 5),IR(1, 0)}, // tanh in opencl_std_100 - {64,IR(10, 1),IR(48480, 6),IR(1, 0)}, // tanpi in opencl_std_100 - {65,IR(10, 1),IR(48486, 7),IR(1, 0)}, // tgamma in opencl_std_100 - {66,IR(10, 1),IR(48493, 6),IR(1, 0)}, // trunc in opencl_std_100 - {67,IR(10, 1),IR(48499, 9),IR(1, 0)}, // half_cos in opencl_std_100 - {68,IR(36, 2),IR(48508, 12),IR(1, 0)}, // half_divide in opencl_std_100 - {69,IR(10, 1),IR(48520, 9),IR(1, 0)}, // half_exp in opencl_std_100 - {70,IR(10, 1),IR(48529, 10),IR(1, 0)}, // half_exp2 in opencl_std_100 - {71,IR(10, 1),IR(48539, 11),IR(1, 0)}, // half_exp10 in opencl_std_100 - {72,IR(10, 1),IR(48550, 9),IR(1, 0)}, // half_log in opencl_std_100 - {73,IR(10, 1),IR(48559, 10),IR(1, 0)}, // half_log2 in opencl_std_100 - {74,IR(10, 1),IR(48569, 11),IR(1, 0)}, // half_log10 in opencl_std_100 - {75,IR(36, 2),IR(48580, 10),IR(1, 0)}, // half_powr in opencl_std_100 - {76,IR(10, 1),IR(48590, 11),IR(1, 0)}, // half_recip in opencl_std_100 - {77,IR(10, 1),IR(48601, 11),IR(1, 0)}, // half_rsqrt in opencl_std_100 - {78,IR(10, 1),IR(48612, 9),IR(1, 0)}, // half_sin in opencl_std_100 - {79,IR(10, 1),IR(48621, 10),IR(1, 0)}, // half_sqrt in opencl_std_100 - {80,IR(10, 1),IR(48631, 9),IR(1, 0)}, // half_tan in opencl_std_100 - {81,IR(10, 1),IR(48640, 11),IR(1, 0)}, // native_cos in opencl_std_100 - {82,IR(36, 2),IR(48651, 14),IR(1, 0)}, // native_divide in opencl_std_100 - {83,IR(10, 1),IR(48665, 11),IR(1, 0)}, // native_exp in opencl_std_100 - {84,IR(10, 1),IR(48676, 12),IR(1, 0)}, // native_exp2 in opencl_std_100 - {85,IR(10, 1),IR(48688, 13),IR(1, 0)}, // native_exp10 in opencl_std_100 - {86,IR(10, 1),IR(48701, 11),IR(1, 0)}, // native_log in opencl_std_100 - {87,IR(10, 1),IR(48712, 12),IR(1, 0)}, // native_log2 in opencl_std_100 - {88,IR(10, 1),IR(48724, 13),IR(1, 0)}, // native_log10 in opencl_std_100 - {89,IR(36, 2),IR(48737, 12),IR(1, 0)}, // native_powr in opencl_std_100 - {90,IR(10, 1),IR(48749, 13),IR(1, 0)}, // native_recip in opencl_std_100 - {91,IR(10, 1),IR(48762, 13),IR(1, 0)}, // native_rsqrt in opencl_std_100 - {92,IR(10, 1),IR(48775, 11),IR(1, 0)}, // native_sin in opencl_std_100 - {93,IR(10, 1),IR(48786, 12),IR(1, 0)}, // native_sqrt in opencl_std_100 - {94,IR(10, 1),IR(48798, 11),IR(1, 0)}, // native_tan in opencl_std_100 - {95,IR(33, 3),IR(48809, 7),IR(1, 0)}, // fclamp in opencl_std_100 - {96,IR(10, 1),IR(48816, 8),IR(1, 0)}, // degrees in opencl_std_100 - {97,IR(36, 2),IR(48824, 12),IR(1, 0)}, // fmax_common in opencl_std_100 - {98,IR(36, 2),IR(48836, 12),IR(1, 0)}, // fmin_common in opencl_std_100 - {99,IR(33, 3),IR(48848, 4),IR(1, 0)}, // mix in opencl_std_100 - {100,IR(10, 1),IR(48852, 8),IR(1, 0)}, // radians in opencl_std_100 - {101,IR(36, 2),IR(48860, 5),IR(1, 0)}, // step in opencl_std_100 - {102,IR(33, 3),IR(48865, 11),IR(1, 0)}, // smoothstep in opencl_std_100 - {103,IR(10, 1),IR(48876, 5),IR(1, 0)}, // sign in opencl_std_100 - {104,IR(36, 2),IR(48881, 6),IR(1, 0)}, // cross in opencl_std_100 - {105,IR(36, 2),IR(48887, 9),IR(1, 0)}, // distance in opencl_std_100 - {106,IR(10, 1),IR(48896, 7),IR(1, 0)}, // length in opencl_std_100 - {107,IR(10, 1),IR(48903, 10),IR(1, 0)}, // normalize in opencl_std_100 - {108,IR(36, 2),IR(48913, 14),IR(1, 0)}, // fast_distance in opencl_std_100 - {109,IR(10, 1),IR(48927, 12),IR(1, 0)}, // fast_length in opencl_std_100 - {110,IR(10, 1),IR(48939, 15),IR(1, 0)}, // fast_normalize in opencl_std_100 - {141,IR(10, 1),IR(48954, 6),IR(1, 0)}, // s_abs in opencl_std_100 - {142,IR(36, 2),IR(48960, 11),IR(1, 0)}, // s_abs_diff in opencl_std_100 - {143,IR(36, 2),IR(48971, 10),IR(1, 0)}, // s_add_sat in opencl_std_100 - {144,IR(36, 2),IR(48981, 10),IR(1, 0)}, // u_add_sat in opencl_std_100 - {145,IR(36, 2),IR(48991, 7),IR(1, 0)}, // s_hadd in opencl_std_100 - {146,IR(36, 2),IR(48998, 7),IR(1, 0)}, // u_hadd in opencl_std_100 - {147,IR(36, 2),IR(49005, 8),IR(1, 0)}, // s_rhadd in opencl_std_100 - {148,IR(36, 2),IR(49013, 8),IR(1, 0)}, // u_rhadd in opencl_std_100 - {149,IR(33, 3),IR(49021, 8),IR(1, 0)}, // s_clamp in opencl_std_100 - {150,IR(33, 3),IR(49029, 8),IR(1, 0)}, // u_clamp in opencl_std_100 - {151,IR(10, 1),IR(49037, 4),IR(1, 0)}, // clz in opencl_std_100 - {152,IR(10, 1),IR(49041, 4),IR(1, 0)}, // ctz in opencl_std_100 - {153,IR(33, 3),IR(49045, 9),IR(1, 0)}, // s_mad_hi in opencl_std_100 - {154,IR(33, 3),IR(49054, 10),IR(1, 0)}, // u_mad_sat in opencl_std_100 - {155,IR(33, 3),IR(49064, 10),IR(1, 0)}, // s_mad_sat in opencl_std_100 - {156,IR(36, 2),IR(49074, 6),IR(1, 0)}, // s_max in opencl_std_100 - {157,IR(36, 2),IR(49080, 6),IR(1, 0)}, // u_max in opencl_std_100 - {158,IR(36, 2),IR(49086, 6),IR(1, 0)}, // s_min in opencl_std_100 - {159,IR(36, 2),IR(49092, 6),IR(1, 0)}, // u_min in opencl_std_100 - {160,IR(36, 2),IR(49098, 9),IR(1, 0)}, // s_mul_hi in opencl_std_100 - {161,IR(36, 2),IR(49107, 7),IR(1, 0)}, // rotate in opencl_std_100 - {162,IR(36, 2),IR(49114, 10),IR(1, 0)}, // s_sub_sat in opencl_std_100 - {163,IR(36, 2),IR(49124, 10),IR(1, 0)}, // u_sub_sat in opencl_std_100 - {164,IR(36, 2),IR(49134, 11),IR(1, 0)}, // u_upsample in opencl_std_100 - {165,IR(36, 2),IR(49145, 11),IR(1, 0)}, // s_upsample in opencl_std_100 - {166,IR(10, 1),IR(49156, 9),IR(1, 0)}, // popcount in opencl_std_100 - {167,IR(33, 3),IR(49165, 8),IR(1, 0)}, // s_mad24 in opencl_std_100 - {168,IR(33, 3),IR(49173, 8),IR(1, 0)}, // u_mad24 in opencl_std_100 - {169,IR(36, 2),IR(49181, 8),IR(1, 0)}, // s_mul24 in opencl_std_100 - {170,IR(36, 2),IR(49189, 8),IR(1, 0)}, // u_mul24 in opencl_std_100 - {171,IR(1066, 3),IR(49197, 7),IR(1, 0)}, // vloadn in opencl_std_100 - {172,IR(33, 3),IR(49204, 8),IR(1, 0)}, // vstoren in opencl_std_100 - {173,IR(36, 2),IR(49212, 11),IR(1, 0)}, // vload_half in opencl_std_100 - {174,IR(1066, 3),IR(49223, 12),IR(1, 0)}, // vload_halfn in opencl_std_100 - {175,IR(33, 3),IR(49235, 12),IR(1, 0)}, // vstore_half in opencl_std_100 - {176,IR(1069, 4),IR(49247, 14),IR(1, 0)}, // vstore_half_r in opencl_std_100 - {177,IR(33, 3),IR(49261, 13),IR(1, 0)}, // vstore_halfn in opencl_std_100 - {178,IR(1069, 4),IR(49274, 15),IR(1, 0)}, // vstore_halfn_r in opencl_std_100 - {179,IR(1066, 3),IR(49289, 13),IR(1, 0)}, // vloada_halfn in opencl_std_100 - {180,IR(33, 3),IR(49302, 14),IR(1, 0)}, // vstorea_halfn in opencl_std_100 - {181,IR(1069, 4),IR(49316, 16),IR(1, 0)}, // vstorea_halfn_r in opencl_std_100 - {182,IR(36, 2),IR(49332, 8),IR(1, 0)}, // shuffle in opencl_std_100 - {183,IR(33, 3),IR(49340, 9),IR(1, 0)}, // shuffle2 in opencl_std_100 - {184,IR(168, 2),IR(49349, 7),IR(1, 0)}, // printf in opencl_std_100 - {185,IR(36, 2),IR(49356, 9),IR(1, 0)}, // prefetch in opencl_std_100 - {186,IR(33, 3),IR(49365, 10),IR(1, 0)}, // bitselect in opencl_std_100 - {187,IR(33, 3),IR(49375, 7),IR(1, 0)}, // select in opencl_std_100 - {201,IR(10, 1),IR(49382, 6),IR(1, 0)}, // u_abs in opencl_std_100 - {202,IR(36, 2),IR(49388, 11),IR(1, 0)}, // u_abs_diff in opencl_std_100 - {203,IR(36, 2),IR(49399, 9),IR(1, 0)}, // u_mul_hi in opencl_std_100 - {204,IR(33, 3),IR(49408, 9),IR(1, 0)}, // u_mad_hi in opencl_std_100 - {1,IR(10, 1),IR(49417, 17),IR(1, 0)}, // CubeFaceIndexAMD in spv_amd_gcn_shader - {2,IR(10, 1),IR(49434, 17),IR(1, 0)}, // CubeFaceCoordAMD in spv_amd_gcn_shader - {3,IR(0, 0),IR(49451, 8),IR(1, 0)}, // TimeAMD in spv_amd_gcn_shader - {1,IR(36, 2),IR(49459, 22),IR(1, 0)}, // SwizzleInvocationsAMD in spv_amd_shader_ballot - {2,IR(36, 2),IR(49481, 28),IR(1, 0)}, // SwizzleInvocationsMaskedAMD in spv_amd_shader_ballot - {3,IR(33, 3),IR(49509, 19),IR(1, 0)}, // WriteInvocationAMD in spv_amd_shader_ballot - {4,IR(10, 1),IR(49528, 9),IR(1, 0)}, // MbcntAMD in spv_amd_shader_ballot - {1,IR(36, 2),IR(49537, 23),IR(1, 0)}, // InterpolateAtVertexAMD in spv_amd_shader_explicit_vertex_parameter - {1,IR(33, 3),IR(49560, 9),IR(1, 0)}, // FMin3AMD in spv_amd_shader_trinary_minmax - {2,IR(33, 3),IR(49569, 9),IR(1, 0)}, // UMin3AMD in spv_amd_shader_trinary_minmax - {3,IR(33, 3),IR(49578, 9),IR(1, 0)}, // SMin3AMD in spv_amd_shader_trinary_minmax - {4,IR(33, 3),IR(49587, 9),IR(1, 0)}, // FMax3AMD in spv_amd_shader_trinary_minmax - {5,IR(33, 3),IR(49596, 9),IR(1, 0)}, // UMax3AMD in spv_amd_shader_trinary_minmax - {6,IR(33, 3),IR(49605, 9),IR(1, 0)}, // SMax3AMD in spv_amd_shader_trinary_minmax - {7,IR(33, 3),IR(49614, 9),IR(1, 0)}, // FMid3AMD in spv_amd_shader_trinary_minmax - {8,IR(33, 3),IR(49623, 9),IR(1, 0)}, // UMid3AMD in spv_amd_shader_trinary_minmax - {9,IR(33, 3),IR(49632, 9),IR(1, 0)}, // SMid3AMD in spv_amd_shader_trinary_minmax + {0,IR(0, 0),IR(45610, 14),IR(1, 0)}, // DebugInfoNone in debuginfo + {1,IR(52, 3),IR(45624, 21),IR(1, 0)}, // DebugCompilationUnit in debuginfo + {2,IR(770, 3),IR(45697, 15),IR(1, 0)}, // DebugTypeBasic in debuginfo + {3,IR(773, 3),IR(45746, 17),IR(1, 0)}, // DebugTypePointer in debuginfo + {4,IR(776, 2),IR(45801, 19),IR(1, 0)}, // DebugTypeQualifier in debuginfo + {5,IR(168, 2),IR(45820, 15),IR(1, 0)}, // DebugTypeArray in debuginfo + {6,IR(261, 2),IR(45835, 16),IR(1, 0)}, // DebugTypeVector in debuginfo + {7,IR(778, 6),IR(45851, 13),IR(1, 0)}, // DebugTypedef in debuginfo + {8,IR(168, 2),IR(45864, 18),IR(1, 0)}, // DebugTypeFunction in debuginfo + {9,IR(784, 9),IR(45882, 14),IR(1, 0)}, // DebugTypeEnum in debuginfo + {10,IR(793, 9),IR(45934, 19),IR(1, 0)}, // DebugTypeComposite in debuginfo + {11,IR(802, 10),IR(45953, 16),IR(1, 0)}, // DebugTypeMember in debuginfo + {12,IR(812, 5),IR(45969, 21),IR(1, 0)}, // DebugTypeInheritance in debuginfo + {13,IR(36, 2),IR(45990, 21),IR(1, 0)}, // DebugTypePtrToMember in debuginfo + {14,IR(168, 2),IR(46011, 18),IR(1, 0)}, // DebugTypeTemplate in debuginfo + {15,IR(817, 6),IR(46029, 27),IR(1, 0)}, // DebugTypeTemplateParameter in debuginfo + {16,IR(823, 5),IR(46056, 35),IR(1, 0)}, // DebugTypeTemplateTemplateParameter in debuginfo + {17,IR(828, 5),IR(46091, 31),IR(1, 0)}, // DebugTypeTemplateParameterPack in debuginfo + {18,IR(802, 10),IR(46122, 20),IR(1, 0)}, // DebugGlobalVariable in debuginfo + {19,IR(833, 8),IR(46142, 25),IR(1, 0)}, // DebugFunctionDeclaration in debuginfo + {20,IR(841, 11),IR(46167, 14),IR(1, 0)}, // DebugFunction in debuginfo + {21,IR(852, 5),IR(46181, 18),IR(1, 0)}, // DebugLexicalBlock in debuginfo + {22,IR(857, 3),IR(46199, 31),IR(1, 0)}, // DebugLexicalBlockDiscriminator in debuginfo + {23,IR(860, 2),IR(46230, 11),IR(1, 0)}, // DebugScope in debuginfo + {24,IR(0, 0),IR(46241, 13),IR(1, 0)}, // DebugNoScope in debuginfo + {25,IR(862, 3),IR(46254, 15),IR(1, 0)}, // DebugInlinedAt in debuginfo + {26,IR(865, 7),IR(46311, 19),IR(1, 0)}, // DebugLocalVariable in debuginfo + {27,IR(36, 2),IR(46330, 21),IR(1, 0)}, // DebugInlinedVariable in debuginfo + {28,IR(33, 3),IR(46351, 13),IR(1, 0)}, // DebugDeclare in debuginfo + {29,IR(375, 3),IR(46364, 11),IR(1, 0)}, // DebugValue in debuginfo + {30,IR(872, 2),IR(46408, 15),IR(1, 0)}, // DebugOperation in debuginfo + {31,IR(706, 1),IR(46423, 16),IR(1, 0)}, // DebugExpression in debuginfo + {32,IR(874, 4),IR(46439, 14),IR(1, 0)}, // DebugMacroDef in debuginfo + {33,IR(857, 3),IR(46453, 16),IR(1, 0)}, // DebugMacroUndef in debuginfo + {1,IR(10, 1),IR(46469, 6),IR(1, 0)}, // Round in glsl_std_450 + {2,IR(10, 1),IR(46475, 10),IR(1, 0)}, // RoundEven in glsl_std_450 + {3,IR(10, 1),IR(46485, 6),IR(1, 0)}, // Trunc in glsl_std_450 + {4,IR(10, 1),IR(46491, 5),IR(1, 0)}, // FAbs in glsl_std_450 + {5,IR(10, 1),IR(46496, 5),IR(1, 0)}, // SAbs in glsl_std_450 + {6,IR(10, 1),IR(46501, 6),IR(1, 0)}, // FSign in glsl_std_450 + {7,IR(10, 1),IR(46507, 6),IR(1, 0)}, // SSign in glsl_std_450 + {8,IR(10, 1),IR(46513, 6),IR(1, 0)}, // Floor in glsl_std_450 + {9,IR(10, 1),IR(46519, 5),IR(1, 0)}, // Ceil in glsl_std_450 + {10,IR(10, 1),IR(46524, 6),IR(1, 0)}, // Fract in glsl_std_450 + {11,IR(10, 1),IR(46530, 8),IR(1, 0)}, // Radians in glsl_std_450 + {12,IR(10, 1),IR(46538, 8),IR(1, 0)}, // Degrees in glsl_std_450 + {13,IR(10, 1),IR(46546, 4),IR(1, 0)}, // Sin in glsl_std_450 + {14,IR(10, 1),IR(46550, 4),IR(1, 0)}, // Cos in glsl_std_450 + {15,IR(10, 1),IR(46554, 4),IR(1, 0)}, // Tan in glsl_std_450 + {16,IR(10, 1),IR(46558, 5),IR(1, 0)}, // Asin in glsl_std_450 + {17,IR(10, 1),IR(46563, 5),IR(1, 0)}, // Acos in glsl_std_450 + {18,IR(10, 1),IR(46568, 5),IR(1, 0)}, // Atan in glsl_std_450 + {19,IR(10, 1),IR(46573, 5),IR(1, 0)}, // Sinh in glsl_std_450 + {20,IR(10, 1),IR(46578, 5),IR(1, 0)}, // Cosh in glsl_std_450 + {21,IR(10, 1),IR(46583, 5),IR(1, 0)}, // Tanh in glsl_std_450 + {22,IR(10, 1),IR(46588, 6),IR(1, 0)}, // Asinh in glsl_std_450 + {23,IR(10, 1),IR(46594, 6),IR(1, 0)}, // Acosh in glsl_std_450 + {24,IR(10, 1),IR(46600, 6),IR(1, 0)}, // Atanh in glsl_std_450 + {25,IR(36, 2),IR(46606, 6),IR(1, 0)}, // Atan2 in glsl_std_450 + {26,IR(36, 2),IR(46612, 4),IR(1, 0)}, // Pow in glsl_std_450 + {27,IR(10, 1),IR(46616, 4),IR(1, 0)}, // Exp in glsl_std_450 + {28,IR(10, 1),IR(46620, 4),IR(1, 0)}, // Log in glsl_std_450 + {29,IR(10, 1),IR(46624, 5),IR(1, 0)}, // Exp2 in glsl_std_450 + {30,IR(10, 1),IR(46629, 5),IR(1, 0)}, // Log2 in glsl_std_450 + {31,IR(10, 1),IR(46634, 5),IR(1, 0)}, // Sqrt in glsl_std_450 + {32,IR(10, 1),IR(46639, 12),IR(1, 0)}, // InverseSqrt in glsl_std_450 + {33,IR(10, 1),IR(46651, 12),IR(1, 0)}, // Determinant in glsl_std_450 + {34,IR(10, 1),IR(46663, 14),IR(1, 0)}, // MatrixInverse in glsl_std_450 + {35,IR(36, 2),IR(46677, 5),IR(1, 0)}, // Modf in glsl_std_450 + {36,IR(10, 1),IR(46682, 11),IR(1, 0)}, // ModfStruct in glsl_std_450 + {37,IR(36, 2),IR(46693, 5),IR(1, 0)}, // FMin in glsl_std_450 + {38,IR(36, 2),IR(46698, 5),IR(1, 0)}, // UMin in glsl_std_450 + {39,IR(36, 2),IR(46703, 5),IR(1, 0)}, // SMin in glsl_std_450 + {40,IR(36, 2),IR(46708, 5),IR(1, 0)}, // FMax in glsl_std_450 + {41,IR(36, 2),IR(46713, 5),IR(1, 0)}, // UMax in glsl_std_450 + {42,IR(36, 2),IR(46718, 5),IR(1, 0)}, // SMax in glsl_std_450 + {43,IR(33, 3),IR(46723, 7),IR(1, 0)}, // FClamp in glsl_std_450 + {44,IR(33, 3),IR(46730, 7),IR(1, 0)}, // UClamp in glsl_std_450 + {45,IR(33, 3),IR(46737, 7),IR(1, 0)}, // SClamp in glsl_std_450 + {46,IR(33, 3),IR(46744, 5),IR(1, 0)}, // FMix in glsl_std_450 + {47,IR(33, 3),IR(46749, 5),IR(1, 0)}, // IMix in glsl_std_450 + {48,IR(36, 2),IR(46754, 5),IR(1, 0)}, // Step in glsl_std_450 + {49,IR(33, 3),IR(46759, 11),IR(1, 0)}, // SmoothStep in glsl_std_450 + {50,IR(33, 3),IR(46770, 4),IR(1, 0)}, // Fma in glsl_std_450 + {51,IR(36, 2),IR(46774, 6),IR(1, 0)}, // Frexp in glsl_std_450 + {52,IR(10, 1),IR(46780, 12),IR(1, 0)}, // FrexpStruct in glsl_std_450 + {53,IR(36, 2),IR(46792, 6),IR(1, 0)}, // Ldexp in glsl_std_450 + {54,IR(10, 1),IR(46798, 13),IR(1, 0)}, // PackSnorm4x8 in glsl_std_450 + {55,IR(10, 1),IR(46811, 13),IR(1, 0)}, // PackUnorm4x8 in glsl_std_450 + {56,IR(10, 1),IR(46824, 14),IR(1, 0)}, // PackSnorm2x16 in glsl_std_450 + {57,IR(10, 1),IR(46838, 14),IR(1, 0)}, // PackUnorm2x16 in glsl_std_450 + {58,IR(10, 1),IR(46852, 13),IR(1, 0)}, // PackHalf2x16 in glsl_std_450 + {59,IR(10, 1),IR(46865, 15),IR(310, 1)}, // PackDouble2x32 in glsl_std_450 + {60,IR(10, 1),IR(46880, 16),IR(1, 0)}, // UnpackSnorm2x16 in glsl_std_450 + {61,IR(10, 1),IR(46896, 16),IR(1, 0)}, // UnpackUnorm2x16 in glsl_std_450 + {62,IR(10, 1),IR(46912, 15),IR(1, 0)}, // UnpackHalf2x16 in glsl_std_450 + {63,IR(10, 1),IR(46927, 15),IR(1, 0)}, // UnpackSnorm4x8 in glsl_std_450 + {64,IR(10, 1),IR(46942, 15),IR(1, 0)}, // UnpackUnorm4x8 in glsl_std_450 + {65,IR(10, 1),IR(46957, 17),IR(310, 1)}, // UnpackDouble2x32 in glsl_std_450 + {66,IR(10, 1),IR(46974, 7),IR(1, 0)}, // Length in glsl_std_450 + {67,IR(36, 2),IR(46981, 9),IR(1, 0)}, // Distance in glsl_std_450 + {68,IR(36, 2),IR(46990, 6),IR(1, 0)}, // Cross in glsl_std_450 + {69,IR(10, 1),IR(46996, 10),IR(1, 0)}, // Normalize in glsl_std_450 + {70,IR(33, 3),IR(47006, 12),IR(1, 0)}, // FaceForward in glsl_std_450 + {71,IR(36, 2),IR(47018, 8),IR(1, 0)}, // Reflect in glsl_std_450 + {72,IR(33, 3),IR(47026, 8),IR(1, 0)}, // Refract in glsl_std_450 + {73,IR(10, 1),IR(47034, 9),IR(1, 0)}, // FindILsb in glsl_std_450 + {74,IR(10, 1),IR(47043, 9),IR(1, 0)}, // FindSMsb in glsl_std_450 + {75,IR(10, 1),IR(47052, 9),IR(1, 0)}, // FindUMsb in glsl_std_450 + {76,IR(10, 1),IR(47061, 22),IR(311, 1)}, // InterpolateAtCentroid in glsl_std_450 + {77,IR(36, 2),IR(47083, 20),IR(311, 1)}, // InterpolateAtSample in glsl_std_450 + {78,IR(36, 2),IR(47103, 20),IR(311, 1)}, // InterpolateAtOffset in glsl_std_450 + {79,IR(36, 2),IR(47123, 5),IR(1, 0)}, // NMin in glsl_std_450 + {80,IR(36, 2),IR(47128, 5),IR(1, 0)}, // NMax in glsl_std_450 + {81,IR(33, 3),IR(47133, 7),IR(1, 0)}, // NClamp in glsl_std_450 + {1,IR(399, 5),IR(4642, 7),IR(1, 0)}, // Kernel in nonsemantic_clspvreflection + {2,IR(878, 5),IR(47140, 13),IR(1, 0)}, // ArgumentInfo in nonsemantic_clspvreflection + {3,IR(883, 5),IR(47153, 22),IR(1, 0)}, // ArgumentStorageBuffer in nonsemantic_clspvreflection + {4,IR(883, 5),IR(47175, 16),IR(1, 0)}, // ArgumentUniform in nonsemantic_clspvreflection + {5,IR(554, 7),IR(47191, 25),IR(1, 0)}, // ArgumentPodStorageBuffer in nonsemantic_clspvreflection + {6,IR(554, 7),IR(47216, 19),IR(1, 0)}, // ArgumentPodUniform in nonsemantic_clspvreflection + {7,IR(883, 5),IR(47235, 24),IR(1, 0)}, // ArgumentPodPushConstant in nonsemantic_clspvreflection + {8,IR(883, 5),IR(47259, 21),IR(1, 0)}, // ArgumentSampledImage in nonsemantic_clspvreflection + {9,IR(883, 5),IR(47280, 21),IR(1, 0)}, // ArgumentStorageImage in nonsemantic_clspvreflection + {10,IR(883, 5),IR(47301, 16),IR(1, 0)}, // ArgumentSampler in nonsemantic_clspvreflection + {11,IR(883, 5),IR(47317, 18),IR(1, 0)}, // ArgumentWorkgroup in nonsemantic_clspvreflection + {12,IR(33, 3),IR(47335, 26),IR(1, 0)}, // SpecConstantWorkgroupSize in nonsemantic_clspvreflection + {13,IR(33, 3),IR(47361, 25),IR(1, 0)}, // SpecConstantGlobalOffset in nonsemantic_clspvreflection + {14,IR(10, 1),IR(47386, 20),IR(1, 0)}, // SpecConstantWorkDim in nonsemantic_clspvreflection + {15,IR(36, 2),IR(47406, 25),IR(1, 0)}, // PushConstantGlobalOffset in nonsemantic_clspvreflection + {16,IR(36, 2),IR(47431, 30),IR(1, 0)}, // PushConstantEnqueuedLocalSize in nonsemantic_clspvreflection + {17,IR(36, 2),IR(47461, 23),IR(1, 0)}, // PushConstantGlobalSize in nonsemantic_clspvreflection + {18,IR(36, 2),IR(47484, 25),IR(1, 0)}, // PushConstantRegionOffset in nonsemantic_clspvreflection + {19,IR(36, 2),IR(47509, 26),IR(1, 0)}, // PushConstantNumWorkgroups in nonsemantic_clspvreflection + {20,IR(36, 2),IR(47535, 30),IR(1, 0)}, // PushConstantRegionGroupOffset in nonsemantic_clspvreflection + {21,IR(33, 3),IR(47565, 26),IR(1, 0)}, // ConstantDataStorageBuffer in nonsemantic_clspvreflection + {22,IR(33, 3),IR(47591, 20),IR(1, 0)}, // ConstantDataUniform in nonsemantic_clspvreflection + {23,IR(33, 3),IR(8067, 15),IR(1, 0)}, // LiteralSampler in nonsemantic_clspvreflection + {24,IR(296, 4),IR(47611, 30),IR(1, 0)}, // PropertyRequiredWorkgroupSize in nonsemantic_clspvreflection + {25,IR(10, 1),IR(47641, 28),IR(1, 0)}, // SpecConstantSubgroupMaxSize in nonsemantic_clspvreflection + {26,IR(883, 5),IR(47669, 28),IR(1, 0)}, // ArgumentPointerPushConstant in nonsemantic_clspvreflection + {27,IR(554, 7),IR(47697, 23),IR(1, 0)}, // ArgumentPointerUniform in nonsemantic_clspvreflection + {28,IR(33, 3),IR(47720, 35),IR(1, 0)}, // ProgramScopeVariablesStorageBuffer in nonsemantic_clspvreflection + {29,IR(33, 3),IR(47755, 38),IR(1, 0)}, // ProgramScopeVariablePointerRelocation in nonsemantic_clspvreflection + {30,IR(296, 4),IR(47793, 42),IR(1, 0)}, // ImageArgumentInfoChannelOrderPushConstant in nonsemantic_clspvreflection + {31,IR(296, 4),IR(47835, 45),IR(1, 0)}, // ImageArgumentInfoChannelDataTypePushConstant in nonsemantic_clspvreflection + {32,IR(525, 6),IR(47880, 37),IR(1, 0)}, // ImageArgumentInfoChannelOrderUniform in nonsemantic_clspvreflection + {33,IR(525, 6),IR(47917, 40),IR(1, 0)}, // ImageArgumentInfoChannelDataTypeUniform in nonsemantic_clspvreflection + {34,IR(883, 5),IR(47957, 27),IR(1, 0)}, // ArgumentStorageTexelBuffer in nonsemantic_clspvreflection + {35,IR(883, 5),IR(47984, 27),IR(1, 0)}, // ArgumentUniformTexelBuffer in nonsemantic_clspvreflection + {36,IR(33, 3),IR(48011, 32),IR(1, 0)}, // ConstantDataPointerPushConstant in nonsemantic_clspvreflection + {37,IR(33, 3),IR(48043, 40),IR(1, 0)}, // ProgramScopeVariablePointerPushConstant in nonsemantic_clspvreflection + {38,IR(375, 3),IR(48083, 11),IR(1, 0)}, // PrintfInfo in nonsemantic_clspvreflection + {39,IR(33, 3),IR(48094, 26),IR(1, 0)}, // PrintfBufferStorageBuffer in nonsemantic_clspvreflection + {40,IR(33, 3),IR(48120, 32),IR(1, 0)}, // PrintfBufferPointerPushConstant in nonsemantic_clspvreflection + {41,IR(296, 4),IR(48152, 34),IR(1, 0)}, // NormalizedSamplerMaskPushConstant in nonsemantic_clspvreflection + {42,IR(36, 2),IR(48186, 22),IR(1, 0)}, // WorkgroupVariableSize in nonsemantic_clspvreflection + {0,IR(0, 0),IR(45610, 14),IR(1, 0)}, // DebugInfoNone in nonsemantic_shader_debuginfo_100 + {1,IR(296, 4),IR(45624, 21),IR(1, 0)}, // DebugCompilationUnit in nonsemantic_shader_debuginfo_100 + {2,IR(296, 4),IR(45697, 15),IR(1, 0)}, // DebugTypeBasic in nonsemantic_shader_debuginfo_100 + {3,IR(33, 3),IR(45746, 17),IR(1, 0)}, // DebugTypePointer in nonsemantic_shader_debuginfo_100 + {4,IR(36, 2),IR(45801, 19),IR(1, 0)}, // DebugTypeQualifier in nonsemantic_shader_debuginfo_100 + {5,IR(168, 2),IR(45820, 15),IR(1, 0)}, // DebugTypeArray in nonsemantic_shader_debuginfo_100 + {6,IR(36, 2),IR(45835, 16),IR(1, 0)}, // DebugTypeVector in nonsemantic_shader_debuginfo_100 + {7,IR(525, 6),IR(45851, 13),IR(1, 0)}, // DebugTypedef in nonsemantic_shader_debuginfo_100 + {8,IR(375, 3),IR(45864, 18),IR(1, 0)}, // DebugTypeFunction in nonsemantic_shader_debuginfo_100 + {9,IR(888, 9),IR(45882, 14),IR(1, 0)}, // DebugTypeEnum in nonsemantic_shader_debuginfo_100 + {10,IR(897, 10),IR(45934, 19),IR(1, 0)}, // DebugTypeComposite in nonsemantic_shader_debuginfo_100 + {11,IR(907, 9),IR(45953, 16),IR(1, 0)}, // DebugTypeMember in nonsemantic_shader_debuginfo_100 + {12,IR(296, 4),IR(45969, 21),IR(1, 0)}, // DebugTypeInheritance in nonsemantic_shader_debuginfo_100 + {13,IR(36, 2),IR(45990, 21),IR(1, 0)}, // DebugTypePtrToMember in nonsemantic_shader_debuginfo_100 + {14,IR(168, 2),IR(46011, 18),IR(1, 0)}, // DebugTypeTemplate in nonsemantic_shader_debuginfo_100 + {15,IR(525, 6),IR(46029, 27),IR(1, 0)}, // DebugTypeTemplateParameter in nonsemantic_shader_debuginfo_100 + {16,IR(634, 5),IR(46056, 35),IR(1, 0)}, // DebugTypeTemplateTemplateParameter in nonsemantic_shader_debuginfo_100 + {17,IR(916, 5),IR(46091, 31),IR(1, 0)}, // DebugTypeTemplateParameterPack in nonsemantic_shader_debuginfo_100 + {18,IR(921, 10),IR(46122, 20),IR(1, 0)}, // DebugGlobalVariable in nonsemantic_shader_debuginfo_100 + {19,IR(471, 8),IR(46142, 25),IR(1, 0)}, // DebugFunctionDeclaration in nonsemantic_shader_debuginfo_100 + {20,IR(921, 10),IR(46167, 14),IR(1, 0)}, // DebugFunction in nonsemantic_shader_debuginfo_100 + {21,IR(883, 5),IR(46181, 18),IR(1, 0)}, // DebugLexicalBlock in nonsemantic_shader_debuginfo_100 + {22,IR(33, 3),IR(46199, 31),IR(1, 0)}, // DebugLexicalBlockDiscriminator in nonsemantic_shader_debuginfo_100 + {23,IR(860, 2),IR(46230, 11),IR(1, 0)}, // DebugScope in nonsemantic_shader_debuginfo_100 + {24,IR(0, 0),IR(46241, 13),IR(1, 0)}, // DebugNoScope in nonsemantic_shader_debuginfo_100 + {25,IR(931, 3),IR(46254, 15),IR(1, 0)}, // DebugInlinedAt in nonsemantic_shader_debuginfo_100 + {26,IR(934, 8),IR(46311, 19),IR(1, 0)}, // DebugLocalVariable in nonsemantic_shader_debuginfo_100 + {27,IR(36, 2),IR(46330, 21),IR(1, 0)}, // DebugInlinedVariable in nonsemantic_shader_debuginfo_100 + {28,IR(942, 4),IR(46351, 13),IR(1, 0)}, // DebugDeclare in nonsemantic_shader_debuginfo_100 + {29,IR(942, 4),IR(46364, 11),IR(1, 0)}, // DebugValue in nonsemantic_shader_debuginfo_100 + {30,IR(168, 2),IR(46408, 15),IR(1, 0)}, // DebugOperation in nonsemantic_shader_debuginfo_100 + {31,IR(706, 1),IR(46423, 16),IR(1, 0)}, // DebugExpression in nonsemantic_shader_debuginfo_100 + {32,IR(577, 4),IR(46439, 14),IR(1, 0)}, // DebugMacroDef in nonsemantic_shader_debuginfo_100 + {33,IR(33, 3),IR(46453, 16),IR(1, 0)}, // DebugMacroUndef in nonsemantic_shader_debuginfo_100 + {34,IR(506, 7),IR(48208, 20),IR(1, 0)}, // DebugImportedEntity in nonsemantic_shader_debuginfo_100 + {35,IR(860, 2),IR(48228, 12),IR(1, 0)}, // DebugSource in nonsemantic_shader_debuginfo_100 + {101,IR(36, 2),IR(48240, 24),IR(1, 0)}, // DebugFunctionDefinition in nonsemantic_shader_debuginfo_100 + {102,IR(10, 1),IR(48264, 21),IR(1, 0)}, // DebugSourceContinued in nonsemantic_shader_debuginfo_100 + {103,IR(634, 5),IR(48285, 10),IR(1, 0)}, // DebugLine in nonsemantic_shader_debuginfo_100 + {104,IR(0, 0),IR(48295, 12),IR(1, 0)}, // DebugNoLine in nonsemantic_shader_debuginfo_100 + {105,IR(36, 2),IR(48307, 21),IR(1, 0)}, // DebugBuildIdentifier in nonsemantic_shader_debuginfo_100 + {106,IR(10, 1),IR(48328, 17),IR(1, 0)}, // DebugStoragePath in nonsemantic_shader_debuginfo_100 + {107,IR(296, 4),IR(48345, 16),IR(1, 0)}, // DebugEntryPoint in nonsemantic_shader_debuginfo_100 + {108,IR(33, 3),IR(48361, 16),IR(1, 0)}, // DebugTypeMatrix in nonsemantic_shader_debuginfo_100 + {1,IR(724, 9),IR(48377, 14),IR(1, 0)}, // Configuration in nonsemantic_vkspreflection + {2,IR(10, 1),IR(48391, 13),IR(1, 0)}, // StartCounter in nonsemantic_vkspreflection + {3,IR(10, 1),IR(48404, 12),IR(1, 0)}, // StopCounter in nonsemantic_vkspreflection + {4,IR(296, 4),IR(48416, 14),IR(1, 0)}, // PushConstants in nonsemantic_vkspreflection + {5,IR(33, 3),IR(48430, 23),IR(1, 0)}, // SpecializationMapEntry in nonsemantic_vkspreflection + {6,IR(946, 15),IR(48453, 20),IR(1, 0)}, // DescriptorSetBuffer in nonsemantic_vkspreflection + {7,IR(961, 33),IR(48473, 19),IR(1, 0)}, // DescriptorSetImage in nonsemantic_vkspreflection + {8,IR(994, 19),IR(48492, 21),IR(1, 0)}, // DescriptorSetSampler in nonsemantic_vkspreflection + {0,IR(0, 0),IR(45610, 14),IR(1, 0)}, // DebugInfoNone in opencl_debuginfo_100 + {1,IR(1013, 4),IR(45624, 21),IR(1, 0)}, // DebugCompilationUnit in opencl_debuginfo_100 + {2,IR(1017, 3),IR(45697, 15),IR(1, 0)}, // DebugTypeBasic in opencl_debuginfo_100 + {3,IR(1020, 3),IR(45746, 17),IR(1, 0)}, // DebugTypePointer in opencl_debuginfo_100 + {4,IR(1023, 2),IR(45801, 19),IR(1, 0)}, // DebugTypeQualifier in opencl_debuginfo_100 + {5,IR(168, 2),IR(45820, 15),IR(1, 0)}, // DebugTypeArray in opencl_debuginfo_100 + {6,IR(261, 2),IR(45835, 16),IR(1, 0)}, // DebugTypeVector in opencl_debuginfo_100 + {7,IR(778, 6),IR(45851, 13),IR(1, 0)}, // DebugTypedef in opencl_debuginfo_100 + {8,IR(1025, 3),IR(45864, 18),IR(1, 0)}, // DebugTypeFunction in opencl_debuginfo_100 + {9,IR(1028, 9),IR(45882, 14),IR(1, 0)}, // DebugTypeEnum in opencl_debuginfo_100 + {10,IR(1037, 10),IR(45934, 19),IR(1, 0)}, // DebugTypeComposite in opencl_debuginfo_100 + {11,IR(1047, 10),IR(45953, 16),IR(1, 0)}, // DebugTypeMember in opencl_debuginfo_100 + {12,IR(1057, 5),IR(45969, 21),IR(1, 0)}, // DebugTypeInheritance in opencl_debuginfo_100 + {13,IR(36, 2),IR(45990, 21),IR(1, 0)}, // DebugTypePtrToMember in opencl_debuginfo_100 + {14,IR(168, 2),IR(46011, 18),IR(1, 0)}, // DebugTypeTemplate in opencl_debuginfo_100 + {15,IR(817, 6),IR(46029, 27),IR(1, 0)}, // DebugTypeTemplateParameter in opencl_debuginfo_100 + {16,IR(823, 5),IR(46056, 35),IR(1, 0)}, // DebugTypeTemplateTemplateParameter in opencl_debuginfo_100 + {17,IR(828, 5),IR(46091, 31),IR(1, 0)}, // DebugTypeTemplateParameterPack in opencl_debuginfo_100 + {18,IR(1047, 10),IR(46122, 20),IR(1, 0)}, // DebugGlobalVariable in opencl_debuginfo_100 + {19,IR(1062, 8),IR(46142, 25),IR(1, 0)}, // DebugFunctionDeclaration in opencl_debuginfo_100 + {20,IR(1070, 11),IR(46167, 14),IR(1, 0)}, // DebugFunction in opencl_debuginfo_100 + {21,IR(852, 5),IR(46181, 18),IR(1, 0)}, // DebugLexicalBlock in opencl_debuginfo_100 + {22,IR(857, 3),IR(46199, 31),IR(1, 0)}, // DebugLexicalBlockDiscriminator in opencl_debuginfo_100 + {23,IR(860, 2),IR(46230, 11),IR(1, 0)}, // DebugScope in opencl_debuginfo_100 + {24,IR(0, 0),IR(46241, 13),IR(1, 0)}, // DebugNoScope in opencl_debuginfo_100 + {25,IR(862, 3),IR(46254, 15),IR(1, 0)}, // DebugInlinedAt in opencl_debuginfo_100 + {26,IR(1081, 8),IR(46311, 19),IR(1, 0)}, // DebugLocalVariable in opencl_debuginfo_100 + {27,IR(36, 2),IR(46330, 21),IR(1, 0)}, // DebugInlinedVariable in opencl_debuginfo_100 + {28,IR(33, 3),IR(46351, 13),IR(1, 0)}, // DebugDeclare in opencl_debuginfo_100 + {29,IR(942, 4),IR(46364, 11),IR(1, 0)}, // DebugValue in opencl_debuginfo_100 + {30,IR(1089, 2),IR(46408, 15),IR(1, 0)}, // DebugOperation in opencl_debuginfo_100 + {31,IR(706, 1),IR(46423, 16),IR(1, 0)}, // DebugExpression in opencl_debuginfo_100 + {32,IR(874, 4),IR(46439, 14),IR(1, 0)}, // DebugMacroDef in opencl_debuginfo_100 + {33,IR(857, 3),IR(46453, 16),IR(1, 0)}, // DebugMacroUndef in opencl_debuginfo_100 + {34,IR(1091, 7),IR(48208, 20),IR(1, 0)}, // DebugImportedEntity in opencl_debuginfo_100 + {35,IR(860, 2),IR(48228, 12),IR(1, 0)}, // DebugSource in opencl_debuginfo_100 + {36,IR(1098, 8),IR(48813, 17),IR(1, 0)}, // DebugModuleINTEL in opencl_debuginfo_100 + {0,IR(10, 1),IR(48830, 5),IR(1, 0)}, // acos in opencl_std_100 + {1,IR(10, 1),IR(48835, 6),IR(1, 0)}, // acosh in opencl_std_100 + {2,IR(10, 1),IR(48841, 7),IR(1, 0)}, // acospi in opencl_std_100 + {3,IR(10, 1),IR(48848, 5),IR(1, 0)}, // asin in opencl_std_100 + {4,IR(10, 1),IR(48853, 6),IR(1, 0)}, // asinh in opencl_std_100 + {5,IR(10, 1),IR(48859, 7),IR(1, 0)}, // asinpi in opencl_std_100 + {6,IR(10, 1),IR(48866, 5),IR(1, 0)}, // atan in opencl_std_100 + {7,IR(36, 2),IR(48871, 6),IR(1, 0)}, // atan2 in opencl_std_100 + {8,IR(10, 1),IR(48877, 6),IR(1, 0)}, // atanh in opencl_std_100 + {9,IR(10, 1),IR(48883, 7),IR(1, 0)}, // atanpi in opencl_std_100 + {10,IR(36, 2),IR(48890, 8),IR(1, 0)}, // atan2pi in opencl_std_100 + {11,IR(10, 1),IR(48898, 5),IR(1, 0)}, // cbrt in opencl_std_100 + {12,IR(10, 1),IR(48903, 5),IR(1, 0)}, // ceil in opencl_std_100 + {13,IR(36, 2),IR(48908, 9),IR(1, 0)}, // copysign in opencl_std_100 + {14,IR(10, 1),IR(48917, 4),IR(1, 0)}, // cos in opencl_std_100 + {15,IR(10, 1),IR(48921, 5),IR(1, 0)}, // cosh in opencl_std_100 + {16,IR(10, 1),IR(48926, 6),IR(1, 0)}, // cospi in opencl_std_100 + {17,IR(10, 1),IR(48932, 5),IR(1, 0)}, // erfc in opencl_std_100 + {18,IR(10, 1),IR(48937, 4),IR(1, 0)}, // erf in opencl_std_100 + {19,IR(10, 1),IR(48941, 4),IR(1, 0)}, // exp in opencl_std_100 + {20,IR(10, 1),IR(48945, 5),IR(1, 0)}, // exp2 in opencl_std_100 + {21,IR(10, 1),IR(48950, 6),IR(1, 0)}, // exp10 in opencl_std_100 + {22,IR(10, 1),IR(48956, 6),IR(1, 0)}, // expm1 in opencl_std_100 + {23,IR(10, 1),IR(48962, 5),IR(1, 0)}, // fabs in opencl_std_100 + {24,IR(36, 2),IR(48967, 5),IR(1, 0)}, // fdim in opencl_std_100 + {25,IR(10, 1),IR(48972, 6),IR(1, 0)}, // floor in opencl_std_100 + {26,IR(33, 3),IR(48978, 4),IR(1, 0)}, // fma in opencl_std_100 + {27,IR(36, 2),IR(48982, 5),IR(1, 0)}, // fmax in opencl_std_100 + {28,IR(36, 2),IR(48987, 5),IR(1, 0)}, // fmin in opencl_std_100 + {29,IR(36, 2),IR(48992, 5),IR(1, 0)}, // fmod in opencl_std_100 + {30,IR(36, 2),IR(48997, 6),IR(1, 0)}, // fract in opencl_std_100 + {31,IR(36, 2),IR(49003, 6),IR(1, 0)}, // frexp in opencl_std_100 + {32,IR(36, 2),IR(49009, 6),IR(1, 0)}, // hypot in opencl_std_100 + {33,IR(10, 1),IR(49015, 6),IR(1, 0)}, // ilogb in opencl_std_100 + {34,IR(36, 2),IR(49021, 6),IR(1, 0)}, // ldexp in opencl_std_100 + {35,IR(10, 1),IR(49027, 7),IR(1, 0)}, // lgamma in opencl_std_100 + {36,IR(36, 2),IR(49034, 9),IR(1, 0)}, // lgamma_r in opencl_std_100 + {37,IR(10, 1),IR(49043, 4),IR(1, 0)}, // log in opencl_std_100 + {38,IR(10, 1),IR(49047, 5),IR(1, 0)}, // log2 in opencl_std_100 + {39,IR(10, 1),IR(49052, 6),IR(1, 0)}, // log10 in opencl_std_100 + {40,IR(10, 1),IR(49058, 6),IR(1, 0)}, // log1p in opencl_std_100 + {41,IR(10, 1),IR(49064, 5),IR(1, 0)}, // logb in opencl_std_100 + {42,IR(33, 3),IR(49069, 4),IR(1, 0)}, // mad in opencl_std_100 + {43,IR(36, 2),IR(49073, 7),IR(1, 0)}, // maxmag in opencl_std_100 + {44,IR(36, 2),IR(49080, 7),IR(1, 0)}, // minmag in opencl_std_100 + {45,IR(36, 2),IR(49087, 5),IR(1, 0)}, // modf in opencl_std_100 + {46,IR(10, 1),IR(49092, 4),IR(1, 0)}, // nan in opencl_std_100 + {47,IR(36, 2),IR(49096, 10),IR(1, 0)}, // nextafter in opencl_std_100 + {48,IR(36, 2),IR(49106, 4),IR(1, 0)}, // pow in opencl_std_100 + {49,IR(36, 2),IR(49110, 5),IR(1, 0)}, // pown in opencl_std_100 + {50,IR(36, 2),IR(49115, 5),IR(1, 0)}, // powr in opencl_std_100 + {51,IR(36, 2),IR(49120, 10),IR(1, 0)}, // remainder in opencl_std_100 + {52,IR(33, 3),IR(49130, 7),IR(1, 0)}, // remquo in opencl_std_100 + {53,IR(10, 1),IR(49137, 5),IR(1, 0)}, // rint in opencl_std_100 + {54,IR(36, 2),IR(49142, 6),IR(1, 0)}, // rootn in opencl_std_100 + {55,IR(10, 1),IR(49148, 6),IR(1, 0)}, // round in opencl_std_100 + {56,IR(10, 1),IR(49154, 6),IR(1, 0)}, // rsqrt in opencl_std_100 + {57,IR(10, 1),IR(49160, 4),IR(1, 0)}, // sin in opencl_std_100 + {58,IR(36, 2),IR(49164, 7),IR(1, 0)}, // sincos in opencl_std_100 + {59,IR(10, 1),IR(49171, 5),IR(1, 0)}, // sinh in opencl_std_100 + {60,IR(10, 1),IR(49176, 6),IR(1, 0)}, // sinpi in opencl_std_100 + {61,IR(10, 1),IR(49182, 5),IR(1, 0)}, // sqrt in opencl_std_100 + {62,IR(10, 1),IR(49187, 4),IR(1, 0)}, // tan in opencl_std_100 + {63,IR(10, 1),IR(49191, 5),IR(1, 0)}, // tanh in opencl_std_100 + {64,IR(10, 1),IR(49196, 6),IR(1, 0)}, // tanpi in opencl_std_100 + {65,IR(10, 1),IR(49202, 7),IR(1, 0)}, // tgamma in opencl_std_100 + {66,IR(10, 1),IR(49209, 6),IR(1, 0)}, // trunc in opencl_std_100 + {67,IR(10, 1),IR(49215, 9),IR(1, 0)}, // half_cos in opencl_std_100 + {68,IR(36, 2),IR(49224, 12),IR(1, 0)}, // half_divide in opencl_std_100 + {69,IR(10, 1),IR(49236, 9),IR(1, 0)}, // half_exp in opencl_std_100 + {70,IR(10, 1),IR(49245, 10),IR(1, 0)}, // half_exp2 in opencl_std_100 + {71,IR(10, 1),IR(49255, 11),IR(1, 0)}, // half_exp10 in opencl_std_100 + {72,IR(10, 1),IR(49266, 9),IR(1, 0)}, // half_log in opencl_std_100 + {73,IR(10, 1),IR(49275, 10),IR(1, 0)}, // half_log2 in opencl_std_100 + {74,IR(10, 1),IR(49285, 11),IR(1, 0)}, // half_log10 in opencl_std_100 + {75,IR(36, 2),IR(49296, 10),IR(1, 0)}, // half_powr in opencl_std_100 + {76,IR(10, 1),IR(49306, 11),IR(1, 0)}, // half_recip in opencl_std_100 + {77,IR(10, 1),IR(49317, 11),IR(1, 0)}, // half_rsqrt in opencl_std_100 + {78,IR(10, 1),IR(49328, 9),IR(1, 0)}, // half_sin in opencl_std_100 + {79,IR(10, 1),IR(49337, 10),IR(1, 0)}, // half_sqrt in opencl_std_100 + {80,IR(10, 1),IR(49347, 9),IR(1, 0)}, // half_tan in opencl_std_100 + {81,IR(10, 1),IR(49356, 11),IR(1, 0)}, // native_cos in opencl_std_100 + {82,IR(36, 2),IR(49367, 14),IR(1, 0)}, // native_divide in opencl_std_100 + {83,IR(10, 1),IR(49381, 11),IR(1, 0)}, // native_exp in opencl_std_100 + {84,IR(10, 1),IR(49392, 12),IR(1, 0)}, // native_exp2 in opencl_std_100 + {85,IR(10, 1),IR(49404, 13),IR(1, 0)}, // native_exp10 in opencl_std_100 + {86,IR(10, 1),IR(49417, 11),IR(1, 0)}, // native_log in opencl_std_100 + {87,IR(10, 1),IR(49428, 12),IR(1, 0)}, // native_log2 in opencl_std_100 + {88,IR(10, 1),IR(49440, 13),IR(1, 0)}, // native_log10 in opencl_std_100 + {89,IR(36, 2),IR(49453, 12),IR(1, 0)}, // native_powr in opencl_std_100 + {90,IR(10, 1),IR(49465, 13),IR(1, 0)}, // native_recip in opencl_std_100 + {91,IR(10, 1),IR(49478, 13),IR(1, 0)}, // native_rsqrt in opencl_std_100 + {92,IR(10, 1),IR(49491, 11),IR(1, 0)}, // native_sin in opencl_std_100 + {93,IR(10, 1),IR(49502, 12),IR(1, 0)}, // native_sqrt in opencl_std_100 + {94,IR(10, 1),IR(49514, 11),IR(1, 0)}, // native_tan in opencl_std_100 + {95,IR(33, 3),IR(49525, 7),IR(1, 0)}, // fclamp in opencl_std_100 + {96,IR(10, 1),IR(49532, 8),IR(1, 0)}, // degrees in opencl_std_100 + {97,IR(36, 2),IR(49540, 12),IR(1, 0)}, // fmax_common in opencl_std_100 + {98,IR(36, 2),IR(49552, 12),IR(1, 0)}, // fmin_common in opencl_std_100 + {99,IR(33, 3),IR(49564, 4),IR(1, 0)}, // mix in opencl_std_100 + {100,IR(10, 1),IR(49568, 8),IR(1, 0)}, // radians in opencl_std_100 + {101,IR(36, 2),IR(49576, 5),IR(1, 0)}, // step in opencl_std_100 + {102,IR(33, 3),IR(49581, 11),IR(1, 0)}, // smoothstep in opencl_std_100 + {103,IR(10, 1),IR(49592, 5),IR(1, 0)}, // sign in opencl_std_100 + {104,IR(36, 2),IR(49597, 6),IR(1, 0)}, // cross in opencl_std_100 + {105,IR(36, 2),IR(49603, 9),IR(1, 0)}, // distance in opencl_std_100 + {106,IR(10, 1),IR(49612, 7),IR(1, 0)}, // length in opencl_std_100 + {107,IR(10, 1),IR(49619, 10),IR(1, 0)}, // normalize in opencl_std_100 + {108,IR(36, 2),IR(49629, 14),IR(1, 0)}, // fast_distance in opencl_std_100 + {109,IR(10, 1),IR(49643, 12),IR(1, 0)}, // fast_length in opencl_std_100 + {110,IR(10, 1),IR(49655, 15),IR(1, 0)}, // fast_normalize in opencl_std_100 + {141,IR(10, 1),IR(49670, 6),IR(1, 0)}, // s_abs in opencl_std_100 + {142,IR(36, 2),IR(49676, 11),IR(1, 0)}, // s_abs_diff in opencl_std_100 + {143,IR(36, 2),IR(49687, 10),IR(1, 0)}, // s_add_sat in opencl_std_100 + {144,IR(36, 2),IR(49697, 10),IR(1, 0)}, // u_add_sat in opencl_std_100 + {145,IR(36, 2),IR(49707, 7),IR(1, 0)}, // s_hadd in opencl_std_100 + {146,IR(36, 2),IR(49714, 7),IR(1, 0)}, // u_hadd in opencl_std_100 + {147,IR(36, 2),IR(49721, 8),IR(1, 0)}, // s_rhadd in opencl_std_100 + {148,IR(36, 2),IR(49729, 8),IR(1, 0)}, // u_rhadd in opencl_std_100 + {149,IR(33, 3),IR(49737, 8),IR(1, 0)}, // s_clamp in opencl_std_100 + {150,IR(33, 3),IR(49745, 8),IR(1, 0)}, // u_clamp in opencl_std_100 + {151,IR(10, 1),IR(49753, 4),IR(1, 0)}, // clz in opencl_std_100 + {152,IR(10, 1),IR(49757, 4),IR(1, 0)}, // ctz in opencl_std_100 + {153,IR(33, 3),IR(49761, 9),IR(1, 0)}, // s_mad_hi in opencl_std_100 + {154,IR(33, 3),IR(49770, 10),IR(1, 0)}, // u_mad_sat in opencl_std_100 + {155,IR(33, 3),IR(49780, 10),IR(1, 0)}, // s_mad_sat in opencl_std_100 + {156,IR(36, 2),IR(49790, 6),IR(1, 0)}, // s_max in opencl_std_100 + {157,IR(36, 2),IR(49796, 6),IR(1, 0)}, // u_max in opencl_std_100 + {158,IR(36, 2),IR(49802, 6),IR(1, 0)}, // s_min in opencl_std_100 + {159,IR(36, 2),IR(49808, 6),IR(1, 0)}, // u_min in opencl_std_100 + {160,IR(36, 2),IR(49814, 9),IR(1, 0)}, // s_mul_hi in opencl_std_100 + {161,IR(36, 2),IR(49823, 7),IR(1, 0)}, // rotate in opencl_std_100 + {162,IR(36, 2),IR(49830, 10),IR(1, 0)}, // s_sub_sat in opencl_std_100 + {163,IR(36, 2),IR(49840, 10),IR(1, 0)}, // u_sub_sat in opencl_std_100 + {164,IR(36, 2),IR(49850, 11),IR(1, 0)}, // u_upsample in opencl_std_100 + {165,IR(36, 2),IR(49861, 11),IR(1, 0)}, // s_upsample in opencl_std_100 + {166,IR(10, 1),IR(49872, 9),IR(1, 0)}, // popcount in opencl_std_100 + {167,IR(33, 3),IR(49881, 8),IR(1, 0)}, // s_mad24 in opencl_std_100 + {168,IR(33, 3),IR(49889, 8),IR(1, 0)}, // u_mad24 in opencl_std_100 + {169,IR(36, 2),IR(49897, 8),IR(1, 0)}, // s_mul24 in opencl_std_100 + {170,IR(36, 2),IR(49905, 8),IR(1, 0)}, // u_mul24 in opencl_std_100 + {171,IR(1106, 3),IR(49913, 7),IR(1, 0)}, // vloadn in opencl_std_100 + {172,IR(33, 3),IR(49920, 8),IR(1, 0)}, // vstoren in opencl_std_100 + {173,IR(36, 2),IR(49928, 11),IR(1, 0)}, // vload_half in opencl_std_100 + {174,IR(1106, 3),IR(49939, 12),IR(1, 0)}, // vload_halfn in opencl_std_100 + {175,IR(33, 3),IR(49951, 12),IR(1, 0)}, // vstore_half in opencl_std_100 + {176,IR(1109, 4),IR(49963, 14),IR(1, 0)}, // vstore_half_r in opencl_std_100 + {177,IR(33, 3),IR(49977, 13),IR(1, 0)}, // vstore_halfn in opencl_std_100 + {178,IR(1109, 4),IR(49990, 15),IR(1, 0)}, // vstore_halfn_r in opencl_std_100 + {179,IR(1106, 3),IR(50005, 13),IR(1, 0)}, // vloada_halfn in opencl_std_100 + {180,IR(33, 3),IR(50018, 14),IR(1, 0)}, // vstorea_halfn in opencl_std_100 + {181,IR(1109, 4),IR(50032, 16),IR(1, 0)}, // vstorea_halfn_r in opencl_std_100 + {182,IR(36, 2),IR(50048, 8),IR(1, 0)}, // shuffle in opencl_std_100 + {183,IR(33, 3),IR(50056, 9),IR(1, 0)}, // shuffle2 in opencl_std_100 + {184,IR(168, 2),IR(50065, 7),IR(1, 0)}, // printf in opencl_std_100 + {185,IR(36, 2),IR(50072, 9),IR(1, 0)}, // prefetch in opencl_std_100 + {186,IR(33, 3),IR(50081, 10),IR(1, 0)}, // bitselect in opencl_std_100 + {187,IR(33, 3),IR(50091, 7),IR(1, 0)}, // select in opencl_std_100 + {201,IR(10, 1),IR(50098, 6),IR(1, 0)}, // u_abs in opencl_std_100 + {202,IR(36, 2),IR(50104, 11),IR(1, 0)}, // u_abs_diff in opencl_std_100 + {203,IR(36, 2),IR(50115, 9),IR(1, 0)}, // u_mul_hi in opencl_std_100 + {204,IR(33, 3),IR(50124, 9),IR(1, 0)}, // u_mad_hi in opencl_std_100 + {1,IR(10, 1),IR(50133, 17),IR(1, 0)}, // CubeFaceIndexAMD in spv_amd_gcn_shader + {2,IR(10, 1),IR(50150, 17),IR(1, 0)}, // CubeFaceCoordAMD in spv_amd_gcn_shader + {3,IR(0, 0),IR(50167, 8),IR(1, 0)}, // TimeAMD in spv_amd_gcn_shader + {1,IR(36, 2),IR(50175, 22),IR(1, 0)}, // SwizzleInvocationsAMD in spv_amd_shader_ballot + {2,IR(36, 2),IR(50197, 28),IR(1, 0)}, // SwizzleInvocationsMaskedAMD in spv_amd_shader_ballot + {3,IR(33, 3),IR(50225, 19),IR(1, 0)}, // WriteInvocationAMD in spv_amd_shader_ballot + {4,IR(10, 1),IR(50244, 9),IR(1, 0)}, // MbcntAMD in spv_amd_shader_ballot + {1,IR(36, 2),IR(50253, 23),IR(1, 0)}, // InterpolateAtVertexAMD in spv_amd_shader_explicit_vertex_parameter + {1,IR(33, 3),IR(50276, 9),IR(1, 0)}, // FMin3AMD in spv_amd_shader_trinary_minmax + {2,IR(33, 3),IR(50285, 9),IR(1, 0)}, // UMin3AMD in spv_amd_shader_trinary_minmax + {3,IR(33, 3),IR(50294, 9),IR(1, 0)}, // SMin3AMD in spv_amd_shader_trinary_minmax + {4,IR(33, 3),IR(50303, 9),IR(1, 0)}, // FMax3AMD in spv_amd_shader_trinary_minmax + {5,IR(33, 3),IR(50312, 9),IR(1, 0)}, // UMax3AMD in spv_amd_shader_trinary_minmax + {6,IR(33, 3),IR(50321, 9),IR(1, 0)}, // SMax3AMD in spv_amd_shader_trinary_minmax + {7,IR(33, 3),IR(50330, 9),IR(1, 0)}, // FMid3AMD in spv_amd_shader_trinary_minmax + {8,IR(33, 3),IR(50339, 9),IR(1, 0)}, // UMid3AMD in spv_amd_shader_trinary_minmax + {9,IR(33, 3),IR(50348, 9),IR(1, 0)}, // SMid3AMD in spv_amd_shader_trinary_minmax }}; IndexRange ExtInstByValueRangeForKind(spv_ext_inst_type_t type) { @@ -5086,431 +5153,431 @@ IndexRange ExtInstByValueRangeForKind(spv_ext_inst_type_t type) { // name // index into kExtInstByValue static const std::array kExtInstNames{{ - {IR(44908, 21), 1}, // DebugCompilationUnit in debuginfo - {IR(45635, 13), 28}, // DebugDeclare in debuginfo - {IR(45707, 16), 31}, // DebugExpression in debuginfo - {IR(45451, 14), 20}, // DebugFunction in debuginfo - {IR(45426, 25), 19}, // DebugFunctionDeclaration in debuginfo - {IR(45406, 20), 18}, // DebugGlobalVariable in debuginfo - {IR(44894, 14), 0}, // DebugInfoNone in debuginfo - {IR(45538, 15), 25}, // DebugInlinedAt in debuginfo - {IR(45614, 21), 27}, // DebugInlinedVariable in debuginfo - {IR(45465, 18), 21}, // DebugLexicalBlock in debuginfo - {IR(45483, 31), 22}, // DebugLexicalBlockDiscriminator in debuginfo - {IR(45595, 19), 26}, // DebugLocalVariable in debuginfo - {IR(45723, 14), 32}, // DebugMacroDef in debuginfo - {IR(45737, 16), 33}, // DebugMacroUndef in debuginfo - {IR(45525, 13), 24}, // DebugNoScope in debuginfo - {IR(45692, 15), 30}, // DebugOperation in debuginfo - {IR(45514, 11), 23}, // DebugScope in debuginfo - {IR(45104, 15), 5}, // DebugTypeArray in debuginfo - {IR(44981, 15), 2}, // DebugTypeBasic in debuginfo - {IR(45218, 19), 10}, // DebugTypeComposite in debuginfo - {IR(45166, 14), 9}, // DebugTypeEnum in debuginfo - {IR(45148, 18), 8}, // DebugTypeFunction in debuginfo - {IR(45253, 21), 12}, // DebugTypeInheritance in debuginfo - {IR(45237, 16), 11}, // DebugTypeMember in debuginfo - {IR(45030, 17), 3}, // DebugTypePointer in debuginfo - {IR(45274, 21), 13}, // DebugTypePtrToMember in debuginfo - {IR(45085, 19), 4}, // DebugTypeQualifier in debuginfo - {IR(45295, 18), 14}, // DebugTypeTemplate in debuginfo - {IR(45313, 27), 15}, // DebugTypeTemplateParameter in debuginfo - {IR(45375, 31), 17}, // DebugTypeTemplateParameterPack in debuginfo - {IR(45340, 35), 16}, // DebugTypeTemplateTemplateParameter in debuginfo - {IR(45119, 16), 6}, // DebugTypeVector in debuginfo - {IR(45135, 13), 7}, // DebugTypedef in debuginfo - {IR(45648, 11), 29}, // DebugValue in debuginfo - {IR(45847, 5), 50}, // Acos in glsl_std_450 - {IR(45878, 6), 56}, // Acosh in glsl_std_450 - {IR(45842, 5), 49}, // Asin in glsl_std_450 - {IR(45872, 6), 55}, // Asinh in glsl_std_450 - {IR(45852, 5), 51}, // Atan in glsl_std_450 - {IR(45890, 6), 58}, // Atan2 in glsl_std_450 - {IR(45884, 6), 57}, // Atanh in glsl_std_450 - {IR(45803, 5), 42}, // Ceil in glsl_std_450 - {IR(45834, 4), 47}, // Cos in glsl_std_450 - {IR(45862, 5), 53}, // Cosh in glsl_std_450 - {IR(46274, 6), 101}, // Cross in glsl_std_450 - {IR(45822, 8), 45}, // Degrees in glsl_std_450 - {IR(45935, 12), 66}, // Determinant in glsl_std_450 - {IR(46265, 9), 100}, // Distance in glsl_std_450 - {IR(45900, 4), 60}, // Exp in glsl_std_450 - {IR(45908, 5), 62}, // Exp2 in glsl_std_450 - {IR(45775, 5), 37}, // FAbs in glsl_std_450 - {IR(46007, 7), 76}, // FClamp in glsl_std_450 - {IR(45992, 5), 73}, // FMax in glsl_std_450 - {IR(45977, 5), 70}, // FMin in glsl_std_450 - {IR(46028, 5), 79}, // FMix in glsl_std_450 - {IR(45785, 6), 39}, // FSign in glsl_std_450 - {IR(46290, 12), 103}, // FaceForward in glsl_std_450 - {IR(46318, 9), 106}, // FindILsb in glsl_std_450 - {IR(46327, 9), 107}, // FindSMsb in glsl_std_450 - {IR(46336, 9), 108}, // FindUMsb in glsl_std_450 - {IR(45797, 6), 41}, // Floor in glsl_std_450 - {IR(46054, 4), 83}, // Fma in glsl_std_450 - {IR(45808, 6), 43}, // Fract in glsl_std_450 - {IR(46058, 6), 84}, // Frexp in glsl_std_450 - {IR(46064, 12), 85}, // FrexpStruct in glsl_std_450 - {IR(46033, 5), 80}, // IMix in glsl_std_450 - {IR(46345, 22), 109}, // InterpolateAtCentroid in glsl_std_450 - {IR(46387, 20), 111}, // InterpolateAtOffset in glsl_std_450 - {IR(46367, 20), 110}, // InterpolateAtSample in glsl_std_450 - {IR(45923, 12), 65}, // InverseSqrt in glsl_std_450 - {IR(46076, 6), 86}, // Ldexp in glsl_std_450 - {IR(46258, 7), 99}, // Length in glsl_std_450 - {IR(45904, 4), 61}, // Log in glsl_std_450 - {IR(45913, 5), 63}, // Log2 in glsl_std_450 - {IR(45947, 14), 67}, // MatrixInverse in glsl_std_450 - {IR(45961, 5), 68}, // Modf in glsl_std_450 - {IR(45966, 11), 69}, // ModfStruct in glsl_std_450 - {IR(46417, 7), 114}, // NClamp in glsl_std_450 - {IR(46412, 5), 113}, // NMax in glsl_std_450 - {IR(46407, 5), 112}, // NMin in glsl_std_450 - {IR(46280, 10), 102}, // Normalize in glsl_std_450 - {IR(46149, 15), 92}, // PackDouble2x32 in glsl_std_450 - {IR(46136, 13), 91}, // PackHalf2x16 in glsl_std_450 - {IR(46108, 14), 89}, // PackSnorm2x16 in glsl_std_450 - {IR(46082, 13), 87}, // PackSnorm4x8 in glsl_std_450 - {IR(46122, 14), 90}, // PackUnorm2x16 in glsl_std_450 - {IR(46095, 13), 88}, // PackUnorm4x8 in glsl_std_450 - {IR(45896, 4), 59}, // Pow in glsl_std_450 - {IR(45814, 8), 44}, // Radians in glsl_std_450 - {IR(46302, 8), 104}, // Reflect in glsl_std_450 - {IR(46310, 8), 105}, // Refract in glsl_std_450 - {IR(45753, 6), 34}, // Round in glsl_std_450 - {IR(45759, 10), 35}, // RoundEven in glsl_std_450 - {IR(45780, 5), 38}, // SAbs in glsl_std_450 - {IR(46021, 7), 78}, // SClamp in glsl_std_450 - {IR(46002, 5), 75}, // SMax in glsl_std_450 - {IR(45987, 5), 72}, // SMin in glsl_std_450 - {IR(45791, 6), 40}, // SSign in glsl_std_450 - {IR(45830, 4), 46}, // Sin in glsl_std_450 - {IR(45857, 5), 52}, // Sinh in glsl_std_450 - {IR(46043, 11), 82}, // SmoothStep in glsl_std_450 - {IR(45918, 5), 64}, // Sqrt in glsl_std_450 - {IR(46038, 5), 81}, // Step in glsl_std_450 - {IR(45838, 4), 48}, // Tan in glsl_std_450 - {IR(45867, 5), 54}, // Tanh in glsl_std_450 - {IR(45769, 6), 36}, // Trunc in glsl_std_450 - {IR(46014, 7), 77}, // UClamp in glsl_std_450 - {IR(45997, 5), 74}, // UMax in glsl_std_450 - {IR(45982, 5), 71}, // UMin in glsl_std_450 - {IR(46241, 17), 98}, // UnpackDouble2x32 in glsl_std_450 - {IR(46196, 15), 95}, // UnpackHalf2x16 in glsl_std_450 - {IR(46164, 16), 93}, // UnpackSnorm2x16 in glsl_std_450 - {IR(46211, 15), 96}, // UnpackSnorm4x8 in glsl_std_450 - {IR(46180, 16), 94}, // UnpackUnorm2x16 in glsl_std_450 - {IR(46226, 15), 97}, // UnpackUnorm4x8 in glsl_std_450 - {IR(46424, 13), 116}, // ArgumentInfo in nonsemantic_clspvreflection - {IR(46519, 24), 121}, // ArgumentPodPushConstant in nonsemantic_clspvreflection - {IR(46475, 25), 119}, // ArgumentPodStorageBuffer in nonsemantic_clspvreflection - {IR(46500, 19), 120}, // ArgumentPodUniform in nonsemantic_clspvreflection - {IR(46953, 28), 140}, // ArgumentPointerPushConstant in nonsemantic_clspvreflection - {IR(46981, 23), 141}, // ArgumentPointerUniform in nonsemantic_clspvreflection - {IR(46543, 21), 122}, // ArgumentSampledImage in nonsemantic_clspvreflection - {IR(46585, 16), 124}, // ArgumentSampler in nonsemantic_clspvreflection - {IR(46437, 22), 117}, // ArgumentStorageBuffer in nonsemantic_clspvreflection - {IR(46564, 21), 123}, // ArgumentStorageImage in nonsemantic_clspvreflection - {IR(47241, 27), 148}, // ArgumentStorageTexelBuffer in nonsemantic_clspvreflection - {IR(46459, 16), 118}, // ArgumentUniform in nonsemantic_clspvreflection - {IR(47268, 27), 149}, // ArgumentUniformTexelBuffer in nonsemantic_clspvreflection - {IR(46601, 18), 125}, // ArgumentWorkgroup in nonsemantic_clspvreflection - {IR(47295, 32), 150}, // ConstantDataPointerPushConstant in nonsemantic_clspvreflection - {IR(46849, 26), 135}, // ConstantDataStorageBuffer in nonsemantic_clspvreflection - {IR(46875, 20), 136}, // ConstantDataUniform in nonsemantic_clspvreflection - {IR(47119, 45), 145}, // ImageArgumentInfoChannelDataTypePushConstant in nonsemantic_clspvreflection - {IR(47201, 40), 147}, // ImageArgumentInfoChannelDataTypeUniform in nonsemantic_clspvreflection - {IR(47077, 42), 144}, // ImageArgumentInfoChannelOrderPushConstant in nonsemantic_clspvreflection - {IR(47164, 37), 146}, // ImageArgumentInfoChannelOrderUniform in nonsemantic_clspvreflection - {IR(4549, 7), 115}, // Kernel in nonsemantic_clspvreflection - {IR(7974, 15), 137}, // LiteralSampler in nonsemantic_clspvreflection - {IR(47436, 34), 155}, // NormalizedSamplerMaskPushConstant in nonsemantic_clspvreflection - {IR(47404, 32), 154}, // PrintfBufferPointerPushConstant in nonsemantic_clspvreflection - {IR(47378, 26), 153}, // PrintfBufferStorageBuffer in nonsemantic_clspvreflection - {IR(47367, 11), 152}, // PrintfInfo in nonsemantic_clspvreflection - {IR(47327, 40), 151}, // ProgramScopeVariablePointerPushConstant in nonsemantic_clspvreflection - {IR(47039, 38), 143}, // ProgramScopeVariablePointerRelocation in nonsemantic_clspvreflection - {IR(47004, 35), 142}, // ProgramScopeVariablesStorageBuffer in nonsemantic_clspvreflection - {IR(46895, 30), 138}, // PropertyRequiredWorkgroupSize in nonsemantic_clspvreflection - {IR(46715, 30), 130}, // PushConstantEnqueuedLocalSize in nonsemantic_clspvreflection - {IR(46690, 25), 129}, // PushConstantGlobalOffset in nonsemantic_clspvreflection - {IR(46745, 23), 131}, // PushConstantGlobalSize in nonsemantic_clspvreflection - {IR(46793, 26), 133}, // PushConstantNumWorkgroups in nonsemantic_clspvreflection - {IR(46819, 30), 134}, // PushConstantRegionGroupOffset in nonsemantic_clspvreflection - {IR(46768, 25), 132}, // PushConstantRegionOffset in nonsemantic_clspvreflection - {IR(46645, 25), 127}, // SpecConstantGlobalOffset in nonsemantic_clspvreflection - {IR(46925, 28), 139}, // SpecConstantSubgroupMaxSize in nonsemantic_clspvreflection - {IR(46670, 20), 128}, // SpecConstantWorkDim in nonsemantic_clspvreflection - {IR(46619, 26), 126}, // SpecConstantWorkgroupSize in nonsemantic_clspvreflection - {IR(47470, 22), 156}, // WorkgroupVariableSize in nonsemantic_clspvreflection - {IR(47591, 21), 197}, // DebugBuildIdentifier in nonsemantic_shader_debuginfo_100 - {IR(44908, 21), 158}, // DebugCompilationUnit in nonsemantic_shader_debuginfo_100 - {IR(45635, 13), 185}, // DebugDeclare in nonsemantic_shader_debuginfo_100 - {IR(47629, 16), 199}, // DebugEntryPoint in nonsemantic_shader_debuginfo_100 - {IR(45707, 16), 188}, // DebugExpression in nonsemantic_shader_debuginfo_100 - {IR(45451, 14), 177}, // DebugFunction in nonsemantic_shader_debuginfo_100 - {IR(45426, 25), 176}, // DebugFunctionDeclaration in nonsemantic_shader_debuginfo_100 - {IR(47524, 24), 193}, // DebugFunctionDefinition in nonsemantic_shader_debuginfo_100 - {IR(45406, 20), 175}, // DebugGlobalVariable in nonsemantic_shader_debuginfo_100 - {IR(47492, 20), 191}, // DebugImportedEntity in nonsemantic_shader_debuginfo_100 - {IR(44894, 14), 157}, // DebugInfoNone in nonsemantic_shader_debuginfo_100 - {IR(45538, 15), 182}, // DebugInlinedAt in nonsemantic_shader_debuginfo_100 - {IR(45614, 21), 184}, // DebugInlinedVariable in nonsemantic_shader_debuginfo_100 - {IR(45465, 18), 178}, // DebugLexicalBlock in nonsemantic_shader_debuginfo_100 - {IR(45483, 31), 179}, // DebugLexicalBlockDiscriminator in nonsemantic_shader_debuginfo_100 - {IR(47569, 10), 195}, // DebugLine in nonsemantic_shader_debuginfo_100 - {IR(45595, 19), 183}, // DebugLocalVariable in nonsemantic_shader_debuginfo_100 - {IR(45723, 14), 189}, // DebugMacroDef in nonsemantic_shader_debuginfo_100 - {IR(45737, 16), 190}, // DebugMacroUndef in nonsemantic_shader_debuginfo_100 - {IR(47579, 12), 196}, // DebugNoLine in nonsemantic_shader_debuginfo_100 - {IR(45525, 13), 181}, // DebugNoScope in nonsemantic_shader_debuginfo_100 - {IR(45692, 15), 187}, // DebugOperation in nonsemantic_shader_debuginfo_100 - {IR(45514, 11), 180}, // DebugScope in nonsemantic_shader_debuginfo_100 - {IR(47512, 12), 192}, // DebugSource in nonsemantic_shader_debuginfo_100 - {IR(47548, 21), 194}, // DebugSourceContinued in nonsemantic_shader_debuginfo_100 - {IR(47612, 17), 198}, // DebugStoragePath in nonsemantic_shader_debuginfo_100 - {IR(45104, 15), 162}, // DebugTypeArray in nonsemantic_shader_debuginfo_100 - {IR(44981, 15), 159}, // DebugTypeBasic in nonsemantic_shader_debuginfo_100 - {IR(45218, 19), 167}, // DebugTypeComposite in nonsemantic_shader_debuginfo_100 - {IR(45166, 14), 166}, // DebugTypeEnum in nonsemantic_shader_debuginfo_100 - {IR(45148, 18), 165}, // DebugTypeFunction in nonsemantic_shader_debuginfo_100 - {IR(45253, 21), 169}, // DebugTypeInheritance in nonsemantic_shader_debuginfo_100 - {IR(47645, 16), 200}, // DebugTypeMatrix in nonsemantic_shader_debuginfo_100 - {IR(45237, 16), 168}, // DebugTypeMember in nonsemantic_shader_debuginfo_100 - {IR(45030, 17), 160}, // DebugTypePointer in nonsemantic_shader_debuginfo_100 - {IR(45274, 21), 170}, // DebugTypePtrToMember in nonsemantic_shader_debuginfo_100 - {IR(45085, 19), 161}, // DebugTypeQualifier in nonsemantic_shader_debuginfo_100 - {IR(45295, 18), 171}, // DebugTypeTemplate in nonsemantic_shader_debuginfo_100 - {IR(45313, 27), 172}, // DebugTypeTemplateParameter in nonsemantic_shader_debuginfo_100 - {IR(45375, 31), 174}, // DebugTypeTemplateParameterPack in nonsemantic_shader_debuginfo_100 - {IR(45340, 35), 173}, // DebugTypeTemplateTemplateParameter in nonsemantic_shader_debuginfo_100 - {IR(45119, 16), 163}, // DebugTypeVector in nonsemantic_shader_debuginfo_100 - {IR(45135, 13), 164}, // DebugTypedef in nonsemantic_shader_debuginfo_100 - {IR(45648, 11), 186}, // DebugValue in nonsemantic_shader_debuginfo_100 - {IR(47661, 14), 201}, // Configuration in nonsemantic_vkspreflection - {IR(47737, 20), 206}, // DescriptorSetBuffer in nonsemantic_vkspreflection - {IR(47757, 19), 207}, // DescriptorSetImage in nonsemantic_vkspreflection - {IR(47776, 21), 208}, // DescriptorSetSampler in nonsemantic_vkspreflection - {IR(47700, 14), 204}, // PushConstants in nonsemantic_vkspreflection - {IR(47714, 23), 205}, // SpecializationMapEntry in nonsemantic_vkspreflection - {IR(47675, 13), 202}, // StartCounter in nonsemantic_vkspreflection - {IR(47688, 12), 203}, // StopCounter in nonsemantic_vkspreflection - {IR(44908, 21), 210}, // DebugCompilationUnit in opencl_debuginfo_100 - {IR(45635, 13), 237}, // DebugDeclare in opencl_debuginfo_100 - {IR(45707, 16), 240}, // DebugExpression in opencl_debuginfo_100 - {IR(45451, 14), 229}, // DebugFunction in opencl_debuginfo_100 - {IR(45426, 25), 228}, // DebugFunctionDeclaration in opencl_debuginfo_100 - {IR(45406, 20), 227}, // DebugGlobalVariable in opencl_debuginfo_100 - {IR(47492, 20), 243}, // DebugImportedEntity in opencl_debuginfo_100 - {IR(44894, 14), 209}, // DebugInfoNone in opencl_debuginfo_100 - {IR(45538, 15), 234}, // DebugInlinedAt in opencl_debuginfo_100 - {IR(45614, 21), 236}, // DebugInlinedVariable in opencl_debuginfo_100 - {IR(45465, 18), 230}, // DebugLexicalBlock in opencl_debuginfo_100 - {IR(45483, 31), 231}, // DebugLexicalBlockDiscriminator in opencl_debuginfo_100 - {IR(45595, 19), 235}, // DebugLocalVariable in opencl_debuginfo_100 - {IR(45723, 14), 241}, // DebugMacroDef in opencl_debuginfo_100 - {IR(45737, 16), 242}, // DebugMacroUndef in opencl_debuginfo_100 - {IR(48097, 17), 245}, // DebugModuleINTEL in opencl_debuginfo_100 - {IR(45525, 13), 233}, // DebugNoScope in opencl_debuginfo_100 - {IR(45692, 15), 239}, // DebugOperation in opencl_debuginfo_100 - {IR(45514, 11), 232}, // DebugScope in opencl_debuginfo_100 - {IR(47512, 12), 244}, // DebugSource in opencl_debuginfo_100 - {IR(45104, 15), 214}, // DebugTypeArray in opencl_debuginfo_100 - {IR(44981, 15), 211}, // DebugTypeBasic in opencl_debuginfo_100 - {IR(45218, 19), 219}, // DebugTypeComposite in opencl_debuginfo_100 - {IR(45166, 14), 218}, // DebugTypeEnum in opencl_debuginfo_100 - {IR(45148, 18), 217}, // DebugTypeFunction in opencl_debuginfo_100 - {IR(45253, 21), 221}, // DebugTypeInheritance in opencl_debuginfo_100 - {IR(45237, 16), 220}, // DebugTypeMember in opencl_debuginfo_100 - {IR(45030, 17), 212}, // DebugTypePointer in opencl_debuginfo_100 - {IR(45274, 21), 222}, // DebugTypePtrToMember in opencl_debuginfo_100 - {IR(45085, 19), 213}, // DebugTypeQualifier in opencl_debuginfo_100 - {IR(45295, 18), 223}, // DebugTypeTemplate in opencl_debuginfo_100 - {IR(45313, 27), 224}, // DebugTypeTemplateParameter in opencl_debuginfo_100 - {IR(45375, 31), 226}, // DebugTypeTemplateParameterPack in opencl_debuginfo_100 - {IR(45340, 35), 225}, // DebugTypeTemplateTemplateParameter in opencl_debuginfo_100 - {IR(45119, 16), 215}, // DebugTypeVector in opencl_debuginfo_100 - {IR(45135, 13), 216}, // DebugTypedef in opencl_debuginfo_100 - {IR(45648, 11), 238}, // DebugValue in opencl_debuginfo_100 - {IR(48114, 5), 246}, // acos in opencl_std_100 - {IR(48119, 6), 247}, // acosh in opencl_std_100 - {IR(48125, 7), 248}, // acospi in opencl_std_100 - {IR(48132, 5), 249}, // asin in opencl_std_100 - {IR(48137, 6), 250}, // asinh in opencl_std_100 - {IR(48143, 7), 251}, // asinpi in opencl_std_100 - {IR(48150, 5), 252}, // atan in opencl_std_100 - {IR(48155, 6), 253}, // atan2 in opencl_std_100 - {IR(48174, 8), 256}, // atan2pi in opencl_std_100 - {IR(48161, 6), 254}, // atanh in opencl_std_100 - {IR(48167, 7), 255}, // atanpi in opencl_std_100 - {IR(49365, 10), 402}, // bitselect in opencl_std_100 - {IR(48182, 5), 257}, // cbrt in opencl_std_100 - {IR(48187, 5), 258}, // ceil in opencl_std_100 - {IR(49037, 4), 367}, // clz in opencl_std_100 - {IR(48192, 9), 259}, // copysign in opencl_std_100 - {IR(48201, 4), 260}, // cos in opencl_std_100 - {IR(48205, 5), 261}, // cosh in opencl_std_100 - {IR(48210, 6), 262}, // cospi in opencl_std_100 - {IR(48881, 6), 350}, // cross in opencl_std_100 - {IR(49041, 4), 368}, // ctz in opencl_std_100 - {IR(48816, 8), 342}, // degrees in opencl_std_100 - {IR(48887, 9), 351}, // distance in opencl_std_100 - {IR(48221, 4), 264}, // erf in opencl_std_100 - {IR(48216, 5), 263}, // erfc in opencl_std_100 - {IR(48225, 4), 265}, // exp in opencl_std_100 - {IR(48234, 6), 267}, // exp10 in opencl_std_100 - {IR(48229, 5), 266}, // exp2 in opencl_std_100 - {IR(48240, 6), 268}, // expm1 in opencl_std_100 - {IR(48246, 5), 269}, // fabs in opencl_std_100 - {IR(48913, 14), 354}, // fast_distance in opencl_std_100 - {IR(48927, 12), 355}, // fast_length in opencl_std_100 - {IR(48939, 15), 356}, // fast_normalize in opencl_std_100 - {IR(48809, 7), 341}, // fclamp in opencl_std_100 - {IR(48251, 5), 270}, // fdim in opencl_std_100 - {IR(48256, 6), 271}, // floor in opencl_std_100 - {IR(48262, 4), 272}, // fma in opencl_std_100 - {IR(48266, 5), 273}, // fmax in opencl_std_100 - {IR(48824, 12), 343}, // fmax_common in opencl_std_100 - {IR(48271, 5), 274}, // fmin in opencl_std_100 - {IR(48836, 12), 344}, // fmin_common in opencl_std_100 - {IR(48276, 5), 275}, // fmod in opencl_std_100 - {IR(48281, 6), 276}, // fract in opencl_std_100 - {IR(48287, 6), 277}, // frexp in opencl_std_100 - {IR(48499, 9), 313}, // half_cos in opencl_std_100 - {IR(48508, 12), 314}, // half_divide in opencl_std_100 - {IR(48520, 9), 315}, // half_exp in opencl_std_100 - {IR(48539, 11), 317}, // half_exp10 in opencl_std_100 - {IR(48529, 10), 316}, // half_exp2 in opencl_std_100 - {IR(48550, 9), 318}, // half_log in opencl_std_100 - {IR(48569, 11), 320}, // half_log10 in opencl_std_100 - {IR(48559, 10), 319}, // half_log2 in opencl_std_100 - {IR(48580, 10), 321}, // half_powr in opencl_std_100 - {IR(48590, 11), 322}, // half_recip in opencl_std_100 - {IR(48601, 11), 323}, // half_rsqrt in opencl_std_100 - {IR(48612, 9), 324}, // half_sin in opencl_std_100 - {IR(48621, 10), 325}, // half_sqrt in opencl_std_100 - {IR(48631, 9), 326}, // half_tan in opencl_std_100 - {IR(48293, 6), 278}, // hypot in opencl_std_100 - {IR(48299, 6), 279}, // ilogb in opencl_std_100 - {IR(48305, 6), 280}, // ldexp in opencl_std_100 - {IR(48896, 7), 352}, // length in opencl_std_100 - {IR(48311, 7), 281}, // lgamma in opencl_std_100 - {IR(48318, 9), 282}, // lgamma_r in opencl_std_100 - {IR(48327, 4), 283}, // log in opencl_std_100 - {IR(48336, 6), 285}, // log10 in opencl_std_100 - {IR(48342, 6), 286}, // log1p in opencl_std_100 - {IR(48331, 5), 284}, // log2 in opencl_std_100 - {IR(48348, 5), 287}, // logb in opencl_std_100 - {IR(48353, 4), 288}, // mad in opencl_std_100 - {IR(48357, 7), 289}, // maxmag in opencl_std_100 - {IR(48364, 7), 290}, // minmag in opencl_std_100 - {IR(48848, 4), 345}, // mix in opencl_std_100 - {IR(48371, 5), 291}, // modf in opencl_std_100 - {IR(48376, 4), 292}, // nan in opencl_std_100 - {IR(48640, 11), 327}, // native_cos in opencl_std_100 - {IR(48651, 14), 328}, // native_divide in opencl_std_100 - {IR(48665, 11), 329}, // native_exp in opencl_std_100 - {IR(48688, 13), 331}, // native_exp10 in opencl_std_100 - {IR(48676, 12), 330}, // native_exp2 in opencl_std_100 - {IR(48701, 11), 332}, // native_log in opencl_std_100 - {IR(48724, 13), 334}, // native_log10 in opencl_std_100 - {IR(48712, 12), 333}, // native_log2 in opencl_std_100 - {IR(48737, 12), 335}, // native_powr in opencl_std_100 - {IR(48749, 13), 336}, // native_recip in opencl_std_100 - {IR(48762, 13), 337}, // native_rsqrt in opencl_std_100 - {IR(48775, 11), 338}, // native_sin in opencl_std_100 - {IR(48786, 12), 339}, // native_sqrt in opencl_std_100 - {IR(48798, 11), 340}, // native_tan in opencl_std_100 - {IR(48380, 10), 293}, // nextafter in opencl_std_100 - {IR(48903, 10), 353}, // normalize in opencl_std_100 - {IR(49156, 9), 382}, // popcount in opencl_std_100 - {IR(48390, 4), 294}, // pow in opencl_std_100 - {IR(48394, 5), 295}, // pown in opencl_std_100 - {IR(48399, 5), 296}, // powr in opencl_std_100 - {IR(49356, 9), 401}, // prefetch in opencl_std_100 - {IR(49349, 7), 400}, // printf in opencl_std_100 - {IR(48852, 8), 346}, // radians in opencl_std_100 - {IR(48404, 10), 297}, // remainder in opencl_std_100 - {IR(48414, 7), 298}, // remquo in opencl_std_100 - {IR(48421, 5), 299}, // rint in opencl_std_100 - {IR(48426, 6), 300}, // rootn in opencl_std_100 - {IR(49107, 7), 377}, // rotate in opencl_std_100 - {IR(48432, 6), 301}, // round in opencl_std_100 - {IR(48438, 6), 302}, // rsqrt in opencl_std_100 - {IR(48954, 6), 357}, // s_abs in opencl_std_100 - {IR(48960, 11), 358}, // s_abs_diff in opencl_std_100 - {IR(48971, 10), 359}, // s_add_sat in opencl_std_100 - {IR(49021, 8), 365}, // s_clamp in opencl_std_100 - {IR(48991, 7), 361}, // s_hadd in opencl_std_100 - {IR(49165, 8), 383}, // s_mad24 in opencl_std_100 - {IR(49045, 9), 369}, // s_mad_hi in opencl_std_100 - {IR(49064, 10), 371}, // s_mad_sat in opencl_std_100 - {IR(49074, 6), 372}, // s_max in opencl_std_100 - {IR(49086, 6), 374}, // s_min in opencl_std_100 - {IR(49181, 8), 385}, // s_mul24 in opencl_std_100 - {IR(49098, 9), 376}, // s_mul_hi in opencl_std_100 - {IR(49005, 8), 363}, // s_rhadd in opencl_std_100 - {IR(49114, 10), 378}, // s_sub_sat in opencl_std_100 - {IR(49145, 11), 381}, // s_upsample in opencl_std_100 - {IR(49375, 7), 403}, // select in opencl_std_100 - {IR(49332, 8), 398}, // shuffle in opencl_std_100 - {IR(49340, 9), 399}, // shuffle2 in opencl_std_100 - {IR(48876, 5), 349}, // sign in opencl_std_100 - {IR(48444, 4), 303}, // sin in opencl_std_100 - {IR(48448, 7), 304}, // sincos in opencl_std_100 - {IR(48455, 5), 305}, // sinh in opencl_std_100 - {IR(48460, 6), 306}, // sinpi in opencl_std_100 - {IR(48865, 11), 348}, // smoothstep in opencl_std_100 - {IR(48466, 5), 307}, // sqrt in opencl_std_100 - {IR(48860, 5), 347}, // step in opencl_std_100 - {IR(48471, 4), 308}, // tan in opencl_std_100 - {IR(48475, 5), 309}, // tanh in opencl_std_100 - {IR(48480, 6), 310}, // tanpi in opencl_std_100 - {IR(48486, 7), 311}, // tgamma in opencl_std_100 - {IR(48493, 6), 312}, // trunc in opencl_std_100 - {IR(49382, 6), 404}, // u_abs in opencl_std_100 - {IR(49388, 11), 405}, // u_abs_diff in opencl_std_100 - {IR(48981, 10), 360}, // u_add_sat in opencl_std_100 - {IR(49029, 8), 366}, // u_clamp in opencl_std_100 - {IR(48998, 7), 362}, // u_hadd in opencl_std_100 - {IR(49173, 8), 384}, // u_mad24 in opencl_std_100 - {IR(49408, 9), 407}, // u_mad_hi in opencl_std_100 - {IR(49054, 10), 370}, // u_mad_sat in opencl_std_100 - {IR(49080, 6), 373}, // u_max in opencl_std_100 - {IR(49092, 6), 375}, // u_min in opencl_std_100 - {IR(49189, 8), 386}, // u_mul24 in opencl_std_100 - {IR(49399, 9), 406}, // u_mul_hi in opencl_std_100 - {IR(49013, 8), 364}, // u_rhadd in opencl_std_100 - {IR(49124, 10), 379}, // u_sub_sat in opencl_std_100 - {IR(49134, 11), 380}, // u_upsample in opencl_std_100 - {IR(49212, 11), 389}, // vload_half in opencl_std_100 - {IR(49223, 12), 390}, // vload_halfn in opencl_std_100 - {IR(49289, 13), 395}, // vloada_halfn in opencl_std_100 - {IR(49197, 7), 387}, // vloadn in opencl_std_100 - {IR(49235, 12), 391}, // vstore_half in opencl_std_100 - {IR(49247, 14), 392}, // vstore_half_r in opencl_std_100 - {IR(49261, 13), 393}, // vstore_halfn in opencl_std_100 - {IR(49274, 15), 394}, // vstore_halfn_r in opencl_std_100 - {IR(49302, 14), 396}, // vstorea_halfn in opencl_std_100 - {IR(49316, 16), 397}, // vstorea_halfn_r in opencl_std_100 - {IR(49204, 8), 388}, // vstoren in opencl_std_100 - {IR(49434, 17), 409}, // CubeFaceCoordAMD in spv_amd_gcn_shader - {IR(49417, 17), 408}, // CubeFaceIndexAMD in spv_amd_gcn_shader - {IR(49451, 8), 410}, // TimeAMD in spv_amd_gcn_shader - {IR(49528, 9), 414}, // MbcntAMD in spv_amd_shader_ballot - {IR(49459, 22), 411}, // SwizzleInvocationsAMD in spv_amd_shader_ballot - {IR(49481, 28), 412}, // SwizzleInvocationsMaskedAMD in spv_amd_shader_ballot - {IR(49509, 19), 413}, // WriteInvocationAMD in spv_amd_shader_ballot - {IR(49537, 23), 415}, // InterpolateAtVertexAMD in spv_amd_shader_explicit_vertex_parameter - {IR(49587, 9), 419}, // FMax3AMD in spv_amd_shader_trinary_minmax - {IR(49614, 9), 422}, // FMid3AMD in spv_amd_shader_trinary_minmax - {IR(49560, 9), 416}, // FMin3AMD in spv_amd_shader_trinary_minmax - {IR(49605, 9), 421}, // SMax3AMD in spv_amd_shader_trinary_minmax - {IR(49632, 9), 424}, // SMid3AMD in spv_amd_shader_trinary_minmax - {IR(49578, 9), 418}, // SMin3AMD in spv_amd_shader_trinary_minmax - {IR(49596, 9), 420}, // UMax3AMD in spv_amd_shader_trinary_minmax - {IR(49623, 9), 423}, // UMid3AMD in spv_amd_shader_trinary_minmax - {IR(49569, 9), 417}, // UMin3AMD in spv_amd_shader_trinary_minmax + {IR(45624, 21), 1}, // DebugCompilationUnit in debuginfo + {IR(46351, 13), 28}, // DebugDeclare in debuginfo + {IR(46423, 16), 31}, // DebugExpression in debuginfo + {IR(46167, 14), 20}, // DebugFunction in debuginfo + {IR(46142, 25), 19}, // DebugFunctionDeclaration in debuginfo + {IR(46122, 20), 18}, // DebugGlobalVariable in debuginfo + {IR(45610, 14), 0}, // DebugInfoNone in debuginfo + {IR(46254, 15), 25}, // DebugInlinedAt in debuginfo + {IR(46330, 21), 27}, // DebugInlinedVariable in debuginfo + {IR(46181, 18), 21}, // DebugLexicalBlock in debuginfo + {IR(46199, 31), 22}, // DebugLexicalBlockDiscriminator in debuginfo + {IR(46311, 19), 26}, // DebugLocalVariable in debuginfo + {IR(46439, 14), 32}, // DebugMacroDef in debuginfo + {IR(46453, 16), 33}, // DebugMacroUndef in debuginfo + {IR(46241, 13), 24}, // DebugNoScope in debuginfo + {IR(46408, 15), 30}, // DebugOperation in debuginfo + {IR(46230, 11), 23}, // DebugScope in debuginfo + {IR(45820, 15), 5}, // DebugTypeArray in debuginfo + {IR(45697, 15), 2}, // DebugTypeBasic in debuginfo + {IR(45934, 19), 10}, // DebugTypeComposite in debuginfo + {IR(45882, 14), 9}, // DebugTypeEnum in debuginfo + {IR(45864, 18), 8}, // DebugTypeFunction in debuginfo + {IR(45969, 21), 12}, // DebugTypeInheritance in debuginfo + {IR(45953, 16), 11}, // DebugTypeMember in debuginfo + {IR(45746, 17), 3}, // DebugTypePointer in debuginfo + {IR(45990, 21), 13}, // DebugTypePtrToMember in debuginfo + {IR(45801, 19), 4}, // DebugTypeQualifier in debuginfo + {IR(46011, 18), 14}, // DebugTypeTemplate in debuginfo + {IR(46029, 27), 15}, // DebugTypeTemplateParameter in debuginfo + {IR(46091, 31), 17}, // DebugTypeTemplateParameterPack in debuginfo + {IR(46056, 35), 16}, // DebugTypeTemplateTemplateParameter in debuginfo + {IR(45835, 16), 6}, // DebugTypeVector in debuginfo + {IR(45851, 13), 7}, // DebugTypedef in debuginfo + {IR(46364, 11), 29}, // DebugValue in debuginfo + {IR(46563, 5), 50}, // Acos in glsl_std_450 + {IR(46594, 6), 56}, // Acosh in glsl_std_450 + {IR(46558, 5), 49}, // Asin in glsl_std_450 + {IR(46588, 6), 55}, // Asinh in glsl_std_450 + {IR(46568, 5), 51}, // Atan in glsl_std_450 + {IR(46606, 6), 58}, // Atan2 in glsl_std_450 + {IR(46600, 6), 57}, // Atanh in glsl_std_450 + {IR(46519, 5), 42}, // Ceil in glsl_std_450 + {IR(46550, 4), 47}, // Cos in glsl_std_450 + {IR(46578, 5), 53}, // Cosh in glsl_std_450 + {IR(46990, 6), 101}, // Cross in glsl_std_450 + {IR(46538, 8), 45}, // Degrees in glsl_std_450 + {IR(46651, 12), 66}, // Determinant in glsl_std_450 + {IR(46981, 9), 100}, // Distance in glsl_std_450 + {IR(46616, 4), 60}, // Exp in glsl_std_450 + {IR(46624, 5), 62}, // Exp2 in glsl_std_450 + {IR(46491, 5), 37}, // FAbs in glsl_std_450 + {IR(46723, 7), 76}, // FClamp in glsl_std_450 + {IR(46708, 5), 73}, // FMax in glsl_std_450 + {IR(46693, 5), 70}, // FMin in glsl_std_450 + {IR(46744, 5), 79}, // FMix in glsl_std_450 + {IR(46501, 6), 39}, // FSign in glsl_std_450 + {IR(47006, 12), 103}, // FaceForward in glsl_std_450 + {IR(47034, 9), 106}, // FindILsb in glsl_std_450 + {IR(47043, 9), 107}, // FindSMsb in glsl_std_450 + {IR(47052, 9), 108}, // FindUMsb in glsl_std_450 + {IR(46513, 6), 41}, // Floor in glsl_std_450 + {IR(46770, 4), 83}, // Fma in glsl_std_450 + {IR(46524, 6), 43}, // Fract in glsl_std_450 + {IR(46774, 6), 84}, // Frexp in glsl_std_450 + {IR(46780, 12), 85}, // FrexpStruct in glsl_std_450 + {IR(46749, 5), 80}, // IMix in glsl_std_450 + {IR(47061, 22), 109}, // InterpolateAtCentroid in glsl_std_450 + {IR(47103, 20), 111}, // InterpolateAtOffset in glsl_std_450 + {IR(47083, 20), 110}, // InterpolateAtSample in glsl_std_450 + {IR(46639, 12), 65}, // InverseSqrt in glsl_std_450 + {IR(46792, 6), 86}, // Ldexp in glsl_std_450 + {IR(46974, 7), 99}, // Length in glsl_std_450 + {IR(46620, 4), 61}, // Log in glsl_std_450 + {IR(46629, 5), 63}, // Log2 in glsl_std_450 + {IR(46663, 14), 67}, // MatrixInverse in glsl_std_450 + {IR(46677, 5), 68}, // Modf in glsl_std_450 + {IR(46682, 11), 69}, // ModfStruct in glsl_std_450 + {IR(47133, 7), 114}, // NClamp in glsl_std_450 + {IR(47128, 5), 113}, // NMax in glsl_std_450 + {IR(47123, 5), 112}, // NMin in glsl_std_450 + {IR(46996, 10), 102}, // Normalize in glsl_std_450 + {IR(46865, 15), 92}, // PackDouble2x32 in glsl_std_450 + {IR(46852, 13), 91}, // PackHalf2x16 in glsl_std_450 + {IR(46824, 14), 89}, // PackSnorm2x16 in glsl_std_450 + {IR(46798, 13), 87}, // PackSnorm4x8 in glsl_std_450 + {IR(46838, 14), 90}, // PackUnorm2x16 in glsl_std_450 + {IR(46811, 13), 88}, // PackUnorm4x8 in glsl_std_450 + {IR(46612, 4), 59}, // Pow in glsl_std_450 + {IR(46530, 8), 44}, // Radians in glsl_std_450 + {IR(47018, 8), 104}, // Reflect in glsl_std_450 + {IR(47026, 8), 105}, // Refract in glsl_std_450 + {IR(46469, 6), 34}, // Round in glsl_std_450 + {IR(46475, 10), 35}, // RoundEven in glsl_std_450 + {IR(46496, 5), 38}, // SAbs in glsl_std_450 + {IR(46737, 7), 78}, // SClamp in glsl_std_450 + {IR(46718, 5), 75}, // SMax in glsl_std_450 + {IR(46703, 5), 72}, // SMin in glsl_std_450 + {IR(46507, 6), 40}, // SSign in glsl_std_450 + {IR(46546, 4), 46}, // Sin in glsl_std_450 + {IR(46573, 5), 52}, // Sinh in glsl_std_450 + {IR(46759, 11), 82}, // SmoothStep in glsl_std_450 + {IR(46634, 5), 64}, // Sqrt in glsl_std_450 + {IR(46754, 5), 81}, // Step in glsl_std_450 + {IR(46554, 4), 48}, // Tan in glsl_std_450 + {IR(46583, 5), 54}, // Tanh in glsl_std_450 + {IR(46485, 6), 36}, // Trunc in glsl_std_450 + {IR(46730, 7), 77}, // UClamp in glsl_std_450 + {IR(46713, 5), 74}, // UMax in glsl_std_450 + {IR(46698, 5), 71}, // UMin in glsl_std_450 + {IR(46957, 17), 98}, // UnpackDouble2x32 in glsl_std_450 + {IR(46912, 15), 95}, // UnpackHalf2x16 in glsl_std_450 + {IR(46880, 16), 93}, // UnpackSnorm2x16 in glsl_std_450 + {IR(46927, 15), 96}, // UnpackSnorm4x8 in glsl_std_450 + {IR(46896, 16), 94}, // UnpackUnorm2x16 in glsl_std_450 + {IR(46942, 15), 97}, // UnpackUnorm4x8 in glsl_std_450 + {IR(47140, 13), 116}, // ArgumentInfo in nonsemantic_clspvreflection + {IR(47235, 24), 121}, // ArgumentPodPushConstant in nonsemantic_clspvreflection + {IR(47191, 25), 119}, // ArgumentPodStorageBuffer in nonsemantic_clspvreflection + {IR(47216, 19), 120}, // ArgumentPodUniform in nonsemantic_clspvreflection + {IR(47669, 28), 140}, // ArgumentPointerPushConstant in nonsemantic_clspvreflection + {IR(47697, 23), 141}, // ArgumentPointerUniform in nonsemantic_clspvreflection + {IR(47259, 21), 122}, // ArgumentSampledImage in nonsemantic_clspvreflection + {IR(47301, 16), 124}, // ArgumentSampler in nonsemantic_clspvreflection + {IR(47153, 22), 117}, // ArgumentStorageBuffer in nonsemantic_clspvreflection + {IR(47280, 21), 123}, // ArgumentStorageImage in nonsemantic_clspvreflection + {IR(47957, 27), 148}, // ArgumentStorageTexelBuffer in nonsemantic_clspvreflection + {IR(47175, 16), 118}, // ArgumentUniform in nonsemantic_clspvreflection + {IR(47984, 27), 149}, // ArgumentUniformTexelBuffer in nonsemantic_clspvreflection + {IR(47317, 18), 125}, // ArgumentWorkgroup in nonsemantic_clspvreflection + {IR(48011, 32), 150}, // ConstantDataPointerPushConstant in nonsemantic_clspvreflection + {IR(47565, 26), 135}, // ConstantDataStorageBuffer in nonsemantic_clspvreflection + {IR(47591, 20), 136}, // ConstantDataUniform in nonsemantic_clspvreflection + {IR(47835, 45), 145}, // ImageArgumentInfoChannelDataTypePushConstant in nonsemantic_clspvreflection + {IR(47917, 40), 147}, // ImageArgumentInfoChannelDataTypeUniform in nonsemantic_clspvreflection + {IR(47793, 42), 144}, // ImageArgumentInfoChannelOrderPushConstant in nonsemantic_clspvreflection + {IR(47880, 37), 146}, // ImageArgumentInfoChannelOrderUniform in nonsemantic_clspvreflection + {IR(4642, 7), 115}, // Kernel in nonsemantic_clspvreflection + {IR(8067, 15), 137}, // LiteralSampler in nonsemantic_clspvreflection + {IR(48152, 34), 155}, // NormalizedSamplerMaskPushConstant in nonsemantic_clspvreflection + {IR(48120, 32), 154}, // PrintfBufferPointerPushConstant in nonsemantic_clspvreflection + {IR(48094, 26), 153}, // PrintfBufferStorageBuffer in nonsemantic_clspvreflection + {IR(48083, 11), 152}, // PrintfInfo in nonsemantic_clspvreflection + {IR(48043, 40), 151}, // ProgramScopeVariablePointerPushConstant in nonsemantic_clspvreflection + {IR(47755, 38), 143}, // ProgramScopeVariablePointerRelocation in nonsemantic_clspvreflection + {IR(47720, 35), 142}, // ProgramScopeVariablesStorageBuffer in nonsemantic_clspvreflection + {IR(47611, 30), 138}, // PropertyRequiredWorkgroupSize in nonsemantic_clspvreflection + {IR(47431, 30), 130}, // PushConstantEnqueuedLocalSize in nonsemantic_clspvreflection + {IR(47406, 25), 129}, // PushConstantGlobalOffset in nonsemantic_clspvreflection + {IR(47461, 23), 131}, // PushConstantGlobalSize in nonsemantic_clspvreflection + {IR(47509, 26), 133}, // PushConstantNumWorkgroups in nonsemantic_clspvreflection + {IR(47535, 30), 134}, // PushConstantRegionGroupOffset in nonsemantic_clspvreflection + {IR(47484, 25), 132}, // PushConstantRegionOffset in nonsemantic_clspvreflection + {IR(47361, 25), 127}, // SpecConstantGlobalOffset in nonsemantic_clspvreflection + {IR(47641, 28), 139}, // SpecConstantSubgroupMaxSize in nonsemantic_clspvreflection + {IR(47386, 20), 128}, // SpecConstantWorkDim in nonsemantic_clspvreflection + {IR(47335, 26), 126}, // SpecConstantWorkgroupSize in nonsemantic_clspvreflection + {IR(48186, 22), 156}, // WorkgroupVariableSize in nonsemantic_clspvreflection + {IR(48307, 21), 197}, // DebugBuildIdentifier in nonsemantic_shader_debuginfo_100 + {IR(45624, 21), 158}, // DebugCompilationUnit in nonsemantic_shader_debuginfo_100 + {IR(46351, 13), 185}, // DebugDeclare in nonsemantic_shader_debuginfo_100 + {IR(48345, 16), 199}, // DebugEntryPoint in nonsemantic_shader_debuginfo_100 + {IR(46423, 16), 188}, // DebugExpression in nonsemantic_shader_debuginfo_100 + {IR(46167, 14), 177}, // DebugFunction in nonsemantic_shader_debuginfo_100 + {IR(46142, 25), 176}, // DebugFunctionDeclaration in nonsemantic_shader_debuginfo_100 + {IR(48240, 24), 193}, // DebugFunctionDefinition in nonsemantic_shader_debuginfo_100 + {IR(46122, 20), 175}, // DebugGlobalVariable in nonsemantic_shader_debuginfo_100 + {IR(48208, 20), 191}, // DebugImportedEntity in nonsemantic_shader_debuginfo_100 + {IR(45610, 14), 157}, // DebugInfoNone in nonsemantic_shader_debuginfo_100 + {IR(46254, 15), 182}, // DebugInlinedAt in nonsemantic_shader_debuginfo_100 + {IR(46330, 21), 184}, // DebugInlinedVariable in nonsemantic_shader_debuginfo_100 + {IR(46181, 18), 178}, // DebugLexicalBlock in nonsemantic_shader_debuginfo_100 + {IR(46199, 31), 179}, // DebugLexicalBlockDiscriminator in nonsemantic_shader_debuginfo_100 + {IR(48285, 10), 195}, // DebugLine in nonsemantic_shader_debuginfo_100 + {IR(46311, 19), 183}, // DebugLocalVariable in nonsemantic_shader_debuginfo_100 + {IR(46439, 14), 189}, // DebugMacroDef in nonsemantic_shader_debuginfo_100 + {IR(46453, 16), 190}, // DebugMacroUndef in nonsemantic_shader_debuginfo_100 + {IR(48295, 12), 196}, // DebugNoLine in nonsemantic_shader_debuginfo_100 + {IR(46241, 13), 181}, // DebugNoScope in nonsemantic_shader_debuginfo_100 + {IR(46408, 15), 187}, // DebugOperation in nonsemantic_shader_debuginfo_100 + {IR(46230, 11), 180}, // DebugScope in nonsemantic_shader_debuginfo_100 + {IR(48228, 12), 192}, // DebugSource in nonsemantic_shader_debuginfo_100 + {IR(48264, 21), 194}, // DebugSourceContinued in nonsemantic_shader_debuginfo_100 + {IR(48328, 17), 198}, // DebugStoragePath in nonsemantic_shader_debuginfo_100 + {IR(45820, 15), 162}, // DebugTypeArray in nonsemantic_shader_debuginfo_100 + {IR(45697, 15), 159}, // DebugTypeBasic in nonsemantic_shader_debuginfo_100 + {IR(45934, 19), 167}, // DebugTypeComposite in nonsemantic_shader_debuginfo_100 + {IR(45882, 14), 166}, // DebugTypeEnum in nonsemantic_shader_debuginfo_100 + {IR(45864, 18), 165}, // DebugTypeFunction in nonsemantic_shader_debuginfo_100 + {IR(45969, 21), 169}, // DebugTypeInheritance in nonsemantic_shader_debuginfo_100 + {IR(48361, 16), 200}, // DebugTypeMatrix in nonsemantic_shader_debuginfo_100 + {IR(45953, 16), 168}, // DebugTypeMember in nonsemantic_shader_debuginfo_100 + {IR(45746, 17), 160}, // DebugTypePointer in nonsemantic_shader_debuginfo_100 + {IR(45990, 21), 170}, // DebugTypePtrToMember in nonsemantic_shader_debuginfo_100 + {IR(45801, 19), 161}, // DebugTypeQualifier in nonsemantic_shader_debuginfo_100 + {IR(46011, 18), 171}, // DebugTypeTemplate in nonsemantic_shader_debuginfo_100 + {IR(46029, 27), 172}, // DebugTypeTemplateParameter in nonsemantic_shader_debuginfo_100 + {IR(46091, 31), 174}, // DebugTypeTemplateParameterPack in nonsemantic_shader_debuginfo_100 + {IR(46056, 35), 173}, // DebugTypeTemplateTemplateParameter in nonsemantic_shader_debuginfo_100 + {IR(45835, 16), 163}, // DebugTypeVector in nonsemantic_shader_debuginfo_100 + {IR(45851, 13), 164}, // DebugTypedef in nonsemantic_shader_debuginfo_100 + {IR(46364, 11), 186}, // DebugValue in nonsemantic_shader_debuginfo_100 + {IR(48377, 14), 201}, // Configuration in nonsemantic_vkspreflection + {IR(48453, 20), 206}, // DescriptorSetBuffer in nonsemantic_vkspreflection + {IR(48473, 19), 207}, // DescriptorSetImage in nonsemantic_vkspreflection + {IR(48492, 21), 208}, // DescriptorSetSampler in nonsemantic_vkspreflection + {IR(48416, 14), 204}, // PushConstants in nonsemantic_vkspreflection + {IR(48430, 23), 205}, // SpecializationMapEntry in nonsemantic_vkspreflection + {IR(48391, 13), 202}, // StartCounter in nonsemantic_vkspreflection + {IR(48404, 12), 203}, // StopCounter in nonsemantic_vkspreflection + {IR(45624, 21), 210}, // DebugCompilationUnit in opencl_debuginfo_100 + {IR(46351, 13), 237}, // DebugDeclare in opencl_debuginfo_100 + {IR(46423, 16), 240}, // DebugExpression in opencl_debuginfo_100 + {IR(46167, 14), 229}, // DebugFunction in opencl_debuginfo_100 + {IR(46142, 25), 228}, // DebugFunctionDeclaration in opencl_debuginfo_100 + {IR(46122, 20), 227}, // DebugGlobalVariable in opencl_debuginfo_100 + {IR(48208, 20), 243}, // DebugImportedEntity in opencl_debuginfo_100 + {IR(45610, 14), 209}, // DebugInfoNone in opencl_debuginfo_100 + {IR(46254, 15), 234}, // DebugInlinedAt in opencl_debuginfo_100 + {IR(46330, 21), 236}, // DebugInlinedVariable in opencl_debuginfo_100 + {IR(46181, 18), 230}, // DebugLexicalBlock in opencl_debuginfo_100 + {IR(46199, 31), 231}, // DebugLexicalBlockDiscriminator in opencl_debuginfo_100 + {IR(46311, 19), 235}, // DebugLocalVariable in opencl_debuginfo_100 + {IR(46439, 14), 241}, // DebugMacroDef in opencl_debuginfo_100 + {IR(46453, 16), 242}, // DebugMacroUndef in opencl_debuginfo_100 + {IR(48813, 17), 245}, // DebugModuleINTEL in opencl_debuginfo_100 + {IR(46241, 13), 233}, // DebugNoScope in opencl_debuginfo_100 + {IR(46408, 15), 239}, // DebugOperation in opencl_debuginfo_100 + {IR(46230, 11), 232}, // DebugScope in opencl_debuginfo_100 + {IR(48228, 12), 244}, // DebugSource in opencl_debuginfo_100 + {IR(45820, 15), 214}, // DebugTypeArray in opencl_debuginfo_100 + {IR(45697, 15), 211}, // DebugTypeBasic in opencl_debuginfo_100 + {IR(45934, 19), 219}, // DebugTypeComposite in opencl_debuginfo_100 + {IR(45882, 14), 218}, // DebugTypeEnum in opencl_debuginfo_100 + {IR(45864, 18), 217}, // DebugTypeFunction in opencl_debuginfo_100 + {IR(45969, 21), 221}, // DebugTypeInheritance in opencl_debuginfo_100 + {IR(45953, 16), 220}, // DebugTypeMember in opencl_debuginfo_100 + {IR(45746, 17), 212}, // DebugTypePointer in opencl_debuginfo_100 + {IR(45990, 21), 222}, // DebugTypePtrToMember in opencl_debuginfo_100 + {IR(45801, 19), 213}, // DebugTypeQualifier in opencl_debuginfo_100 + {IR(46011, 18), 223}, // DebugTypeTemplate in opencl_debuginfo_100 + {IR(46029, 27), 224}, // DebugTypeTemplateParameter in opencl_debuginfo_100 + {IR(46091, 31), 226}, // DebugTypeTemplateParameterPack in opencl_debuginfo_100 + {IR(46056, 35), 225}, // DebugTypeTemplateTemplateParameter in opencl_debuginfo_100 + {IR(45835, 16), 215}, // DebugTypeVector in opencl_debuginfo_100 + {IR(45851, 13), 216}, // DebugTypedef in opencl_debuginfo_100 + {IR(46364, 11), 238}, // DebugValue in opencl_debuginfo_100 + {IR(48830, 5), 246}, // acos in opencl_std_100 + {IR(48835, 6), 247}, // acosh in opencl_std_100 + {IR(48841, 7), 248}, // acospi in opencl_std_100 + {IR(48848, 5), 249}, // asin in opencl_std_100 + {IR(48853, 6), 250}, // asinh in opencl_std_100 + {IR(48859, 7), 251}, // asinpi in opencl_std_100 + {IR(48866, 5), 252}, // atan in opencl_std_100 + {IR(48871, 6), 253}, // atan2 in opencl_std_100 + {IR(48890, 8), 256}, // atan2pi in opencl_std_100 + {IR(48877, 6), 254}, // atanh in opencl_std_100 + {IR(48883, 7), 255}, // atanpi in opencl_std_100 + {IR(50081, 10), 402}, // bitselect in opencl_std_100 + {IR(48898, 5), 257}, // cbrt in opencl_std_100 + {IR(48903, 5), 258}, // ceil in opencl_std_100 + {IR(49753, 4), 367}, // clz in opencl_std_100 + {IR(48908, 9), 259}, // copysign in opencl_std_100 + {IR(48917, 4), 260}, // cos in opencl_std_100 + {IR(48921, 5), 261}, // cosh in opencl_std_100 + {IR(48926, 6), 262}, // cospi in opencl_std_100 + {IR(49597, 6), 350}, // cross in opencl_std_100 + {IR(49757, 4), 368}, // ctz in opencl_std_100 + {IR(49532, 8), 342}, // degrees in opencl_std_100 + {IR(49603, 9), 351}, // distance in opencl_std_100 + {IR(48937, 4), 264}, // erf in opencl_std_100 + {IR(48932, 5), 263}, // erfc in opencl_std_100 + {IR(48941, 4), 265}, // exp in opencl_std_100 + {IR(48950, 6), 267}, // exp10 in opencl_std_100 + {IR(48945, 5), 266}, // exp2 in opencl_std_100 + {IR(48956, 6), 268}, // expm1 in opencl_std_100 + {IR(48962, 5), 269}, // fabs in opencl_std_100 + {IR(49629, 14), 354}, // fast_distance in opencl_std_100 + {IR(49643, 12), 355}, // fast_length in opencl_std_100 + {IR(49655, 15), 356}, // fast_normalize in opencl_std_100 + {IR(49525, 7), 341}, // fclamp in opencl_std_100 + {IR(48967, 5), 270}, // fdim in opencl_std_100 + {IR(48972, 6), 271}, // floor in opencl_std_100 + {IR(48978, 4), 272}, // fma in opencl_std_100 + {IR(48982, 5), 273}, // fmax in opencl_std_100 + {IR(49540, 12), 343}, // fmax_common in opencl_std_100 + {IR(48987, 5), 274}, // fmin in opencl_std_100 + {IR(49552, 12), 344}, // fmin_common in opencl_std_100 + {IR(48992, 5), 275}, // fmod in opencl_std_100 + {IR(48997, 6), 276}, // fract in opencl_std_100 + {IR(49003, 6), 277}, // frexp in opencl_std_100 + {IR(49215, 9), 313}, // half_cos in opencl_std_100 + {IR(49224, 12), 314}, // half_divide in opencl_std_100 + {IR(49236, 9), 315}, // half_exp in opencl_std_100 + {IR(49255, 11), 317}, // half_exp10 in opencl_std_100 + {IR(49245, 10), 316}, // half_exp2 in opencl_std_100 + {IR(49266, 9), 318}, // half_log in opencl_std_100 + {IR(49285, 11), 320}, // half_log10 in opencl_std_100 + {IR(49275, 10), 319}, // half_log2 in opencl_std_100 + {IR(49296, 10), 321}, // half_powr in opencl_std_100 + {IR(49306, 11), 322}, // half_recip in opencl_std_100 + {IR(49317, 11), 323}, // half_rsqrt in opencl_std_100 + {IR(49328, 9), 324}, // half_sin in opencl_std_100 + {IR(49337, 10), 325}, // half_sqrt in opencl_std_100 + {IR(49347, 9), 326}, // half_tan in opencl_std_100 + {IR(49009, 6), 278}, // hypot in opencl_std_100 + {IR(49015, 6), 279}, // ilogb in opencl_std_100 + {IR(49021, 6), 280}, // ldexp in opencl_std_100 + {IR(49612, 7), 352}, // length in opencl_std_100 + {IR(49027, 7), 281}, // lgamma in opencl_std_100 + {IR(49034, 9), 282}, // lgamma_r in opencl_std_100 + {IR(49043, 4), 283}, // log in opencl_std_100 + {IR(49052, 6), 285}, // log10 in opencl_std_100 + {IR(49058, 6), 286}, // log1p in opencl_std_100 + {IR(49047, 5), 284}, // log2 in opencl_std_100 + {IR(49064, 5), 287}, // logb in opencl_std_100 + {IR(49069, 4), 288}, // mad in opencl_std_100 + {IR(49073, 7), 289}, // maxmag in opencl_std_100 + {IR(49080, 7), 290}, // minmag in opencl_std_100 + {IR(49564, 4), 345}, // mix in opencl_std_100 + {IR(49087, 5), 291}, // modf in opencl_std_100 + {IR(49092, 4), 292}, // nan in opencl_std_100 + {IR(49356, 11), 327}, // native_cos in opencl_std_100 + {IR(49367, 14), 328}, // native_divide in opencl_std_100 + {IR(49381, 11), 329}, // native_exp in opencl_std_100 + {IR(49404, 13), 331}, // native_exp10 in opencl_std_100 + {IR(49392, 12), 330}, // native_exp2 in opencl_std_100 + {IR(49417, 11), 332}, // native_log in opencl_std_100 + {IR(49440, 13), 334}, // native_log10 in opencl_std_100 + {IR(49428, 12), 333}, // native_log2 in opencl_std_100 + {IR(49453, 12), 335}, // native_powr in opencl_std_100 + {IR(49465, 13), 336}, // native_recip in opencl_std_100 + {IR(49478, 13), 337}, // native_rsqrt in opencl_std_100 + {IR(49491, 11), 338}, // native_sin in opencl_std_100 + {IR(49502, 12), 339}, // native_sqrt in opencl_std_100 + {IR(49514, 11), 340}, // native_tan in opencl_std_100 + {IR(49096, 10), 293}, // nextafter in opencl_std_100 + {IR(49619, 10), 353}, // normalize in opencl_std_100 + {IR(49872, 9), 382}, // popcount in opencl_std_100 + {IR(49106, 4), 294}, // pow in opencl_std_100 + {IR(49110, 5), 295}, // pown in opencl_std_100 + {IR(49115, 5), 296}, // powr in opencl_std_100 + {IR(50072, 9), 401}, // prefetch in opencl_std_100 + {IR(50065, 7), 400}, // printf in opencl_std_100 + {IR(49568, 8), 346}, // radians in opencl_std_100 + {IR(49120, 10), 297}, // remainder in opencl_std_100 + {IR(49130, 7), 298}, // remquo in opencl_std_100 + {IR(49137, 5), 299}, // rint in opencl_std_100 + {IR(49142, 6), 300}, // rootn in opencl_std_100 + {IR(49823, 7), 377}, // rotate in opencl_std_100 + {IR(49148, 6), 301}, // round in opencl_std_100 + {IR(49154, 6), 302}, // rsqrt in opencl_std_100 + {IR(49670, 6), 357}, // s_abs in opencl_std_100 + {IR(49676, 11), 358}, // s_abs_diff in opencl_std_100 + {IR(49687, 10), 359}, // s_add_sat in opencl_std_100 + {IR(49737, 8), 365}, // s_clamp in opencl_std_100 + {IR(49707, 7), 361}, // s_hadd in opencl_std_100 + {IR(49881, 8), 383}, // s_mad24 in opencl_std_100 + {IR(49761, 9), 369}, // s_mad_hi in opencl_std_100 + {IR(49780, 10), 371}, // s_mad_sat in opencl_std_100 + {IR(49790, 6), 372}, // s_max in opencl_std_100 + {IR(49802, 6), 374}, // s_min in opencl_std_100 + {IR(49897, 8), 385}, // s_mul24 in opencl_std_100 + {IR(49814, 9), 376}, // s_mul_hi in opencl_std_100 + {IR(49721, 8), 363}, // s_rhadd in opencl_std_100 + {IR(49830, 10), 378}, // s_sub_sat in opencl_std_100 + {IR(49861, 11), 381}, // s_upsample in opencl_std_100 + {IR(50091, 7), 403}, // select in opencl_std_100 + {IR(50048, 8), 398}, // shuffle in opencl_std_100 + {IR(50056, 9), 399}, // shuffle2 in opencl_std_100 + {IR(49592, 5), 349}, // sign in opencl_std_100 + {IR(49160, 4), 303}, // sin in opencl_std_100 + {IR(49164, 7), 304}, // sincos in opencl_std_100 + {IR(49171, 5), 305}, // sinh in opencl_std_100 + {IR(49176, 6), 306}, // sinpi in opencl_std_100 + {IR(49581, 11), 348}, // smoothstep in opencl_std_100 + {IR(49182, 5), 307}, // sqrt in opencl_std_100 + {IR(49576, 5), 347}, // step in opencl_std_100 + {IR(49187, 4), 308}, // tan in opencl_std_100 + {IR(49191, 5), 309}, // tanh in opencl_std_100 + {IR(49196, 6), 310}, // tanpi in opencl_std_100 + {IR(49202, 7), 311}, // tgamma in opencl_std_100 + {IR(49209, 6), 312}, // trunc in opencl_std_100 + {IR(50098, 6), 404}, // u_abs in opencl_std_100 + {IR(50104, 11), 405}, // u_abs_diff in opencl_std_100 + {IR(49697, 10), 360}, // u_add_sat in opencl_std_100 + {IR(49745, 8), 366}, // u_clamp in opencl_std_100 + {IR(49714, 7), 362}, // u_hadd in opencl_std_100 + {IR(49889, 8), 384}, // u_mad24 in opencl_std_100 + {IR(50124, 9), 407}, // u_mad_hi in opencl_std_100 + {IR(49770, 10), 370}, // u_mad_sat in opencl_std_100 + {IR(49796, 6), 373}, // u_max in opencl_std_100 + {IR(49808, 6), 375}, // u_min in opencl_std_100 + {IR(49905, 8), 386}, // u_mul24 in opencl_std_100 + {IR(50115, 9), 406}, // u_mul_hi in opencl_std_100 + {IR(49729, 8), 364}, // u_rhadd in opencl_std_100 + {IR(49840, 10), 379}, // u_sub_sat in opencl_std_100 + {IR(49850, 11), 380}, // u_upsample in opencl_std_100 + {IR(49928, 11), 389}, // vload_half in opencl_std_100 + {IR(49939, 12), 390}, // vload_halfn in opencl_std_100 + {IR(50005, 13), 395}, // vloada_halfn in opencl_std_100 + {IR(49913, 7), 387}, // vloadn in opencl_std_100 + {IR(49951, 12), 391}, // vstore_half in opencl_std_100 + {IR(49963, 14), 392}, // vstore_half_r in opencl_std_100 + {IR(49977, 13), 393}, // vstore_halfn in opencl_std_100 + {IR(49990, 15), 394}, // vstore_halfn_r in opencl_std_100 + {IR(50018, 14), 396}, // vstorea_halfn in opencl_std_100 + {IR(50032, 16), 397}, // vstorea_halfn_r in opencl_std_100 + {IR(49920, 8), 388}, // vstoren in opencl_std_100 + {IR(50150, 17), 409}, // CubeFaceCoordAMD in spv_amd_gcn_shader + {IR(50133, 17), 408}, // CubeFaceIndexAMD in spv_amd_gcn_shader + {IR(50167, 8), 410}, // TimeAMD in spv_amd_gcn_shader + {IR(50244, 9), 414}, // MbcntAMD in spv_amd_shader_ballot + {IR(50175, 22), 411}, // SwizzleInvocationsAMD in spv_amd_shader_ballot + {IR(50197, 28), 412}, // SwizzleInvocationsMaskedAMD in spv_amd_shader_ballot + {IR(50225, 19), 413}, // WriteInvocationAMD in spv_amd_shader_ballot + {IR(50253, 23), 415}, // InterpolateAtVertexAMD in spv_amd_shader_explicit_vertex_parameter + {IR(50303, 9), 419}, // FMax3AMD in spv_amd_shader_trinary_minmax + {IR(50330, 9), 422}, // FMid3AMD in spv_amd_shader_trinary_minmax + {IR(50276, 9), 416}, // FMin3AMD in spv_amd_shader_trinary_minmax + {IR(50321, 9), 421}, // SMax3AMD in spv_amd_shader_trinary_minmax + {IR(50348, 9), 424}, // SMid3AMD in spv_amd_shader_trinary_minmax + {IR(50294, 9), 418}, // SMin3AMD in spv_amd_shader_trinary_minmax + {IR(50312, 9), 420}, // UMax3AMD in spv_amd_shader_trinary_minmax + {IR(50339, 9), 423}, // UMid3AMD in spv_amd_shader_trinary_minmax + {IR(50285, 9), 417}, // UMin3AMD in spv_amd_shader_trinary_minmax }}; IndexRange ExtInstNameRangeForKind(spv_ext_inst_type_t type) { @@ -5548,2514 +5615,2546 @@ static const char kStrings[] = "SPV_AMD_texture_gather_bias_lod\0" // IR(337, 32) "SPV_ARM_cooperative_matrix_layouts\0" // IR(369, 35) "SPV_ARM_core_builtins\0" // IR(404, 22) - "SPV_ARM_tensors\0" // IR(426, 16) - "SPV_EXT_arithmetic_fence\0" // IR(442, 25) - "SPV_EXT_demote_to_helper_invocation\0" // IR(467, 36) - "SPV_EXT_descriptor_indexing\0" // IR(503, 28) - "SPV_EXT_float8\0" // IR(531, 15) - "SPV_EXT_fragment_fully_covered\0" // IR(546, 31) - "SPV_EXT_fragment_invocation_density\0" // IR(577, 36) - "SPV_EXT_fragment_shader_interlock\0" // IR(613, 34) - "SPV_EXT_mesh_shader\0" // IR(647, 20) - "SPV_EXT_opacity_micromap\0" // IR(667, 25) - "SPV_EXT_optnone\0" // IR(692, 16) - "SPV_EXT_physical_storage_buffer\0" // IR(708, 32) - "SPV_EXT_relaxed_printf_string_address_space\0" // IR(740, 44) - "SPV_EXT_replicated_composites\0" // IR(784, 30) - "SPV_EXT_shader_atomic_float16_add\0" // IR(814, 34) - "SPV_EXT_shader_atomic_float_add\0" // IR(848, 32) - "SPV_EXT_shader_atomic_float_min_max\0" // IR(880, 36) - "SPV_EXT_shader_image_int64\0" // IR(916, 27) - "SPV_EXT_shader_stencil_export\0" // IR(943, 30) - "SPV_EXT_shader_tile_image\0" // IR(973, 26) - "SPV_EXT_shader_viewport_index_layer\0" // IR(999, 36) - "SPV_GOOGLE_decorate_string\0" // IR(1035, 27) - "SPV_GOOGLE_hlsl_functionality1\0" // IR(1062, 31) - "SPV_GOOGLE_user_type\0" // IR(1093, 21) - "SPV_INTEL_2d_block_io\0" // IR(1114, 22) - "SPV_INTEL_arbitrary_precision_fixed_point\0" // IR(1136, 42) - "SPV_INTEL_arbitrary_precision_floating_point\0" // IR(1178, 45) - "SPV_INTEL_arbitrary_precision_integers\0" // IR(1223, 39) - "SPV_INTEL_bfloat16_conversion\0" // IR(1262, 30) - "SPV_INTEL_bindless_images\0" // IR(1292, 26) - "SPV_INTEL_blocking_pipes\0" // IR(1318, 25) - "SPV_INTEL_cache_controls\0" // IR(1343, 25) - "SPV_INTEL_debug_module\0" // IR(1368, 23) - "SPV_INTEL_device_side_avc_motion_estimation\0" // IR(1391, 44) - "SPV_INTEL_float_controls2\0" // IR(1435, 26) - "SPV_INTEL_fp_fast_math_mode\0" // IR(1461, 28) - "SPV_INTEL_fp_max_error\0" // IR(1489, 23) - "SPV_INTEL_fpga_argument_interfaces\0" // IR(1512, 35) - "SPV_INTEL_fpga_buffer_location\0" // IR(1547, 31) - "SPV_INTEL_fpga_cluster_attributes\0" // IR(1578, 34) - "SPV_INTEL_fpga_dsp_control\0" // IR(1612, 27) - "SPV_INTEL_fpga_invocation_pipelining_attributes\0" // IR(1639, 48) - "SPV_INTEL_fpga_latency_control\0" // IR(1687, 31) - "SPV_INTEL_fpga_loop_controls\0" // IR(1718, 29) - "SPV_INTEL_fpga_memory_accesses\0" // IR(1747, 31) - "SPV_INTEL_fpga_memory_attributes\0" // IR(1778, 33) - "SPV_INTEL_fpga_reg\0" // IR(1811, 19) - "SPV_INTEL_function_pointers\0" // IR(1830, 28) - "SPV_INTEL_global_variable_fpga_decorations\0" // IR(1858, 43) - "SPV_INTEL_global_variable_host_access\0" // IR(1901, 38) - "SPV_INTEL_inline_assembly\0" // IR(1939, 26) - "SPV_INTEL_int4\0" // IR(1965, 15) - "SPV_INTEL_io_pipes\0" // IR(1980, 19) - "SPV_INTEL_kernel_attributes\0" // IR(1999, 28) - "SPV_INTEL_long_composites\0" // IR(2027, 26) - "SPV_INTEL_loop_fuse\0" // IR(2053, 20) - "SPV_INTEL_masked_gather_scatter\0" // IR(2073, 32) - "SPV_INTEL_maximum_registers\0" // IR(2105, 28) - "SPV_INTEL_media_block_io\0" // IR(2133, 25) - "SPV_INTEL_memory_access_aliasing\0" // IR(2158, 33) - "SPV_INTEL_optnone\0" // IR(2191, 18) - "SPV_INTEL_runtime_aligned\0" // IR(2209, 26) - "SPV_INTEL_shader_integer_functions2\0" // IR(2235, 36) - "SPV_INTEL_split_barrier\0" // IR(2271, 24) - "SPV_INTEL_subgroup_buffer_prefetch\0" // IR(2295, 35) - "SPV_INTEL_subgroup_matrix_multiply_accumulate\0" // IR(2330, 46) - "SPV_INTEL_subgroups\0" // IR(2376, 20) - "SPV_INTEL_task_sequence\0" // IR(2396, 24) - "SPV_INTEL_tensor_float32_conversion\0" // IR(2420, 36) - "SPV_INTEL_ternary_bitwise_function\0" // IR(2456, 35) - "SPV_INTEL_unstructured_loop_controls\0" // IR(2491, 37) - "SPV_INTEL_usm_storage_classes\0" // IR(2528, 30) - "SPV_INTEL_variable_length_array\0" // IR(2558, 32) - "SPV_INTEL_vector_compute\0" // IR(2590, 25) - "SPV_KHR_16bit_storage\0" // IR(2615, 22) - "SPV_KHR_8bit_storage\0" // IR(2637, 21) - "SPV_KHR_bfloat16\0" // IR(2658, 17) - "SPV_KHR_bit_instructions\0" // IR(2675, 25) - "SPV_KHR_compute_shader_derivatives\0" // IR(2700, 35) - "SPV_KHR_cooperative_matrix\0" // IR(2735, 27) - "SPV_KHR_device_group\0" // IR(2762, 21) - "SPV_KHR_expect_assume\0" // IR(2783, 22) - "SPV_KHR_float_controls\0" // IR(2805, 23) - "SPV_KHR_float_controls2\0" // IR(2828, 24) - "SPV_KHR_fragment_shader_barycentric\0" // IR(2852, 36) - "SPV_KHR_fragment_shading_rate\0" // IR(2888, 30) - "SPV_KHR_integer_dot_product\0" // IR(2918, 28) - "SPV_KHR_linkonce_odr\0" // IR(2946, 21) - "SPV_KHR_maximal_reconvergence\0" // IR(2967, 30) - "SPV_KHR_multiview\0" // IR(2997, 18) - "SPV_KHR_no_integer_wrap_decoration\0" // IR(3015, 35) - "SPV_KHR_non_semantic_info\0" // IR(3050, 26) - "SPV_KHR_physical_storage_buffer\0" // IR(3076, 32) - "SPV_KHR_post_depth_coverage\0" // IR(3108, 28) - "SPV_KHR_quad_control\0" // IR(3136, 21) - "SPV_KHR_ray_cull_mask\0" // IR(3157, 22) - "SPV_KHR_ray_query\0" // IR(3179, 18) - "SPV_KHR_ray_tracing\0" // IR(3197, 20) - "SPV_KHR_ray_tracing_position_fetch\0" // IR(3217, 35) - "SPV_KHR_relaxed_extended_instruction\0" // IR(3252, 37) - "SPV_KHR_shader_atomic_counter_ops\0" // IR(3289, 34) - "SPV_KHR_shader_ballot\0" // IR(3323, 22) - "SPV_KHR_shader_clock\0" // IR(3345, 21) - "SPV_KHR_shader_draw_parameters\0" // IR(3366, 31) - "SPV_KHR_storage_buffer_storage_class\0" // IR(3397, 37) - "SPV_KHR_subgroup_rotate\0" // IR(3434, 24) - "SPV_KHR_subgroup_uniform_control_flow\0" // IR(3458, 38) - "SPV_KHR_subgroup_vote\0" // IR(3496, 22) - "SPV_KHR_terminate_invocation\0" // IR(3518, 29) - "SPV_KHR_uniform_group_instructions\0" // IR(3547, 35) - "SPV_KHR_untyped_pointers\0" // IR(3582, 25) - "SPV_KHR_variable_pointers\0" // IR(3607, 26) - "SPV_KHR_vulkan_memory_model\0" // IR(3633, 28) - "SPV_KHR_workgroup_memory_explicit_layout\0" // IR(3661, 41) - "SPV_NVX_multiview_per_view_attributes\0" // IR(3702, 38) - "SPV_NV_bindless_texture\0" // IR(3740, 24) - "SPV_NV_cluster_acceleration_structure\0" // IR(3764, 38) - "SPV_NV_compute_shader_derivatives\0" // IR(3802, 34) - "SPV_NV_cooperative_matrix\0" // IR(3836, 26) - "SPV_NV_cooperative_matrix2\0" // IR(3862, 27) - "SPV_NV_cooperative_vector\0" // IR(3889, 26) - "SPV_NV_displacement_micromap\0" // IR(3915, 29) - "SPV_NV_fragment_shader_barycentric\0" // IR(3944, 35) - "SPV_NV_geometry_shader_passthrough\0" // IR(3979, 35) - "SPV_NV_linear_swept_spheres\0" // IR(4014, 28) - "SPV_NV_mesh_shader\0" // IR(4042, 19) - "SPV_NV_raw_access_chains\0" // IR(4061, 25) - "SPV_NV_ray_tracing\0" // IR(4086, 19) - "SPV_NV_ray_tracing_motion_blur\0" // IR(4105, 31) - "SPV_NV_sample_mask_override_coverage\0" // IR(4136, 37) - "SPV_NV_shader_atomic_fp16_vector\0" // IR(4173, 33) - "SPV_NV_shader_image_footprint\0" // IR(4206, 30) - "SPV_NV_shader_invocation_reorder\0" // IR(4236, 33) - "SPV_NV_shader_sm_builtins\0" // IR(4269, 26) - "SPV_NV_shader_subgroup_partitioned\0" // IR(4295, 35) - "SPV_NV_shading_rate\0" // IR(4330, 20) - "SPV_NV_stereo_view_rendering\0" // IR(4350, 29) - "SPV_NV_tensor_addressing\0" // IR(4379, 25) - "SPV_NV_viewport_array2\0" // IR(4404, 23) - "SPV_QCOM_image_processing\0" // IR(4427, 26) - "SPV_QCOM_image_processing2\0" // IR(4453, 27) - "SPV_QCOM_tile_shading\0" // IR(4480, 22) - "SPV_VALIDATOR_ignore_type_decl_unique\0" // IR(4502, 38) - "ReadOnly\0" // IR(4540, 9) - "Kernel\0" // IR(4549, 7) - "WriteOnly\0" // IR(4556, 10) - "ReadWrite\0" // IR(4566, 10) - "Logical\0" // IR(4576, 8) - "Physical32\0" // IR(4584, 11) - "Addresses\0" // IR(4595, 10) - "Physical64\0" // IR(4605, 11) - "PhysicalStorageBuffer64\0" // IR(4616, 24) - "PhysicalStorageBuffer64EXT\0" // IR(4640, 27) - "PhysicalStorageBufferAddresses\0" // IR(4667, 31) - "Position\0" // IR(4698, 9) - "Shader\0" // IR(4707, 7) - "PointSize\0" // IR(4714, 10) - "ClipDistance\0" // IR(4724, 13) - "CullDistance\0" // IR(4737, 13) - "VertexId\0" // IR(4750, 9) - "InstanceId\0" // IR(4759, 11) - "PrimitiveId\0" // IR(4770, 12) - "Geometry\0" // IR(4782, 9) - "Tessellation\0" // IR(4791, 13) - "RayTracingNV\0" // IR(4804, 13) - "RayTracingKHR\0" // IR(4817, 14) - "MeshShadingNV\0" // IR(4831, 14) - "MeshShadingEXT\0" // IR(4845, 15) - "InvocationId\0" // IR(4860, 13) - "Layer\0" // IR(4873, 6) - "ShaderLayer\0" // IR(4879, 12) - "ShaderViewportIndexLayerEXT\0" // IR(4891, 28) - "ViewportIndex\0" // IR(4919, 14) - "MultiViewport\0" // IR(4933, 14) - "ShaderViewportIndex\0" // IR(4947, 20) - "TessLevelOuter\0" // IR(4967, 15) - "TessLevelInner\0" // IR(4982, 15) - "TessCoord\0" // IR(4997, 10) - "PatchVertices\0" // IR(5007, 14) - "FragCoord\0" // IR(5021, 10) - "PointCoord\0" // IR(5031, 11) - "FrontFacing\0" // IR(5042, 12) - "SampleId\0" // IR(5054, 9) - "SampleRateShading\0" // IR(5063, 18) - "SamplePosition\0" // IR(5081, 15) - "SampleMask\0" // IR(5096, 11) - "FragDepth\0" // IR(5107, 10) - "HelperInvocation\0" // IR(5117, 17) - "NumWorkgroups\0" // IR(5134, 14) - "WorkgroupSize\0" // IR(5148, 14) - "WorkgroupId\0" // IR(5162, 12) - "LocalInvocationId\0" // IR(5174, 18) - "GlobalInvocationId\0" // IR(5192, 19) - "LocalInvocationIndex\0" // IR(5211, 21) - "WorkDim\0" // IR(5232, 8) - "GlobalSize\0" // IR(5240, 11) - "EnqueuedWorkgroupSize\0" // IR(5251, 22) - "GlobalOffset\0" // IR(5273, 13) - "GlobalLinearId\0" // IR(5286, 15) - "SubgroupSize\0" // IR(5301, 13) - "GroupNonUniform\0" // IR(5314, 16) - "SubgroupBallotKHR\0" // IR(5330, 18) - "SubgroupMaxSize\0" // IR(5348, 16) - "NumSubgroups\0" // IR(5364, 13) - "NumEnqueuedSubgroups\0" // IR(5377, 21) - "SubgroupId\0" // IR(5398, 11) - "SubgroupLocalInvocationId\0" // IR(5409, 26) - "VertexIndex\0" // IR(5435, 12) - "InstanceIndex\0" // IR(5447, 14) - "CoreIDARM\0" // IR(5461, 10) - "CoreBuiltinsARM\0" // IR(5471, 16) - "CoreCountARM\0" // IR(5487, 13) - "CoreMaxIDARM\0" // IR(5500, 13) - "WarpIDARM\0" // IR(5513, 10) - "WarpMaxIDARM\0" // IR(5523, 13) - "SubgroupEqMask\0" // IR(5536, 15) - "SubgroupEqMaskKHR\0" // IR(5551, 18) - "GroupNonUniformBallot\0" // IR(5569, 22) - "SubgroupGeMask\0" // IR(5591, 15) - "SubgroupGeMaskKHR\0" // IR(5606, 18) - "SubgroupGtMask\0" // IR(5624, 15) - "SubgroupGtMaskKHR\0" // IR(5639, 18) - "SubgroupLeMask\0" // IR(5657, 15) - "SubgroupLeMaskKHR\0" // IR(5672, 18) - "SubgroupLtMask\0" // IR(5690, 15) - "SubgroupLtMaskKHR\0" // IR(5705, 18) - "BaseVertex\0" // IR(5723, 11) - "DrawParameters\0" // IR(5734, 15) - "BaseInstance\0" // IR(5749, 13) - "DrawIndex\0" // IR(5762, 10) - "PrimitiveShadingRateKHR\0" // IR(5772, 24) - "FragmentShadingRateKHR\0" // IR(5796, 23) - "DeviceIndex\0" // IR(5819, 12) - "DeviceGroup\0" // IR(5831, 12) - "ViewIndex\0" // IR(5843, 10) - "MultiView\0" // IR(5853, 10) - "ShadingRateKHR\0" // IR(5863, 15) - "TileOffsetQCOM\0" // IR(5878, 15) - "TileShadingQCOM\0" // IR(5893, 16) - "TileDimensionQCOM\0" // IR(5909, 18) - "TileApronSizeQCOM\0" // IR(5927, 18) - "BaryCoordNoPerspAMD\0" // IR(5945, 20) - "BaryCoordNoPerspCentroidAMD\0" // IR(5965, 28) - "BaryCoordNoPerspSampleAMD\0" // IR(5993, 26) - "BaryCoordSmoothAMD\0" // IR(6019, 19) - "BaryCoordSmoothCentroidAMD\0" // IR(6038, 27) - "BaryCoordSmoothSampleAMD\0" // IR(6065, 25) - "BaryCoordPullModelAMD\0" // IR(6090, 22) - "FragStencilRefEXT\0" // IR(6112, 18) - "StencilExportEXT\0" // IR(6130, 17) - "RemainingRecursionLevelsAMDX\0" // IR(6147, 29) - "ShaderEnqueueAMDX\0" // IR(6176, 18) - "ShaderIndexAMDX\0" // IR(6194, 16) - "ViewportMaskNV\0" // IR(6210, 15) - "ShaderViewportMaskNV\0" // IR(6225, 21) - "SecondaryPositionNV\0" // IR(6246, 20) - "ShaderStereoViewNV\0" // IR(6266, 19) - "SecondaryViewportMaskNV\0" // IR(6285, 24) - "PositionPerViewNV\0" // IR(6309, 18) - "PerViewAttributesNV\0" // IR(6327, 20) - "ViewportMaskPerViewNV\0" // IR(6347, 22) - "FullyCoveredEXT\0" // IR(6369, 16) - "FragmentFullyCoveredEXT\0" // IR(6385, 24) - "TaskCountNV\0" // IR(6409, 12) - "PrimitiveCountNV\0" // IR(6421, 17) - "PrimitiveIndicesNV\0" // IR(6438, 19) - "ClipDistancePerViewNV\0" // IR(6457, 22) - "CullDistancePerViewNV\0" // IR(6479, 22) - "LayerPerViewNV\0" // IR(6501, 15) - "MeshViewCountNV\0" // IR(6516, 16) - "MeshViewIndicesNV\0" // IR(6532, 18) - "BaryCoordKHR\0" // IR(6550, 13) - "BaryCoordNV\0" // IR(6563, 12) - "FragmentBarycentricKHR\0" // IR(6575, 23) - "BaryCoordNoPerspKHR\0" // IR(6598, 20) - "BaryCoordNoPerspNV\0" // IR(6618, 19) - "FragSizeEXT\0" // IR(6637, 12) - "FragmentSizeNV\0" // IR(6649, 15) - "FragmentDensityEXT\0" // IR(6664, 19) - "FragInvocationCountEXT\0" // IR(6683, 23) - "InvocationsPerPixelNV\0" // IR(6706, 22) - "PrimitivePointIndicesEXT\0" // IR(6728, 25) - "PrimitiveLineIndicesEXT\0" // IR(6753, 24) - "PrimitiveTriangleIndicesEXT\0" // IR(6777, 28) - "CullPrimitiveEXT\0" // IR(6805, 17) - "LaunchIdKHR\0" // IR(6822, 12) - "LaunchIdNV\0" // IR(6834, 11) - "LaunchSizeKHR\0" // IR(6845, 14) - "LaunchSizeNV\0" // IR(6859, 13) - "WorldRayOriginKHR\0" // IR(6872, 18) - "WorldRayOriginNV\0" // IR(6890, 17) - "WorldRayDirectionKHR\0" // IR(6907, 21) - "WorldRayDirectionNV\0" // IR(6928, 20) - "ObjectRayOriginKHR\0" // IR(6948, 19) - "ObjectRayOriginNV\0" // IR(6967, 18) - "ObjectRayDirectionKHR\0" // IR(6985, 22) - "ObjectRayDirectionNV\0" // IR(7007, 21) - "RayTminKHR\0" // IR(7028, 11) - "RayTminNV\0" // IR(7039, 10) - "RayTmaxKHR\0" // IR(7049, 11) - "RayTmaxNV\0" // IR(7060, 10) - "InstanceCustomIndexKHR\0" // IR(7070, 23) - "InstanceCustomIndexNV\0" // IR(7093, 22) - "ObjectToWorldKHR\0" // IR(7115, 17) - "ObjectToWorldNV\0" // IR(7132, 16) - "WorldToObjectKHR\0" // IR(7148, 17) - "WorldToObjectNV\0" // IR(7165, 16) - "HitTNV\0" // IR(7181, 7) - "HitKindKHR\0" // IR(7188, 11) - "HitKindNV\0" // IR(7199, 10) - "CurrentRayTimeNV\0" // IR(7209, 17) - "RayTracingMotionBlurNV\0" // IR(7226, 23) - "HitTriangleVertexPositionsKHR\0" // IR(7249, 30) - "RayTracingPositionFetchKHR\0" // IR(7279, 27) - "HitMicroTriangleVertexPositionsNV\0" // IR(7306, 34) - "RayTracingDisplacementMicromapNV\0" // IR(7340, 33) - "HitMicroTriangleVertexBarycentricsNV\0" // IR(7373, 37) - "IncomingRayFlagsKHR\0" // IR(7410, 20) - "IncomingRayFlagsNV\0" // IR(7430, 19) - "RayGeometryIndexKHR\0" // IR(7449, 20) - "HitIsSphereNV\0" // IR(7469, 14) - "RayTracingSpheresGeometryNV\0" // IR(7483, 28) - "HitIsLSSNV\0" // IR(7511, 11) - "RayTracingLinearSweptSpheresGeometryNV\0" // IR(7522, 39) - "HitSpherePositionNV\0" // IR(7561, 20) - "WarpsPerSMNV\0" // IR(7581, 13) - "ShaderSMBuiltinsNV\0" // IR(7594, 19) - "SMCountNV\0" // IR(7613, 10) - "WarpIDNV\0" // IR(7623, 9) - "SMIDNV\0" // IR(7632, 7) - "HitLSSPositionsNV\0" // IR(7639, 18) - "HitKindFrontFacingMicroTriangleNV\0" // IR(7657, 34) - "HitKindBackFacingMicroTriangleNV\0" // IR(7691, 33) - "HitSphereRadiusNV\0" // IR(7724, 18) - "HitLSSRadiiNV\0" // IR(7742, 14) - "ClusterIDNV\0" // IR(7756, 12) - "RayTracingClusterAccelerationStructureNV\0" // IR(7768, 41) - "CullMaskKHR\0" // IR(7809, 12) - "RayCullMaskKHR\0" // IR(7821, 15) - "Matrix\0" // IR(7836, 7) - "Linkage\0" // IR(7843, 8) - "Vector16\0" // IR(7851, 9) - "Float16Buffer\0" // IR(7860, 14) - "Float16\0" // IR(7874, 8) - "Float64\0" // IR(7882, 8) - "Int64\0" // IR(7890, 6) - "Int64Atomics\0" // IR(7896, 13) - "ImageBasic\0" // IR(7909, 11) - "ImageReadWrite\0" // IR(7920, 15) - "ImageMipmap\0" // IR(7935, 12) - "Pipes\0" // IR(7947, 6) - "Groups\0" // IR(7953, 7) - "DeviceEnqueue\0" // IR(7960, 14) - "LiteralSampler\0" // IR(7974, 15) - "AtomicStorage\0" // IR(7989, 14) - "Int16\0" // IR(8003, 6) - "TessellationPointSize\0" // IR(8009, 22) - "GeometryPointSize\0" // IR(8031, 18) - "ImageGatherExtended\0" // IR(8049, 20) - "StorageImageMultisample\0" // IR(8069, 24) - "UniformBufferArrayDynamicIndexing\0" // IR(8093, 34) - "SampledImageArrayDynamicIndexing\0" // IR(8127, 33) - "StorageBufferArrayDynamicIndexing\0" // IR(8160, 34) - "StorageImageArrayDynamicIndexing\0" // IR(8194, 33) - "ImageCubeArray\0" // IR(8227, 15) - "SampledCubeArray\0" // IR(8242, 17) - "ImageRect\0" // IR(8259, 10) - "SampledRect\0" // IR(8269, 12) - "GenericPointer\0" // IR(8281, 15) - "Int8\0" // IR(8296, 5) - "InputAttachment\0" // IR(8301, 16) - "SparseResidency\0" // IR(8317, 16) - "MinLod\0" // IR(8333, 7) - "Sampled1D\0" // IR(8340, 10) - "Image1D\0" // IR(8350, 8) - "SampledBuffer\0" // IR(8358, 14) - "ImageBuffer\0" // IR(8372, 12) - "ImageMSArray\0" // IR(8384, 13) - "StorageImageExtendedFormats\0" // IR(8397, 28) - "ImageQuery\0" // IR(8425, 11) - "DerivativeControl\0" // IR(8436, 18) - "InterpolationFunction\0" // IR(8454, 22) - "TransformFeedback\0" // IR(8476, 18) - "GeometryStreams\0" // IR(8494, 16) - "StorageImageReadWithoutFormat\0" // IR(8510, 30) - "StorageImageWriteWithoutFormat\0" // IR(8540, 31) - "SubgroupDispatch\0" // IR(8571, 17) - "NamedBarrier\0" // IR(8588, 13) - "PipeStorage\0" // IR(8601, 12) - "GroupNonUniformVote\0" // IR(8613, 20) - "GroupNonUniformArithmetic\0" // IR(8633, 26) - "GroupNonUniformShuffle\0" // IR(8659, 23) - "GroupNonUniformShuffleRelative\0" // IR(8682, 31) - "GroupNonUniformClustered\0" // IR(8713, 25) - "GroupNonUniformQuad\0" // IR(8738, 20) - "UniformDecoration\0" // IR(8758, 18) - "TileImageColorReadAccessEXT\0" // IR(8776, 28) - "TileImageDepthReadAccessEXT\0" // IR(8804, 28) - "TileImageStencilReadAccessEXT\0" // IR(8832, 30) - "TensorsARM\0" // IR(8862, 11) - "StorageTensorArrayDynamicIndexingARM\0" // IR(8873, 37) - "StorageTensorArrayNonUniformIndexingARM\0" // IR(8910, 40) - "CooperativeMatrixLayoutsARM\0" // IR(8950, 28) - "Float8EXT\0" // IR(8978, 10) - "Float8CooperativeMatrixEXT\0" // IR(8988, 27) - "WorkgroupMemoryExplicitLayoutKHR\0" // IR(9015, 33) - "WorkgroupMemoryExplicitLayout8BitAccessKHR\0" // IR(9048, 43) - "WorkgroupMemoryExplicitLayout16BitAccessKHR\0" // IR(9091, 44) - "SubgroupVoteKHR\0" // IR(9135, 16) - "StorageBuffer16BitAccess\0" // IR(9151, 25) - "StorageUniformBufferBlock16\0" // IR(9176, 28) - "UniformAndStorageBuffer16BitAccess\0" // IR(9204, 35) - "StorageUniform16\0" // IR(9239, 17) - "StoragePushConstant16\0" // IR(9256, 22) - "StorageInputOutput16\0" // IR(9278, 21) - "VariablePointersStorageBuffer\0" // IR(9299, 30) - "VariablePointers\0" // IR(9329, 17) - "AtomicStorageOps\0" // IR(9346, 17) - "SampleMaskPostDepthCoverage\0" // IR(9363, 28) - "StorageBuffer8BitAccess\0" // IR(9391, 24) - "UniformAndStorageBuffer8BitAccess\0" // IR(9415, 34) - "StoragePushConstant8\0" // IR(9449, 21) - "DenormPreserve\0" // IR(9470, 15) - "DenormFlushToZero\0" // IR(9485, 18) - "SignedZeroInfNanPreserve\0" // IR(9503, 25) - "RoundingModeRTE\0" // IR(9528, 16) - "RoundingModeRTZ\0" // IR(9544, 16) - "RayQueryProvisionalKHR\0" // IR(9560, 23) - "RayQueryKHR\0" // IR(9583, 12) - "UntypedPointersKHR\0" // IR(9595, 19) - "RayTraversalPrimitiveCullingKHR\0" // IR(9614, 32) - "TextureSampleWeightedQCOM\0" // IR(9646, 26) - "TextureBoxFilterQCOM\0" // IR(9672, 21) - "TextureBlockMatchQCOM\0" // IR(9693, 22) - "TextureBlockMatch2QCOM\0" // IR(9715, 23) - "Float16ImageAMD\0" // IR(9738, 16) - "ImageGatherBiasLodAMD\0" // IR(9754, 22) - "FragmentMaskAMD\0" // IR(9776, 16) - "ImageReadWriteLodAMD\0" // IR(9792, 21) - "Int64ImageEXT\0" // IR(9813, 14) - "ShaderClockKHR\0" // IR(9827, 15) - "QuadControlKHR\0" // IR(9842, 15) - "Int4TypeINTEL\0" // IR(9857, 14) - "Int4CooperativeMatrixINTEL\0" // IR(9871, 27) - "CooperativeMatrixKHR\0" // IR(9898, 21) - "BFloat16TypeKHR\0" // IR(9919, 16) - "BFloat16DotProductKHR\0" // IR(9935, 22) - "BFloat16CooperativeMatrixKHR\0" // IR(9957, 29) - "SampleMaskOverrideCoverageNV\0" // IR(9986, 29) - "GeometryShaderPassthroughNV\0" // IR(10015, 28) - "ShaderViewportIndexLayerNV\0" // IR(10043, 27) - "ImageFootprintNV\0" // IR(10070, 17) - "FragmentBarycentricNV\0" // IR(10087, 22) - "ComputeDerivativeGroupQuadsKHR\0" // IR(10109, 31) - "ComputeDerivativeGroupQuadsNV\0" // IR(10140, 30) - "ShadingRateNV\0" // IR(10170, 14) - "GroupNonUniformPartitionedNV\0" // IR(10184, 29) - "ShaderNonUniform\0" // IR(10213, 17) - "ShaderNonUniformEXT\0" // IR(10230, 20) - "RuntimeDescriptorArray\0" // IR(10250, 23) - "RuntimeDescriptorArrayEXT\0" // IR(10273, 26) - "InputAttachmentArrayDynamicIndexing\0" // IR(10299, 36) - "InputAttachmentArrayDynamicIndexingEXT\0" // IR(10335, 39) - "UniformTexelBufferArrayDynamicIndexing\0" // IR(10374, 39) - "UniformTexelBufferArrayDynamicIndexingEXT\0" // IR(10413, 42) - "StorageTexelBufferArrayDynamicIndexing\0" // IR(10455, 39) - "StorageTexelBufferArrayDynamicIndexingEXT\0" // IR(10494, 42) - "UniformBufferArrayNonUniformIndexing\0" // IR(10536, 37) - "UniformBufferArrayNonUniformIndexingEXT\0" // IR(10573, 40) - "SampledImageArrayNonUniformIndexing\0" // IR(10613, 36) - "SampledImageArrayNonUniformIndexingEXT\0" // IR(10649, 39) - "StorageBufferArrayNonUniformIndexing\0" // IR(10688, 37) - "StorageBufferArrayNonUniformIndexingEXT\0" // IR(10725, 40) - "StorageImageArrayNonUniformIndexing\0" // IR(10765, 36) - "StorageImageArrayNonUniformIndexingEXT\0" // IR(10801, 39) - "InputAttachmentArrayNonUniformIndexing\0" // IR(10840, 39) - "InputAttachmentArrayNonUniformIndexingEXT\0" // IR(10879, 42) - "UniformTexelBufferArrayNonUniformIndexing\0" // IR(10921, 42) - "UniformTexelBufferArrayNonUniformIndexingEXT\0" // IR(10963, 45) - "StorageTexelBufferArrayNonUniformIndexing\0" // IR(11008, 42) - "StorageTexelBufferArrayNonUniformIndexingEXT\0" // IR(11050, 45) - "VulkanMemoryModel\0" // IR(11095, 18) - "VulkanMemoryModelKHR\0" // IR(11113, 21) - "VulkanMemoryModelDeviceScope\0" // IR(11134, 29) - "VulkanMemoryModelDeviceScopeKHR\0" // IR(11163, 32) - "PhysicalStorageBufferAddressesEXT\0" // IR(11195, 34) - "ComputeDerivativeGroupLinearKHR\0" // IR(11229, 32) - "ComputeDerivativeGroupLinearNV\0" // IR(11261, 31) - "RayTracingProvisionalKHR\0" // IR(11292, 25) - "CooperativeMatrixNV\0" // IR(11317, 20) - "FragmentShaderSampleInterlockEXT\0" // IR(11337, 33) - "FragmentShaderShadingRateInterlockEXT\0" // IR(11370, 38) - "FragmentShaderPixelInterlockEXT\0" // IR(11408, 32) - "DemoteToHelperInvocation\0" // IR(11440, 25) - "DemoteToHelperInvocationEXT\0" // IR(11465, 28) - "DisplacementMicromapNV\0" // IR(11493, 23) - "RayTracingOpacityMicromapEXT\0" // IR(11516, 29) - "ShaderInvocationReorderNV\0" // IR(11545, 26) - "BindlessTextureNV\0" // IR(11571, 18) - "RayQueryPositionFetchKHR\0" // IR(11589, 25) - "CooperativeVectorNV\0" // IR(11614, 20) - "AtomicFloat16VectorNV\0" // IR(11634, 22) - "RawAccessChainsNV\0" // IR(11656, 18) - "CooperativeMatrixReductionsNV\0" // IR(11674, 30) - "CooperativeMatrixConversionsNV\0" // IR(11704, 31) - "CooperativeMatrixPerElementOperationsNV\0" // IR(11735, 40) - "CooperativeMatrixTensorAddressingNV\0" // IR(11775, 36) - "CooperativeMatrixBlockLoadsNV\0" // IR(11811, 30) - "CooperativeVectorTrainingNV\0" // IR(11841, 28) - "TensorAddressingNV\0" // IR(11869, 19) - "SubgroupShuffleINTEL\0" // IR(11888, 21) - "SubgroupBufferBlockIOINTEL\0" // IR(11909, 27) - "SubgroupImageBlockIOINTEL\0" // IR(11936, 26) - "SubgroupImageMediaBlockIOINTEL\0" // IR(11962, 31) - "RoundToInfinityINTEL\0" // IR(11993, 21) - "FloatingPointModeINTEL\0" // IR(12014, 23) - "IntegerFunctions2INTEL\0" // IR(12037, 23) - "FunctionPointersINTEL\0" // IR(12060, 22) - "IndirectReferencesINTEL\0" // IR(12082, 24) - "AsmINTEL\0" // IR(12106, 9) - "AtomicFloat32MinMaxEXT\0" // IR(12115, 23) - "AtomicFloat64MinMaxEXT\0" // IR(12138, 23) - "AtomicFloat16MinMaxEXT\0" // IR(12161, 23) - "VectorComputeINTEL\0" // IR(12184, 19) - "VectorAnyINTEL\0" // IR(12203, 15) - "ExpectAssumeKHR\0" // IR(12218, 16) - "SubgroupAvcMotionEstimationINTEL\0" // IR(12234, 33) - "SubgroupAvcMotionEstimationIntraINTEL\0" // IR(12267, 38) - "SubgroupAvcMotionEstimationChromaINTEL\0" // IR(12305, 39) - "VariableLengthArrayINTEL\0" // IR(12344, 25) - "FunctionFloatControlINTEL\0" // IR(12369, 26) - "FPGAMemoryAttributesINTEL\0" // IR(12395, 26) - "FPFastMathModeINTEL\0" // IR(12421, 20) - "ArbitraryPrecisionIntegersINTEL\0" // IR(12441, 32) - "ArbitraryPrecisionFloatingPointINTEL\0" // IR(12473, 37) - "UnstructuredLoopControlsINTEL\0" // IR(12510, 30) - "FPGALoopControlsINTEL\0" // IR(12540, 22) - "KernelAttributesINTEL\0" // IR(12562, 22) - "FPGAKernelAttributesINTEL\0" // IR(12584, 26) - "FPGAMemoryAccessesINTEL\0" // IR(12610, 24) - "FPGAClusterAttributesINTEL\0" // IR(12634, 27) - "LoopFuseINTEL\0" // IR(12661, 14) - "FPGADSPControlINTEL\0" // IR(12675, 20) - "MemoryAccessAliasingINTEL\0" // IR(12695, 26) - "FPGAInvocationPipeliningAttributesINTEL\0" // IR(12721, 40) - "FPGABufferLocationINTEL\0" // IR(12761, 24) - "ArbitraryPrecisionFixedPointINTEL\0" // IR(12785, 34) - "USMStorageClassesINTEL\0" // IR(12819, 23) - "RuntimeAlignedAttributeINTEL\0" // IR(12842, 29) - "IOPipesINTEL\0" // IR(12871, 13) - "BlockingPipesINTEL\0" // IR(12884, 19) - "FPGARegINTEL\0" // IR(12903, 13) - "DotProductInputAll\0" // IR(12916, 19) - "DotProductInputAllKHR\0" // IR(12935, 22) - "DotProductInput4x8Bit\0" // IR(12957, 22) - "DotProductInput4x8BitKHR\0" // IR(12979, 25) - "DotProductInput4x8BitPacked\0" // IR(13004, 28) - "DotProductInput4x8BitPackedKHR\0" // IR(13032, 31) - "DotProduct\0" // IR(13063, 11) - "DotProductKHR\0" // IR(13074, 14) - "ReplicatedCompositesEXT\0" // IR(13088, 24) - "BitInstructions\0" // IR(13112, 16) - "GroupNonUniformRotateKHR\0" // IR(13128, 25) - "FloatControls2\0" // IR(13153, 15) - "AtomicFloat32AddEXT\0" // IR(13168, 20) - "AtomicFloat64AddEXT\0" // IR(13188, 20) - "LongCompositesINTEL\0" // IR(13208, 20) - "OptNoneEXT\0" // IR(13228, 11) - "OptNoneINTEL\0" // IR(13239, 13) - "AtomicFloat16AddEXT\0" // IR(13252, 20) - "DebugInfoModuleINTEL\0" // IR(13272, 21) - "BFloat16ConversionINTEL\0" // IR(13293, 24) - "SplitBarrierINTEL\0" // IR(13317, 18) - "ArithmeticFenceEXT\0" // IR(13335, 19) - "FPGAClusterAttributesV2INTEL\0" // IR(13354, 29) - "FPGAKernelAttributesv2INTEL\0" // IR(13383, 28) - "TaskSequenceINTEL\0" // IR(13411, 18) - "FPMaxErrorINTEL\0" // IR(13429, 16) - "FPGALatencyControlINTEL\0" // IR(13445, 24) - "FPGAArgumentInterfacesINTEL\0" // IR(13469, 28) - "GlobalVariableHostAccessINTEL\0" // IR(13497, 30) - "GlobalVariableFPGADecorationsINTEL\0" // IR(13527, 35) - "SubgroupBufferPrefetchINTEL\0" // IR(13562, 28) - "Subgroup2DBlockIOINTEL\0" // IR(13590, 23) - "Subgroup2DBlockTransformINTEL\0" // IR(13613, 30) - "Subgroup2DBlockTransposeINTEL\0" // IR(13643, 30) - "SubgroupMatrixMultiplyAccumulateINTEL\0" // IR(13673, 38) - "TernaryBitwiseFunctionINTEL\0" // IR(13711, 28) - "GroupUniformArithmeticKHR\0" // IR(13739, 26) - "TensorFloat32RoundingINTEL\0" // IR(13765, 27) - "MaskedGatherScatterINTEL\0" // IR(13792, 25) - "CacheControlsINTEL\0" // IR(13817, 19) - "RegisterLimitsINTEL\0" // IR(13836, 20) - "BindlessImagesINTEL\0" // IR(13856, 20) - "Unspecified\0" // IR(13876, 12) - "Address\0" // IR(13888, 8) - "Boolean\0" // IR(13896, 8) - "Float\0" // IR(13904, 6) - "Signed\0" // IR(13910, 7) - "SignedChar\0" // IR(13917, 11) - "Unsigned\0" // IR(13928, 9) - "UnsignedChar\0" // IR(13937, 13) - "Class\0" // IR(13950, 6) - "Structure\0" // IR(13956, 10) - "Union\0" // IR(13966, 6) - "ImportedModule\0" // IR(13972, 15) - "ImportedDeclaration\0" // IR(13987, 20) - "None\0" // IR(14007, 5) - "FlagIsProtected\0" // IR(14012, 16) - "FlagIsPrivate\0" // IR(14028, 14) - "FlagIsPublic\0" // IR(14042, 13) - "FlagIsLocal\0" // IR(14055, 12) - "FlagIsDefinition\0" // IR(14067, 17) - "FlagFwdDecl\0" // IR(14084, 12) - "FlagArtificial\0" // IR(14096, 15) - "FlagExplicit\0" // IR(14111, 13) - "FlagPrototyped\0" // IR(14124, 15) - "FlagObjectPointer\0" // IR(14139, 18) - "FlagStaticMember\0" // IR(14157, 17) - "FlagIndirectVariable\0" // IR(14174, 21) - "FlagLValueReference\0" // IR(14195, 20) - "FlagRValueReference\0" // IR(14215, 20) - "FlagIsOptimized\0" // IR(14235, 16) - "FlagIsEnumClass\0" // IR(14251, 16) - "FlagTypePassByValue\0" // IR(14267, 20) - "FlagTypePassByReference\0" // IR(14287, 24) - "Deref\0" // IR(14311, 6) - "Plus\0" // IR(14317, 5) - "Minus\0" // IR(14322, 6) - "SPV_OPERAND_TYPE_LITERAL_INTEGER\0" // IR(14328, 33) - "PlusUconst\0" // IR(14361, 11) - "BitPiece\0" // IR(14372, 9) - "Swap\0" // IR(14381, 5) - "Xderef\0" // IR(14386, 7) - "StackValue\0" // IR(14393, 11) - "Constu\0" // IR(14404, 7) - "Fragment\0" // IR(14411, 9) - "ConstType\0" // IR(14420, 10) - "VolatileType\0" // IR(14430, 13) - "RestrictType\0" // IR(14443, 13) - "AtomicType\0" // IR(14456, 11) - "Float16NV\0" // IR(14467, 10) - "Float32NV\0" // IR(14477, 10) - "Float64NV\0" // IR(14487, 10) - "SignedInt8NV\0" // IR(14497, 13) - "SignedInt16NV\0" // IR(14510, 14) - "SignedInt32NV\0" // IR(14524, 14) - "SignedInt64NV\0" // IR(14538, 14) - "UnsignedInt8NV\0" // IR(14552, 15) - "UnsignedInt16NV\0" // IR(14567, 16) - "UnsignedInt32NV\0" // IR(14583, 16) - "UnsignedInt64NV\0" // IR(14599, 16) - "SignedInt8PackedNV\0" // IR(14615, 19) - "UnsignedInt8PackedNV\0" // IR(14634, 21) - "FloatE4M3NV\0" // IR(14655, 12) - "FloatE5M2NV\0" // IR(14667, 12) - "RowMajorKHR\0" // IR(14679, 12) - "ColumnMajorKHR\0" // IR(14691, 15) - "RowBlockedInterleavedARM\0" // IR(14706, 25) - "ColumnBlockedInterleavedARM\0" // IR(14731, 28) - "NoneKHR\0" // IR(14759, 8) - "MatrixASignedComponentsKHR\0" // IR(14767, 27) - "MatrixBSignedComponentsKHR\0" // IR(14794, 27) - "MatrixCSignedComponentsKHR\0" // IR(14821, 27) - "MatrixResultSignedComponentsKHR\0" // IR(14848, 32) - "SaturatingAccumulationKHR\0" // IR(14880, 26) - "Row\0" // IR(14906, 4) - "Column\0" // IR(14910, 7) - "2x2\0" // IR(14917, 4) - "MatrixAKHR\0" // IR(14921, 11) - "MatrixBKHR\0" // IR(14932, 11) - "MatrixAccumulatorKHR\0" // IR(14943, 21) - "RowMajorNV\0" // IR(14964, 11) - "ColumnMajorNV\0" // IR(14975, 14) - "InferencingOptimalNV\0" // IR(14989, 21) - "TrainingOptimalNV\0" // IR(15010, 18) - "RelaxedPrecision\0" // IR(15028, 17) - "SpecId\0" // IR(15045, 7) - "Block\0" // IR(15052, 6) - "BufferBlock\0" // IR(15058, 12) - "RowMajor\0" // IR(15070, 9) - "ColMajor\0" // IR(15079, 9) - "ArrayStride\0" // IR(15088, 12) - "MatrixStride\0" // IR(15100, 13) - "GLSLShared\0" // IR(15113, 11) - "GLSLPacked\0" // IR(15124, 11) - "CPacked\0" // IR(15135, 8) - "SPV_OPERAND_TYPE_BUILT_IN\0" // IR(15143, 26) - "BuiltIn\0" // IR(15169, 8) - "NoPerspective\0" // IR(15177, 14) - "Flat\0" // IR(15191, 5) - "Patch\0" // IR(15196, 6) - "Centroid\0" // IR(15202, 9) - "Sample\0" // IR(15211, 7) - "Invariant\0" // IR(15218, 10) - "Restrict\0" // IR(15228, 9) - "Aliased\0" // IR(15237, 8) - "Volatile\0" // IR(15245, 9) - "Constant\0" // IR(15254, 9) - "Coherent\0" // IR(15263, 9) - "NonWritable\0" // IR(15272, 12) - "NonReadable\0" // IR(15284, 12) - "Uniform\0" // IR(15296, 8) - "SPV_OPERAND_TYPE_SCOPE_ID\0" // IR(15304, 26) - "UniformId\0" // IR(15330, 10) - "SaturatedConversion\0" // IR(15340, 20) - "Stream\0" // IR(15360, 7) - "Location\0" // IR(15367, 9) - "Component\0" // IR(15376, 10) - "Index\0" // IR(15386, 6) - "Binding\0" // IR(15392, 8) - "DescriptorSet\0" // IR(15400, 14) - "Offset\0" // IR(15414, 7) - "XfbBuffer\0" // IR(15421, 10) - "XfbStride\0" // IR(15431, 10) - "SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE\0" // IR(15441, 46) - "FuncParamAttr\0" // IR(15487, 14) - "SPV_OPERAND_TYPE_FP_ROUNDING_MODE\0" // IR(15501, 34) - "FPRoundingMode\0" // IR(15535, 15) - "SPV_OPERAND_TYPE_FP_FAST_MATH_MODE\0" // IR(15550, 35) - "FPFastMathMode\0" // IR(15585, 15) - "SPV_OPERAND_TYPE_LITERAL_STRING\0" // IR(15600, 32) - "SPV_OPERAND_TYPE_LINKAGE_TYPE\0" // IR(15632, 30) - "LinkageAttributes\0" // IR(15662, 18) - "NoContraction\0" // IR(15680, 14) - "InputAttachmentIndex\0" // IR(15694, 21) - "Alignment\0" // IR(15715, 10) - "MaxByteOffset\0" // IR(15725, 14) - "SPV_OPERAND_TYPE_ID\0" // IR(15739, 20) - "AlignmentId\0" // IR(15759, 12) - "MaxByteOffsetId\0" // IR(15771, 16) - "SaturatedToLargestFloat8NormalConversionEXT\0" // IR(15787, 44) - "NoSignedWrap\0" // IR(15831, 13) - "NoUnsignedWrap\0" // IR(15844, 15) - "WeightTextureQCOM\0" // IR(15859, 18) - "BlockMatchTextureQCOM\0" // IR(15877, 22) - "BlockMatchSamplerQCOM\0" // IR(15899, 22) - "ExplicitInterpAMD\0" // IR(15921, 18) - "NodeSharesPayloadLimitsWithAMDX\0" // IR(15939, 32) - "NodeMaxPayloadsAMDX\0" // IR(15971, 20) - "TrackFinishWritingAMDX\0" // IR(15991, 23) - "PayloadNodeNameAMDX\0" // IR(16014, 20) - "PayloadNodeBaseIndexAMDX\0" // IR(16034, 25) - "PayloadNodeSparseArrayAMDX\0" // IR(16059, 27) - "PayloadNodeArraySizeAMDX\0" // IR(16086, 25) - "PayloadDispatchIndirectAMDX\0" // IR(16111, 28) - "OverrideCoverageNV\0" // IR(16139, 19) - "PassthroughNV\0" // IR(16158, 14) - "ViewportRelativeNV\0" // IR(16172, 19) - "SecondaryViewportRelativeNV\0" // IR(16191, 28) - "PerPrimitiveEXT\0" // IR(16219, 16) - "PerPrimitiveNV\0" // IR(16235, 15) - "PerViewNV\0" // IR(16250, 10) - "PerTaskNV\0" // IR(16260, 10) - "PerVertexKHR\0" // IR(16270, 13) - "PerVertexNV\0" // IR(16283, 12) - "NonUniform\0" // IR(16295, 11) - "NonUniformEXT\0" // IR(16306, 14) - "RestrictPointer\0" // IR(16320, 16) - "RestrictPointerEXT\0" // IR(16336, 19) - "AliasedPointer\0" // IR(16355, 15) - "AliasedPointerEXT\0" // IR(16370, 18) - "HitObjectShaderRecordBufferNV\0" // IR(16388, 30) - "BindlessSamplerNV\0" // IR(16418, 18) - "BindlessImageNV\0" // IR(16436, 16) - "BoundSamplerNV\0" // IR(16452, 15) - "BoundImageNV\0" // IR(16467, 13) - "SIMTCallINTEL\0" // IR(16480, 14) - "ReferencedIndirectlyINTEL\0" // IR(16494, 26) - "ClobberINTEL\0" // IR(16520, 13) - "SideEffectsINTEL\0" // IR(16533, 17) - "VectorComputeVariableINTEL\0" // IR(16550, 27) - "FuncParamIOKindINTEL\0" // IR(16577, 21) - "VectorComputeFunctionINTEL\0" // IR(16598, 27) - "StackCallINTEL\0" // IR(16625, 15) - "GlobalVariableOffsetINTEL\0" // IR(16640, 26) - "CounterBuffer\0" // IR(16666, 14) - "HlslCounterBufferGOOGLE\0" // IR(16680, 24) - "UserSemantic\0" // IR(16704, 13) - "HlslSemanticGOOGLE\0" // IR(16717, 19) - "UserTypeGOOGLE\0" // IR(16736, 15) - "FunctionRoundingModeINTEL\0" // IR(16751, 26) - "SPV_OPERAND_TYPE_FPDENORM_MODE\0" // IR(16777, 31) - "FunctionDenormModeINTEL\0" // IR(16808, 24) - "RegisterINTEL\0" // IR(16832, 14) - "MemoryINTEL\0" // IR(16846, 12) - "NumbanksINTEL\0" // IR(16858, 14) - "BankwidthINTEL\0" // IR(16872, 15) - "MaxPrivateCopiesINTEL\0" // IR(16887, 22) - "SinglepumpINTEL\0" // IR(16909, 16) - "DoublepumpINTEL\0" // IR(16925, 16) - "MaxReplicatesINTEL\0" // IR(16941, 19) - "SimpleDualPortINTEL\0" // IR(16960, 20) - "MergeINTEL\0" // IR(16980, 11) - "SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER\0" // IR(16991, 42) - "BankBitsINTEL\0" // IR(17033, 14) - "ForcePow2DepthINTEL\0" // IR(17047, 20) - "StridesizeINTEL\0" // IR(17067, 16) - "WordsizeINTEL\0" // IR(17083, 14) - "TrueDualPortINTEL\0" // IR(17097, 18) - "BurstCoalesceINTEL\0" // IR(17115, 19) - "CacheSizeINTEL\0" // IR(17134, 15) - "DontStaticallyCoalesceINTEL\0" // IR(17149, 28) - "PrefetchINTEL\0" // IR(17177, 14) - "StallEnableINTEL\0" // IR(17191, 17) - "FuseLoopsInFunctionINTEL\0" // IR(17208, 25) - "MathOpDSPModeINTEL\0" // IR(17233, 19) - "AliasScopeINTEL\0" // IR(17252, 16) - "NoAliasINTEL\0" // IR(17268, 13) - "InitiationIntervalINTEL\0" // IR(17281, 24) - "MaxConcurrencyINTEL\0" // IR(17305, 20) - "PipelineEnableINTEL\0" // IR(17325, 20) - "BufferLocationINTEL\0" // IR(17345, 20) - "IOPipeStorageINTEL\0" // IR(17365, 19) - "SPV_OPERAND_TYPE_FPOPERATION_MODE\0" // IR(17384, 34) - "FunctionFloatingPointModeINTEL\0" // IR(17418, 31) - "SingleElementVectorINTEL\0" // IR(17449, 25) - "VectorComputeCallableFunctionINTEL\0" // IR(17474, 35) - "MediaBlockIOINTEL\0" // IR(17509, 18) - "StallFreeINTEL\0" // IR(17527, 15) - "SPV_OPERAND_TYPE_LITERAL_FLOAT\0" // IR(17542, 31) - "FPMaxErrorDecorationINTEL\0" // IR(17573, 26) - "LatencyControlLabelINTEL\0" // IR(17599, 25) - "LatencyControlConstraintINTEL\0" // IR(17624, 30) - "ConduitKernelArgumentINTEL\0" // IR(17654, 27) - "RegisterMapKernelArgumentINTEL\0" // IR(17681, 31) - "MMHostInterfaceAddressWidthINTEL\0" // IR(17712, 33) - "MMHostInterfaceDataWidthINTEL\0" // IR(17745, 30) - "MMHostInterfaceLatencyINTEL\0" // IR(17775, 28) - "SPV_OPERAND_TYPE_ACCESS_QUALIFIER\0" // IR(17803, 34) - "MMHostInterfaceReadWriteModeINTEL\0" // IR(17837, 34) - "MMHostInterfaceMaxBurstINTEL\0" // IR(17871, 29) - "MMHostInterfaceWaitRequestINTEL\0" // IR(17900, 32) - "StableKernelArgumentINTEL\0" // IR(17932, 26) - "SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER\0" // IR(17958, 39) - "HostAccessINTEL\0" // IR(17997, 16) - "SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER\0" // IR(18013, 47) - "InitModeINTEL\0" // IR(18060, 14) - "ImplementInRegisterMapINTEL\0" // IR(18074, 28) - "SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL\0" // IR(18102, 36) - "CacheControlLoadINTEL\0" // IR(18138, 22) - "SPV_OPERAND_TYPE_STORE_CACHE_CONTROL\0" // IR(18160, 37) - "CacheControlStoreINTEL\0" // IR(18197, 23) - "1D\0" // IR(18220, 3) - "2D\0" // IR(18223, 3) - "3D\0" // IR(18226, 3) - "Cube\0" // IR(18229, 5) - "Rect\0" // IR(18234, 5) - "Buffer\0" // IR(18239, 7) - "SubpassData\0" // IR(18246, 12) - "TileImageDataEXT\0" // IR(18258, 17) - "Invocations\0" // IR(18275, 12) - "SpacingEqual\0" // IR(18287, 13) - "SpacingFractionalEven\0" // IR(18300, 22) - "SpacingFractionalOdd\0" // IR(18322, 21) - "VertexOrderCw\0" // IR(18343, 14) - "VertexOrderCcw\0" // IR(18357, 15) - "PixelCenterInteger\0" // IR(18372, 19) - "OriginUpperLeft\0" // IR(18391, 16) - "OriginLowerLeft\0" // IR(18407, 16) - "EarlyFragmentTests\0" // IR(18423, 19) - "PointMode\0" // IR(18442, 10) - "Xfb\0" // IR(18452, 4) - "DepthReplacing\0" // IR(18456, 15) - "DepthGreater\0" // IR(18471, 13) - "DepthLess\0" // IR(18484, 10) - "DepthUnchanged\0" // IR(18494, 15) - "LocalSize\0" // IR(18509, 10) - "LocalSizeHint\0" // IR(18519, 14) - "InputPoints\0" // IR(18533, 12) - "InputLines\0" // IR(18545, 11) - "InputLinesAdjacency\0" // IR(18556, 20) - "Triangles\0" // IR(18576, 10) - "InputTrianglesAdjacency\0" // IR(18586, 24) - "Quads\0" // IR(18610, 6) - "Isolines\0" // IR(18616, 9) - "OutputVertices\0" // IR(18625, 15) - "OutputPoints\0" // IR(18640, 13) - "OutputLineStrip\0" // IR(18653, 16) - "OutputTriangleStrip\0" // IR(18669, 20) - "VecTypeHint\0" // IR(18689, 12) - "ContractionOff\0" // IR(18701, 15) - "Initializer\0" // IR(18716, 12) - "Finalizer\0" // IR(18728, 10) - "SubgroupsPerWorkgroup\0" // IR(18738, 22) - "SubgroupsPerWorkgroupId\0" // IR(18760, 24) - "LocalSizeId\0" // IR(18784, 12) - "LocalSizeHintId\0" // IR(18796, 16) - "NonCoherentColorAttachmentReadEXT\0" // IR(18812, 34) - "NonCoherentDepthAttachmentReadEXT\0" // IR(18846, 34) - "NonCoherentStencilAttachmentReadEXT\0" // IR(18880, 36) - "SubgroupUniformControlFlowKHR\0" // IR(18916, 30) - "PostDepthCoverage\0" // IR(18946, 18) - "NonCoherentTileAttachmentReadQCOM\0" // IR(18964, 34) - "TileShadingRateQCOM\0" // IR(18998, 20) - "EarlyAndLateFragmentTestsAMD\0" // IR(19018, 29) - "StencilRefReplacingEXT\0" // IR(19047, 23) - "CoalescingAMDX\0" // IR(19070, 15) - "IsApiEntryAMDX\0" // IR(19085, 15) - "MaxNodeRecursionAMDX\0" // IR(19100, 21) - "StaticNumWorkgroupsAMDX\0" // IR(19121, 24) - "MaxNumWorkgroupsAMDX\0" // IR(19145, 21) - "StencilRefUnchangedFrontAMD\0" // IR(19166, 28) - "StencilRefGreaterFrontAMD\0" // IR(19194, 26) - "StencilRefLessFrontAMD\0" // IR(19220, 23) - "StencilRefUnchangedBackAMD\0" // IR(19243, 27) - "StencilRefGreaterBackAMD\0" // IR(19270, 25) - "StencilRefLessBackAMD\0" // IR(19295, 22) - "QuadDerivativesKHR\0" // IR(19317, 19) - "RequireFullQuadsKHR\0" // IR(19336, 20) - "SharesInputWithAMDX\0" // IR(19356, 20) - "OutputLinesEXT\0" // IR(19376, 15) - "OutputLinesNV\0" // IR(19391, 14) - "OutputPrimitivesEXT\0" // IR(19405, 20) - "OutputPrimitivesNV\0" // IR(19425, 19) - "DerivativeGroupQuadsKHR\0" // IR(19444, 24) - "DerivativeGroupQuadsNV\0" // IR(19468, 23) - "DerivativeGroupLinearKHR\0" // IR(19491, 25) - "DerivativeGroupLinearNV\0" // IR(19516, 24) - "OutputTrianglesEXT\0" // IR(19540, 19) - "OutputTrianglesNV\0" // IR(19559, 18) - "PixelInterlockOrderedEXT\0" // IR(19577, 25) - "PixelInterlockUnorderedEXT\0" // IR(19602, 27) - "SampleInterlockOrderedEXT\0" // IR(19629, 26) - "SampleInterlockUnorderedEXT\0" // IR(19655, 28) - "ShadingRateInterlockOrderedEXT\0" // IR(19683, 31) - "ShadingRateInterlockUnorderedEXT\0" // IR(19714, 33) - "SharedLocalMemorySizeINTEL\0" // IR(19747, 27) - "RoundingModeRTPINTEL\0" // IR(19774, 21) - "RoundingModeRTNINTEL\0" // IR(19795, 21) - "FloatingPointModeALTINTEL\0" // IR(19816, 26) - "FloatingPointModeIEEEINTEL\0" // IR(19842, 27) - "MaxWorkgroupSizeINTEL\0" // IR(19869, 22) - "MaxWorkDimINTEL\0" // IR(19891, 16) - "NoGlobalOffsetINTEL\0" // IR(19907, 20) - "NumSIMDWorkitemsINTEL\0" // IR(19927, 22) - "SchedulerTargetFmaxMhzINTEL\0" // IR(19949, 28) - "MaximallyReconvergesKHR\0" // IR(19977, 24) - "FPFastMathDefault\0" // IR(20001, 18) - "StreamingInterfaceINTEL\0" // IR(20019, 24) - "RegisterMapInterfaceINTEL\0" // IR(20043, 26) - "NamedBarrierCountINTEL\0" // IR(20069, 23) - "MaximumRegistersINTEL\0" // IR(20092, 22) - "MaximumRegistersIdINTEL\0" // IR(20114, 24) - "SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS\0" // IR(20138, 51) - "NamedMaximumRegistersINTEL\0" // IR(20189, 27) - "Vertex\0" // IR(20216, 7) - "TessellationControl\0" // IR(20223, 20) - "TessellationEvaluation\0" // IR(20243, 23) - "GLCompute\0" // IR(20266, 10) - "TaskNV\0" // IR(20276, 7) - "MeshNV\0" // IR(20283, 7) - "RayGenerationKHR\0" // IR(20290, 17) - "RayGenerationNV\0" // IR(20307, 16) - "IntersectionKHR\0" // IR(20323, 16) - "IntersectionNV\0" // IR(20339, 15) - "AnyHitKHR\0" // IR(20354, 10) - "AnyHitNV\0" // IR(20364, 9) - "ClosestHitKHR\0" // IR(20373, 14) - "ClosestHitNV\0" // IR(20387, 13) - "MissKHR\0" // IR(20400, 8) - "MissNV\0" // IR(20408, 7) - "CallableKHR\0" // IR(20415, 12) - "CallableNV\0" // IR(20427, 11) - "TaskEXT\0" // IR(20438, 8) - "MeshEXT\0" // IR(20446, 8) - "Preserve\0" // IR(20454, 9) - "FlushToZero\0" // IR(20463, 12) - "BFloat16KHR\0" // IR(20475, 12) - "Float8E4M3EXT\0" // IR(20487, 14) - "Float8E5M2EXT\0" // IR(20501, 14) - "IEEE\0" // IR(20515, 5) - "ALT\0" // IR(20520, 4) - "NotNaN\0" // IR(20524, 7) - "NotInf\0" // IR(20531, 7) - "NSZ\0" // IR(20538, 4) - "AllowRecip\0" // IR(20542, 11) - "Fast\0" // IR(20553, 5) - "AllowContract\0" // IR(20558, 14) - "AllowContractFastINTEL\0" // IR(20572, 23) - "AllowReassoc\0" // IR(20595, 13) - "AllowReassocINTEL\0" // IR(20608, 18) - "AllowTransform\0" // IR(20626, 15) - "RTE\0" // IR(20641, 4) - "RTZ\0" // IR(20645, 4) - "RTP\0" // IR(20649, 4) - "RTN\0" // IR(20653, 4) - "Vertical2Pixels\0" // IR(20657, 16) - "Vertical4Pixels\0" // IR(20673, 16) - "Horizontal2Pixels\0" // IR(20689, 18) - "Horizontal4Pixels\0" // IR(20707, 18) - "Inline\0" // IR(20725, 7) - "DontInline\0" // IR(20732, 11) - "Pure\0" // IR(20743, 5) - "Const\0" // IR(20748, 6) - "Zext\0" // IR(20754, 5) - "Sext\0" // IR(20759, 5) - "ByVal\0" // IR(20764, 6) - "Sret\0" // IR(20770, 5) - "NoAlias\0" // IR(20775, 8) - "NoCapture\0" // IR(20783, 10) - "NoWrite\0" // IR(20793, 8) - "NoReadWrite\0" // IR(20801, 12) - "RuntimeAlignedINTEL\0" // IR(20813, 20) - "Reduce\0" // IR(20833, 7) - "InclusiveScan\0" // IR(20840, 14) - "ExclusiveScan\0" // IR(20854, 14) - "ClusteredReduce\0" // IR(20868, 16) - "PartitionedReduceNV\0" // IR(20884, 20) - "PartitionedInclusiveScanNV\0" // IR(20904, 27) - "PartitionedExclusiveScanNV\0" // IR(20931, 27) - "NoneINTEL\0" // IR(20958, 10) - "ReadINTEL\0" // IR(20968, 10) - "WriteINTEL\0" // IR(20978, 11) - "ReadWriteINTEL\0" // IR(20989, 15) - "Bias\0" // IR(21004, 5) - "Lod\0" // IR(21009, 4) - "Grad\0" // IR(21013, 5) - "ConstOffset\0" // IR(21018, 12) - "ConstOffsets\0" // IR(21030, 13) - "MakeTexelAvailable\0" // IR(21043, 19) - "MakeTexelAvailableKHR\0" // IR(21062, 22) - "MakeTexelVisible\0" // IR(21084, 17) - "MakeTexelVisibleKHR\0" // IR(21101, 20) - "NonPrivateTexel\0" // IR(21121, 16) - "NonPrivateTexelKHR\0" // IR(21137, 19) - "VolatileTexel\0" // IR(21156, 14) - "VolatileTexelKHR\0" // IR(21170, 17) - "SignExtend\0" // IR(21187, 11) - "ZeroExtend\0" // IR(21198, 11) - "Nontemporal\0" // IR(21209, 12) - "Offsets\0" // IR(21221, 8) - "SnormInt8\0" // IR(21229, 10) - "SnormInt16\0" // IR(21239, 11) - "UnormInt8\0" // IR(21250, 10) - "UnormInt16\0" // IR(21260, 11) - "UnormShort565\0" // IR(21271, 14) - "UnormShort555\0" // IR(21285, 14) - "UnormInt101010\0" // IR(21299, 15) - "SignedInt8\0" // IR(21314, 11) - "SignedInt16\0" // IR(21325, 12) - "SignedInt32\0" // IR(21337, 12) - "UnsignedInt8\0" // IR(21349, 13) - "UnsignedInt16\0" // IR(21362, 14) - "UnsignedInt32\0" // IR(21376, 14) - "HalfFloat\0" // IR(21390, 10) - "UnormInt24\0" // IR(21400, 11) - "UnormInt101010_2\0" // IR(21411, 17) - "UnormInt10X6EXT\0" // IR(21428, 16) - "UnsignedIntRaw10EXT\0" // IR(21444, 20) - "UnsignedIntRaw12EXT\0" // IR(21464, 20) - "UnormInt2_101010EXT\0" // IR(21484, 20) - "UnsignedInt10X6EXT\0" // IR(21504, 19) - "UnsignedInt12X4EXT\0" // IR(21523, 19) - "UnsignedInt14X2EXT\0" // IR(21542, 19) - "UnormInt12X4EXT\0" // IR(21561, 16) - "UnormInt14X2EXT\0" // IR(21577, 16) - "R\0" // IR(21593, 2) - "A\0" // IR(21595, 2) - "RG\0" // IR(21597, 3) - "RA\0" // IR(21600, 3) - "RGB\0" // IR(21603, 4) - "RGBA\0" // IR(21607, 5) - "BGRA\0" // IR(21612, 5) - "ARGB\0" // IR(21617, 5) - "Intensity\0" // IR(21622, 10) - "Luminance\0" // IR(21632, 10) - "Rx\0" // IR(21642, 3) - "RGx\0" // IR(21645, 4) - "RGBx\0" // IR(21649, 5) - "Depth\0" // IR(21654, 6) - "DepthStencil\0" // IR(21660, 13) - "sRGB\0" // IR(21673, 5) - "sRGBx\0" // IR(21678, 6) - "sRGBA\0" // IR(21684, 6) - "sBGRA\0" // IR(21690, 6) - "ABGR\0" // IR(21696, 5) - "InitOnDeviceReprogramINTEL\0" // IR(21701, 27) - "InitOnDeviceResetINTEL\0" // IR(21728, 23) - "NoWait\0" // IR(21751, 7) - "WaitKernel\0" // IR(21758, 11) - "WaitWorkGroup\0" // IR(21769, 14) - "CmdExecTime\0" // IR(21783, 12) - "MayUsePrintf\0" // IR(21795, 13) - "Export\0" // IR(21808, 7) - "Import\0" // IR(21815, 7) - "LinkOnceODR\0" // IR(21822, 12) - "UncachedINTEL\0" // IR(21834, 14) - "CachedINTEL\0" // IR(21848, 12) - "StreamingINTEL\0" // IR(21860, 15) - "InvalidateAfterReadINTEL\0" // IR(21875, 25) - "ConstCachedINTEL\0" // IR(21900, 17) - "Unroll\0" // IR(21917, 7) - "DontUnroll\0" // IR(21924, 11) - "DependencyInfinite\0" // IR(21935, 19) - "DependencyLength\0" // IR(21954, 17) - "MinIterations\0" // IR(21971, 14) - "MaxIterations\0" // IR(21985, 14) - "IterationMultiple\0" // IR(21999, 18) - "PeelCount\0" // IR(22017, 10) - "PartialCount\0" // IR(22027, 13) - "DependencyArrayINTEL\0" // IR(22040, 21) - "LoopCoalesceINTEL\0" // IR(22061, 18) - "MaxInterleavingINTEL\0" // IR(22079, 21) - "SpeculatedIterationsINTEL\0" // IR(22100, 26) - "NoFusionINTEL\0" // IR(22126, 14) - "LoopCountINTEL\0" // IR(22140, 15) - "MaxReinvocationDelayINTEL\0" // IR(22155, 26) - "MatrixASignedComponentsINTEL\0" // IR(22181, 29) - "MatrixBSignedComponentsINTEL\0" // IR(22210, 29) - "MatrixCBFloat16INTEL\0" // IR(22239, 21) - "MatrixResultBFloat16INTEL\0" // IR(22260, 26) - "MatrixAPackedInt8INTEL\0" // IR(22286, 23) - "MatrixBPackedInt8INTEL\0" // IR(22309, 23) - "MatrixAPackedInt4INTEL\0" // IR(22332, 23) - "MatrixBPackedInt4INTEL\0" // IR(22355, 23) - "MatrixATF32INTEL\0" // IR(22378, 17) - "MatrixBTF32INTEL\0" // IR(22395, 17) - "MatrixAPackedFloat16INTEL\0" // IR(22412, 26) - "MatrixBPackedFloat16INTEL\0" // IR(22438, 26) - "MatrixAPackedBFloat16INTEL\0" // IR(22464, 27) - "MatrixBPackedBFloat16INTEL\0" // IR(22491, 27) - "Aligned\0" // IR(22518, 8) - "MakePointerAvailable\0" // IR(22526, 21) - "MakePointerAvailableKHR\0" // IR(22547, 24) - "MakePointerVisible\0" // IR(22571, 19) - "MakePointerVisibleKHR\0" // IR(22590, 22) - "NonPrivatePointer\0" // IR(22612, 18) - "NonPrivatePointerKHR\0" // IR(22630, 21) - "AliasScopeINTELMask\0" // IR(22651, 20) - "NoAliasINTELMask\0" // IR(22671, 17) - "Simple\0" // IR(22688, 7) - "GLSL450\0" // IR(22695, 8) - "OpenCL\0" // IR(22703, 7) - "Vulkan\0" // IR(22710, 7) - "VulkanKHR\0" // IR(22717, 10) - "Relaxed\0" // IR(22727, 8) - "Acquire\0" // IR(22735, 8) - "Release\0" // IR(22743, 8) - "AcquireRelease\0" // IR(22751, 15) - "SequentiallyConsistent\0" // IR(22766, 23) - "UniformMemory\0" // IR(22789, 14) - "SubgroupMemory\0" // IR(22803, 15) - "WorkgroupMemory\0" // IR(22818, 16) - "CrossWorkgroupMemory\0" // IR(22834, 21) - "AtomicCounterMemory\0" // IR(22855, 20) - "ImageMemory\0" // IR(22875, 12) - "OutputMemory\0" // IR(22887, 13) - "OutputMemoryKHR\0" // IR(22900, 16) - "MakeAvailable\0" // IR(22916, 14) - "MakeAvailableKHR\0" // IR(22930, 17) - "MakeVisible\0" // IR(22947, 12) - "MakeVisibleKHR\0" // IR(22959, 15) - "AutoINTEL\0" // IR(22974, 10) - "WRAP\0" // IR(22984, 5) - "SAT\0" // IR(22989, 4) - "SAT_ZERO\0" // IR(22993, 9) - "SAT_SYM\0" // IR(23002, 8) - "PackedVectorFormat4x8Bit\0" // IR(23010, 25) - "PackedVectorFormat4x8BitKHR\0" // IR(23035, 28) - "TRN\0" // IR(23063, 4) - "TRN_ZERO\0" // IR(23067, 9) - "RND\0" // IR(23076, 4) - "RND_ZERO\0" // IR(23080, 9) - "RND_INF\0" // IR(23089, 8) - "RND_MIN_INF\0" // IR(23097, 12) - "RND_CONV\0" // IR(23109, 9) - "RND_CONV_ODD\0" // IR(23118, 13) - "RobustnessPerComponentNV\0" // IR(23131, 25) - "RobustnessPerElementNV\0" // IR(23156, 23) - "OpaqueKHR\0" // IR(23179, 10) - "NoOpaqueKHR\0" // IR(23189, 12) - "TerminateOnFirstHitKHR\0" // IR(23201, 23) - "SkipClosestHitShaderKHR\0" // IR(23224, 24) - "CullBackFacingTrianglesKHR\0" // IR(23248, 27) - "CullFrontFacingTrianglesKHR\0" // IR(23275, 28) - "CullOpaqueKHR\0" // IR(23303, 14) - "CullNoOpaqueKHR\0" // IR(23317, 16) - "SkipTrianglesKHR\0" // IR(23333, 17) - "SkipBuiltinPrimitivesNV\0" // IR(23350, 24) - "SkipAABBsKHR\0" // IR(23374, 13) - "ForceOpacityMicromap2StateEXT\0" // IR(23387, 30) - "RayQueryCandidateIntersectionTriangleKHR\0" // IR(23417, 41) - "RayQueryCandidateIntersectionAABBKHR\0" // IR(23458, 37) - "RayQueryCommittedIntersectionNoneKHR\0" // IR(23495, 37) - "RayQueryCommittedIntersectionTriangleKHR\0" // IR(23532, 41) - "RayQueryCommittedIntersectionGeneratedKHR\0" // IR(23573, 42) - "RayQueryCandidateIntersectionKHR\0" // IR(23615, 33) - "RayQueryCommittedIntersectionKHR\0" // IR(23648, 33) - "ClampToEdge\0" // IR(23681, 12) - "Clamp\0" // IR(23693, 6) - "Repeat\0" // IR(23699, 7) - "RepeatMirrored\0" // IR(23706, 15) - "Nearest\0" // IR(23721, 8) - "Linear\0" // IR(23729, 7) - "Unknown\0" // IR(23736, 8) - "Rgba32f\0" // IR(23744, 8) - "Rgba16f\0" // IR(23752, 8) - "R32f\0" // IR(23760, 5) - "Rgba8\0" // IR(23765, 6) - "Rgba8Snorm\0" // IR(23771, 11) - "Rg32f\0" // IR(23782, 6) - "Rg16f\0" // IR(23788, 6) - "R11fG11fB10f\0" // IR(23794, 13) - "R16f\0" // IR(23807, 5) - "Rgba16\0" // IR(23812, 7) - "Rgb10A2\0" // IR(23819, 8) - "Rg16\0" // IR(23827, 5) - "Rg8\0" // IR(23832, 4) - "R16\0" // IR(23836, 4) - "R8\0" // IR(23840, 3) - "Rgba16Snorm\0" // IR(23843, 12) - "Rg16Snorm\0" // IR(23855, 10) - "Rg8Snorm\0" // IR(23865, 9) - "R16Snorm\0" // IR(23874, 9) - "R8Snorm\0" // IR(23883, 8) - "Rgba32i\0" // IR(23891, 8) - "Rgba16i\0" // IR(23899, 8) - "Rgba8i\0" // IR(23907, 7) - "R32i\0" // IR(23914, 5) - "Rg32i\0" // IR(23919, 6) - "Rg16i\0" // IR(23925, 6) - "Rg8i\0" // IR(23931, 5) - "R16i\0" // IR(23936, 5) - "R8i\0" // IR(23941, 4) - "Rgba32ui\0" // IR(23945, 9) - "Rgba16ui\0" // IR(23954, 9) - "Rgba8ui\0" // IR(23963, 8) - "R32ui\0" // IR(23971, 6) - "Rgb10a2ui\0" // IR(23977, 10) - "Rg32ui\0" // IR(23987, 7) - "Rg16ui\0" // IR(23994, 7) - "Rg8ui\0" // IR(24001, 6) - "R16ui\0" // IR(24007, 6) - "R8ui\0" // IR(24013, 5) - "R64ui\0" // IR(24018, 6) - "R64i\0" // IR(24024, 5) - "CrossDevice\0" // IR(24029, 12) - "Device\0" // IR(24041, 7) - "Workgroup\0" // IR(24048, 10) - "Subgroup\0" // IR(24058, 9) - "Invocation\0" // IR(24067, 11) - "QueueFamily\0" // IR(24078, 12) - "QueueFamilyKHR\0" // IR(24090, 15) - "ShaderCallKHR\0" // IR(24105, 14) - "Flatten\0" // IR(24119, 8) - "DontFlatten\0" // IR(24127, 12) - "IdentifierPossibleDuplicates\0" // IR(24139, 29) - "FlagUnknownPhysicalLayout\0" // IR(24168, 26) - "ESSL\0" // IR(24194, 5) - "GLSL\0" // IR(24199, 5) - "OpenCL_C\0" // IR(24204, 9) - "OpenCL_CPP\0" // IR(24213, 11) - "HLSL\0" // IR(24224, 5) - "CPP_for_OpenCL\0" // IR(24229, 15) - "SYCL\0" // IR(24244, 5) - "HERO_C\0" // IR(24249, 7) - "NZSL\0" // IR(24256, 5) - "WGSL\0" // IR(24261, 5) - "Slang\0" // IR(24266, 6) - "Zig\0" // IR(24272, 4) - "Rust\0" // IR(24276, 5) - "UniformConstant\0" // IR(24281, 16) - "Input\0" // IR(24297, 6) - "Output\0" // IR(24303, 7) - "CrossWorkgroup\0" // IR(24310, 15) - "Private\0" // IR(24325, 8) - "Function\0" // IR(24333, 9) - "Generic\0" // IR(24342, 8) - "PushConstant\0" // IR(24350, 13) - "AtomicCounter\0" // IR(24363, 14) - "Image\0" // IR(24377, 6) - "StorageBuffer\0" // IR(24383, 14) - "TileImageEXT\0" // IR(24397, 13) - "TileAttachmentQCOM\0" // IR(24410, 19) - "NodePayloadAMDX\0" // IR(24429, 16) - "CallableDataKHR\0" // IR(24445, 16) - "CallableDataNV\0" // IR(24461, 15) - "IncomingCallableDataKHR\0" // IR(24476, 24) - "IncomingCallableDataNV\0" // IR(24500, 23) - "RayPayloadKHR\0" // IR(24523, 14) - "RayPayloadNV\0" // IR(24537, 13) - "HitAttributeKHR\0" // IR(24550, 16) - "HitAttributeNV\0" // IR(24566, 15) - "IncomingRayPayloadKHR\0" // IR(24581, 22) - "IncomingRayPayloadNV\0" // IR(24603, 21) - "ShaderRecordBufferKHR\0" // IR(24624, 22) - "ShaderRecordBufferNV\0" // IR(24646, 21) - "PhysicalStorageBuffer\0" // IR(24667, 22) - "PhysicalStorageBufferEXT\0" // IR(24689, 25) - "HitObjectAttributeNV\0" // IR(24714, 21) - "TaskPayloadWorkgroupEXT\0" // IR(24735, 24) - "CodeSectionINTEL\0" // IR(24759, 17) - "DeviceOnlyINTEL\0" // IR(24776, 16) - "HostOnlyINTEL\0" // IR(24792, 14) - "WriteThroughINTEL\0" // IR(24806, 18) - "WriteBackINTEL\0" // IR(24824, 15) - "TensorView\0" // IR(24839, 11) - "DecodeFunc\0" // IR(24850, 11) - "Undefined\0" // IR(24861, 10) - "NoneARM\0" // IR(24871, 8) - "NontemporalARM\0" // IR(24879, 15) - "OutOfBoundsValueARM\0" // IR(24894, 20) - "MakeElementAvailableARM\0" // IR(24914, 24) - "MakeElementVisibleARM\0" // IR(24938, 22) - "NonPrivateElementARM\0" // IR(24960, 21) - "Nop\0" // IR(24981, 4) - "SPV_OPERAND_TYPE_TYPE_ID\0" // IR(24985, 25) - "SPV_OPERAND_TYPE_RESULT_ID\0" // IR(25010, 27) - "Undef\0" // IR(25037, 6) - "SourceContinued\0" // IR(25043, 16) - "SPV_OPERAND_TYPE_SOURCE_LANGUAGE\0" // IR(25059, 33) - "SPV_OPERAND_TYPE_OPTIONAL_ID\0" // IR(25092, 29) - "SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING\0" // IR(25121, 41) - "Source\0" // IR(25162, 7) - "SourceExtension\0" // IR(25169, 16) - "Name\0" // IR(25185, 5) - "MemberName\0" // IR(25190, 11) - "String\0" // IR(25201, 7) - "Line\0" // IR(25208, 5) - "Extension\0" // IR(25213, 10) - "ExtInstImport\0" // IR(25223, 14) - "SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER\0" // IR(25237, 46) - "ExtInst\0" // IR(25283, 8) - "SPV_OPERAND_TYPE_ADDRESSING_MODEL\0" // IR(25291, 34) - "SPV_OPERAND_TYPE_MEMORY_MODEL\0" // IR(25325, 30) - "MemoryModel\0" // IR(25355, 12) - "SPV_OPERAND_TYPE_EXECUTION_MODEL\0" // IR(25367, 33) - "SPV_OPERAND_TYPE_VARIABLE_ID\0" // IR(25400, 29) - "EntryPoint\0" // IR(25429, 11) - "SPV_OPERAND_TYPE_EXECUTION_MODE\0" // IR(25440, 32) - "ExecutionMode\0" // IR(25472, 14) - "SPV_OPERAND_TYPE_CAPABILITY\0" // IR(25486, 28) - "Capability\0" // IR(25514, 11) - "TypeVoid\0" // IR(25525, 9) - "TypeBool\0" // IR(25534, 9) - "TypeInt\0" // IR(25543, 8) - "SPV_OPERAND_TYPE_OPTIONAL_FPENCODING\0" // IR(25551, 37) - "TypeFloat\0" // IR(25588, 10) - "TypeVector\0" // IR(25598, 11) - "TypeMatrix\0" // IR(25609, 11) - "SPV_OPERAND_TYPE_DIMENSIONALITY\0" // IR(25620, 32) - "SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT\0" // IR(25652, 38) - "SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER\0" // IR(25690, 43) - "TypeImage\0" // IR(25733, 10) - "TypeSampler\0" // IR(25743, 12) - "TypeSampledImage\0" // IR(25755, 17) - "TypeArray\0" // IR(25772, 10) - "TypeRuntimeArray\0" // IR(25782, 17) - "TypeStruct\0" // IR(25799, 11) - "TypeOpaque\0" // IR(25810, 11) - "SPV_OPERAND_TYPE_STORAGE_CLASS\0" // IR(25821, 31) - "TypePointer\0" // IR(25852, 12) - "TypeFunction\0" // IR(25864, 13) - "TypeEvent\0" // IR(25877, 10) - "TypeDeviceEvent\0" // IR(25887, 16) - "TypeReserveId\0" // IR(25903, 14) - "TypeQueue\0" // IR(25917, 10) - "TypePipe\0" // IR(25927, 9) - "TypeForwardPointer\0" // IR(25936, 19) - "ConstantTrue\0" // IR(25955, 13) - "ConstantFalse\0" // IR(25968, 14) - "SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER\0" // IR(25982, 38) - "ConstantComposite\0" // IR(26020, 18) - "SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE\0" // IR(26038, 41) - "SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE\0" // IR(26079, 37) - "ConstantSampler\0" // IR(26116, 16) - "ConstantNull\0" // IR(26132, 13) - "SpecConstantTrue\0" // IR(26145, 17) - "SpecConstantFalse\0" // IR(26162, 18) - "SpecConstant\0" // IR(26180, 13) - "SpecConstantComposite\0" // IR(26193, 22) - "SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER\0" // IR(26215, 41) - "SpecConstantOp\0" // IR(26256, 15) - "SPV_OPERAND_TYPE_FUNCTION_CONTROL\0" // IR(26271, 34) - "FunctionParameter\0" // IR(26305, 18) - "FunctionEnd\0" // IR(26323, 12) - "FunctionCall\0" // IR(26335, 13) - "Variable\0" // IR(26348, 9) - "ImageTexelPointer\0" // IR(26357, 18) - "SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS\0" // IR(26375, 40) - "Load\0" // IR(26415, 5) - "Store\0" // IR(26420, 6) - "CopyMemory\0" // IR(26426, 11) - "CopyMemorySized\0" // IR(26437, 16) - "AccessChain\0" // IR(26453, 12) - "InBoundsAccessChain\0" // IR(26465, 20) - "PtrAccessChain\0" // IR(26485, 15) - "ArrayLength\0" // IR(26500, 12) - "GenericPtrMemSemantics\0" // IR(26512, 23) - "InBoundsPtrAccessChain\0" // IR(26535, 23) - "SPV_OPERAND_TYPE_DECORATION\0" // IR(26558, 28) - "Decorate\0" // IR(26586, 9) - "MemberDecorate\0" // IR(26595, 15) - "DecorationGroup\0" // IR(26610, 16) - "GroupDecorate\0" // IR(26626, 14) - "SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER\0" // IR(26640, 45) - "GroupMemberDecorate\0" // IR(26685, 20) - "VectorExtractDynamic\0" // IR(26705, 21) - "VectorInsertDynamic\0" // IR(26726, 20) - "VectorShuffle\0" // IR(26746, 14) - "CompositeConstruct\0" // IR(26760, 19) - "CompositeExtract\0" // IR(26779, 17) - "CompositeInsert\0" // IR(26796, 16) - "CopyObject\0" // IR(26812, 11) - "Transpose\0" // IR(26823, 10) - "SampledImage\0" // IR(26833, 13) - "SPV_OPERAND_TYPE_OPTIONAL_IMAGE\0" // IR(26846, 32) - "ImageSampleImplicitLod\0" // IR(26878, 23) - "SPV_OPERAND_TYPE_IMAGE\0" // IR(26901, 23) - "ImageSampleExplicitLod\0" // IR(26924, 23) - "ImageSampleDrefImplicitLod\0" // IR(26947, 27) - "ImageSampleDrefExplicitLod\0" // IR(26974, 27) - "ImageSampleProjImplicitLod\0" // IR(27001, 27) - "ImageSampleProjExplicitLod\0" // IR(27028, 27) - "ImageSampleProjDrefImplicitLod\0" // IR(27055, 31) - "ImageSampleProjDrefExplicitLod\0" // IR(27086, 31) - "ImageFetch\0" // IR(27117, 11) - "ImageGather\0" // IR(27128, 12) - "ImageDrefGather\0" // IR(27140, 16) - "ImageRead\0" // IR(27156, 10) - "ImageWrite\0" // IR(27166, 11) - "ImageQueryFormat\0" // IR(27177, 17) - "ImageQueryOrder\0" // IR(27194, 16) - "ImageQuerySizeLod\0" // IR(27210, 18) - "ImageQuerySize\0" // IR(27228, 15) - "ImageQueryLod\0" // IR(27243, 14) - "ImageQueryLevels\0" // IR(27257, 17) - "ImageQuerySamples\0" // IR(27274, 18) - "ConvertFToU\0" // IR(27292, 12) - "ConvertFToS\0" // IR(27304, 12) - "ConvertSToF\0" // IR(27316, 12) - "ConvertUToF\0" // IR(27328, 12) - "UConvert\0" // IR(27340, 9) - "SConvert\0" // IR(27349, 9) - "FConvert\0" // IR(27358, 9) - "QuantizeToF16\0" // IR(27367, 14) - "ConvertPtrToU\0" // IR(27381, 14) - "SatConvertSToU\0" // IR(27395, 15) - "SatConvertUToS\0" // IR(27410, 15) - "ConvertUToPtr\0" // IR(27425, 14) - "PtrCastToGeneric\0" // IR(27439, 17) - "GenericCastToPtr\0" // IR(27456, 17) - "GenericCastToPtrExplicit\0" // IR(27473, 25) - "Bitcast\0" // IR(27498, 8) - "SNegate\0" // IR(27506, 8) - "FNegate\0" // IR(27514, 8) - "IAdd\0" // IR(27522, 5) - "FAdd\0" // IR(27527, 5) - "ISub\0" // IR(27532, 5) - "FSub\0" // IR(27537, 5) - "IMul\0" // IR(27542, 5) - "FMul\0" // IR(27547, 5) - "UDiv\0" // IR(27552, 5) - "SDiv\0" // IR(27557, 5) - "FDiv\0" // IR(27562, 5) - "UMod\0" // IR(27567, 5) - "SRem\0" // IR(27572, 5) - "SMod\0" // IR(27577, 5) - "FRem\0" // IR(27582, 5) - "FMod\0" // IR(27587, 5) - "VectorTimesScalar\0" // IR(27592, 18) - "MatrixTimesScalar\0" // IR(27610, 18) - "VectorTimesMatrix\0" // IR(27628, 18) - "MatrixTimesVector\0" // IR(27646, 18) - "MatrixTimesMatrix\0" // IR(27664, 18) - "OuterProduct\0" // IR(27682, 13) - "Dot\0" // IR(27695, 4) - "IAddCarry\0" // IR(27699, 10) - "ISubBorrow\0" // IR(27709, 11) - "UMulExtended\0" // IR(27720, 13) - "SMulExtended\0" // IR(27733, 13) - "Any\0" // IR(27746, 4) - "All\0" // IR(27750, 4) - "IsNan\0" // IR(27754, 6) - "IsInf\0" // IR(27760, 6) - "IsFinite\0" // IR(27766, 9) - "IsNormal\0" // IR(27775, 9) - "SignBitSet\0" // IR(27784, 11) - "LessOrGreater\0" // IR(27795, 14) - "Ordered\0" // IR(27809, 8) - "Unordered\0" // IR(27817, 10) - "LogicalEqual\0" // IR(27827, 13) - "LogicalNotEqual\0" // IR(27840, 16) - "LogicalOr\0" // IR(27856, 10) - "LogicalAnd\0" // IR(27866, 11) - "LogicalNot\0" // IR(27877, 11) - "Select\0" // IR(27888, 7) - "IEqual\0" // IR(27895, 7) - "INotEqual\0" // IR(27902, 10) - "UGreaterThan\0" // IR(27912, 13) - "SGreaterThan\0" // IR(27925, 13) - "UGreaterThanEqual\0" // IR(27938, 18) - "SGreaterThanEqual\0" // IR(27956, 18) - "ULessThan\0" // IR(27974, 10) - "SLessThan\0" // IR(27984, 10) - "ULessThanEqual\0" // IR(27994, 15) - "SLessThanEqual\0" // IR(28009, 15) - "FOrdEqual\0" // IR(28024, 10) - "FUnordEqual\0" // IR(28034, 12) - "FOrdNotEqual\0" // IR(28046, 13) - "FUnordNotEqual\0" // IR(28059, 15) - "FOrdLessThan\0" // IR(28074, 13) - "FUnordLessThan\0" // IR(28087, 15) - "FOrdGreaterThan\0" // IR(28102, 16) - "FUnordGreaterThan\0" // IR(28118, 18) - "FOrdLessThanEqual\0" // IR(28136, 18) - "FUnordLessThanEqual\0" // IR(28154, 20) - "FOrdGreaterThanEqual\0" // IR(28174, 21) - "FUnordGreaterThanEqual\0" // IR(28195, 23) - "ShiftRightLogical\0" // IR(28218, 18) - "ShiftRightArithmetic\0" // IR(28236, 21) - "ShiftLeftLogical\0" // IR(28257, 17) - "BitwiseOr\0" // IR(28274, 10) - "BitwiseXor\0" // IR(28284, 11) - "BitwiseAnd\0" // IR(28295, 11) - "Not\0" // IR(28306, 4) - "BitFieldInsert\0" // IR(28310, 15) - "BitFieldSExtract\0" // IR(28325, 17) - "BitFieldUExtract\0" // IR(28342, 17) - "BitReverse\0" // IR(28359, 11) - "BitCount\0" // IR(28370, 9) - "DPdx\0" // IR(28379, 5) - "DPdy\0" // IR(28384, 5) - "Fwidth\0" // IR(28389, 7) - "DPdxFine\0" // IR(28396, 9) - "DPdyFine\0" // IR(28405, 9) - "FwidthFine\0" // IR(28414, 11) - "DPdxCoarse\0" // IR(28425, 11) - "DPdyCoarse\0" // IR(28436, 11) - "FwidthCoarse\0" // IR(28447, 13) - "EmitVertex\0" // IR(28460, 11) - "EndPrimitive\0" // IR(28471, 13) - "EmitStreamVertex\0" // IR(28484, 17) - "EndStreamPrimitive\0" // IR(28501, 19) - "SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID\0" // IR(28520, 37) - "ControlBarrier\0" // IR(28557, 15) - "MemoryBarrier\0" // IR(28572, 14) - "AtomicLoad\0" // IR(28586, 11) - "AtomicStore\0" // IR(28597, 12) - "AtomicExchange\0" // IR(28609, 15) - "AtomicCompareExchange\0" // IR(28624, 22) - "AtomicCompareExchangeWeak\0" // IR(28646, 26) - "AtomicIIncrement\0" // IR(28672, 17) - "AtomicIDecrement\0" // IR(28689, 17) - "AtomicIAdd\0" // IR(28706, 11) - "AtomicISub\0" // IR(28717, 11) - "AtomicSMin\0" // IR(28728, 11) - "AtomicUMin\0" // IR(28739, 11) - "AtomicSMax\0" // IR(28750, 11) - "AtomicUMax\0" // IR(28761, 11) - "AtomicAnd\0" // IR(28772, 10) - "AtomicOr\0" // IR(28782, 9) - "AtomicXor\0" // IR(28791, 10) - "Phi\0" // IR(28801, 4) - "SPV_OPERAND_TYPE_LOOP_CONTROL\0" // IR(28805, 30) - "LoopMerge\0" // IR(28835, 10) - "SPV_OPERAND_TYPE_SELECTION_CONTROL\0" // IR(28845, 35) - "SelectionMerge\0" // IR(28880, 15) - "Label\0" // IR(28895, 6) - "Branch\0" // IR(28901, 7) - "BranchConditional\0" // IR(28908, 18) - "SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER_ID\0" // IR(28926, 45) - "Switch\0" // IR(28971, 7) - "Kill\0" // IR(28978, 5) - "Return\0" // IR(28983, 7) - "ReturnValue\0" // IR(28990, 12) - "Unreachable\0" // IR(29002, 12) - "LifetimeStart\0" // IR(29014, 14) - "LifetimeStop\0" // IR(29028, 13) - "GroupAsyncCopy\0" // IR(29041, 15) - "GroupWaitEvents\0" // IR(29056, 16) - "GroupAll\0" // IR(29072, 9) - "GroupAny\0" // IR(29081, 9) - "GroupBroadcast\0" // IR(29090, 15) - "SPV_OPERAND_TYPE_GROUP_OPERATION\0" // IR(29105, 33) - "GroupIAdd\0" // IR(29138, 10) - "GroupFAdd\0" // IR(29148, 10) - "GroupFMin\0" // IR(29158, 10) - "GroupUMin\0" // IR(29168, 10) - "GroupSMin\0" // IR(29178, 10) - "GroupFMax\0" // IR(29188, 10) - "GroupUMax\0" // IR(29198, 10) - "GroupSMax\0" // IR(29208, 10) - "ReadPipe\0" // IR(29218, 9) - "WritePipe\0" // IR(29227, 10) - "ReservedReadPipe\0" // IR(29237, 17) - "ReservedWritePipe\0" // IR(29254, 18) - "ReserveReadPipePackets\0" // IR(29272, 23) - "ReserveWritePipePackets\0" // IR(29295, 24) - "CommitReadPipe\0" // IR(29319, 15) - "CommitWritePipe\0" // IR(29334, 16) - "IsValidReserveId\0" // IR(29350, 17) - "GetNumPipePackets\0" // IR(29367, 18) - "GetMaxPipePackets\0" // IR(29385, 18) - "GroupReserveReadPipePackets\0" // IR(29403, 28) - "GroupReserveWritePipePackets\0" // IR(29431, 29) - "GroupCommitReadPipe\0" // IR(29460, 20) - "GroupCommitWritePipe\0" // IR(29480, 21) - "EnqueueMarker\0" // IR(29501, 14) - "EnqueueKernel\0" // IR(29515, 14) - "GetKernelNDrangeSubGroupCount\0" // IR(29529, 30) - "GetKernelNDrangeMaxSubGroupSize\0" // IR(29559, 32) - "GetKernelWorkGroupSize\0" // IR(29591, 23) - "GetKernelPreferredWorkGroupSizeMultiple\0" // IR(29614, 40) - "RetainEvent\0" // IR(29654, 12) - "ReleaseEvent\0" // IR(29666, 13) - "CreateUserEvent\0" // IR(29679, 16) - "IsValidEvent\0" // IR(29695, 13) - "SetUserEventStatus\0" // IR(29708, 19) - "CaptureEventProfilingInfo\0" // IR(29727, 26) - "GetDefaultQueue\0" // IR(29753, 16) - "BuildNDRange\0" // IR(29769, 13) - "ImageSparseSampleImplicitLod\0" // IR(29782, 29) - "ImageSparseSampleExplicitLod\0" // IR(29811, 29) - "ImageSparseSampleDrefImplicitLod\0" // IR(29840, 33) - "ImageSparseSampleDrefExplicitLod\0" // IR(29873, 33) - "ImageSparseSampleProjImplicitLod\0" // IR(29906, 33) - "ImageSparseSampleProjExplicitLod\0" // IR(29939, 33) - "ImageSparseSampleProjDrefImplicitLod\0" // IR(29972, 37) - "ImageSparseSampleProjDrefExplicitLod\0" // IR(30009, 37) - "ImageSparseFetch\0" // IR(30046, 17) - "ImageSparseGather\0" // IR(30063, 18) - "ImageSparseDrefGather\0" // IR(30081, 22) - "ImageSparseTexelsResident\0" // IR(30103, 26) - "NoLine\0" // IR(30129, 7) - "AtomicFlagTestAndSet\0" // IR(30136, 21) - "AtomicFlagClear\0" // IR(30157, 16) - "ImageSparseRead\0" // IR(30173, 16) - "SizeOf\0" // IR(30189, 7) - "TypePipeStorage\0" // IR(30196, 16) - "ConstantPipeStorage\0" // IR(30212, 20) - "CreatePipeFromPipeStorage\0" // IR(30232, 26) - "GetKernelLocalSizeForSubgroupCount\0" // IR(30258, 35) - "GetKernelMaxNumSubgroups\0" // IR(30293, 25) - "TypeNamedBarrier\0" // IR(30318, 17) - "NamedBarrierInitialize\0" // IR(30335, 23) - "MemoryNamedBarrier\0" // IR(30358, 19) - "ModuleProcessed\0" // IR(30377, 16) - "ExecutionModeId\0" // IR(30393, 16) - "DecorateId\0" // IR(30409, 11) - "GroupNonUniformElect\0" // IR(30420, 21) - "GroupNonUniformAll\0" // IR(30441, 19) - "GroupNonUniformAny\0" // IR(30460, 19) - "GroupNonUniformAllEqual\0" // IR(30479, 24) - "GroupNonUniformBroadcast\0" // IR(30503, 25) - "GroupNonUniformBroadcastFirst\0" // IR(30528, 30) - "GroupNonUniformInverseBallot\0" // IR(30558, 29) - "GroupNonUniformBallotBitExtract\0" // IR(30587, 32) - "GroupNonUniformBallotBitCount\0" // IR(30619, 30) - "GroupNonUniformBallotFindLSB\0" // IR(30649, 29) - "GroupNonUniformBallotFindMSB\0" // IR(30678, 29) - "GroupNonUniformShuffleXor\0" // IR(30707, 26) - "GroupNonUniformShuffleUp\0" // IR(30733, 25) - "GroupNonUniformShuffleDown\0" // IR(30758, 27) - "GroupNonUniformIAdd\0" // IR(30785, 20) - "GroupNonUniformFAdd\0" // IR(30805, 20) - "GroupNonUniformIMul\0" // IR(30825, 20) - "GroupNonUniformFMul\0" // IR(30845, 20) - "GroupNonUniformSMin\0" // IR(30865, 20) - "GroupNonUniformUMin\0" // IR(30885, 20) - "GroupNonUniformFMin\0" // IR(30905, 20) - "GroupNonUniformSMax\0" // IR(30925, 20) - "GroupNonUniformUMax\0" // IR(30945, 20) - "GroupNonUniformFMax\0" // IR(30965, 20) - "GroupNonUniformBitwiseAnd\0" // IR(30985, 26) - "GroupNonUniformBitwiseOr\0" // IR(31011, 25) - "GroupNonUniformBitwiseXor\0" // IR(31036, 26) - "GroupNonUniformLogicalAnd\0" // IR(31062, 26) - "GroupNonUniformLogicalOr\0" // IR(31088, 25) - "GroupNonUniformLogicalXor\0" // IR(31113, 26) - "GroupNonUniformQuadBroadcast\0" // IR(31139, 29) - "GroupNonUniformQuadSwap\0" // IR(31168, 24) - "CopyLogical\0" // IR(31192, 12) - "PtrEqual\0" // IR(31204, 9) - "PtrNotEqual\0" // IR(31213, 12) - "PtrDiff\0" // IR(31225, 8) - "ColorAttachmentReadEXT\0" // IR(31233, 23) - "DepthAttachmentReadEXT\0" // IR(31256, 23) - "StencilAttachmentReadEXT\0" // IR(31279, 25) - "TypeTensorARM\0" // IR(31304, 14) - "SPV_OPERAND_TYPE_OPTIONAL_TENSOR_OPERANDS\0" // IR(31318, 42) - "TensorReadARM\0" // IR(31360, 14) - "TensorWriteARM\0" // IR(31374, 15) - "TensorQuerySizeARM\0" // IR(31389, 19) - "TerminateInvocation\0" // IR(31408, 20) - "TypeUntypedPointerKHR\0" // IR(31428, 22) - "UntypedVariableKHR\0" // IR(31450, 19) - "UntypedAccessChainKHR\0" // IR(31469, 22) - "UntypedInBoundsAccessChainKHR\0" // IR(31491, 30) - "SubgroupFirstInvocationKHR\0" // IR(31521, 27) - "UntypedPtrAccessChainKHR\0" // IR(31548, 25) - "UntypedInBoundsPtrAccessChainKHR\0" // IR(31573, 33) - "UntypedArrayLengthKHR\0" // IR(31606, 22) - "UntypedPrefetchKHR\0" // IR(31628, 19) - "SubgroupAllKHR\0" // IR(31647, 15) - "SubgroupAnyKHR\0" // IR(31662, 15) - "SubgroupAllEqualKHR\0" // IR(31677, 20) - "SubgroupReadInvocationKHR\0" // IR(31697, 26) - "ExtInstWithForwardRefsKHR\0" // IR(31723, 26) - "TraceRayKHR\0" // IR(31749, 12) - "ExecuteCallableKHR\0" // IR(31761, 19) - "ConvertUToAccelerationStructureKHR\0" // IR(31780, 35) - "IgnoreIntersectionKHR\0" // IR(31815, 22) - "TerminateRayKHR\0" // IR(31837, 16) - "SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT\0" // IR(31853, 47) - "SDot\0" // IR(31900, 5) - "SDotKHR\0" // IR(31905, 8) - "UDot\0" // IR(31913, 5) - "UDotKHR\0" // IR(31918, 8) - "SUDot\0" // IR(31926, 6) - "SUDotKHR\0" // IR(31932, 9) - "SDotAccSat\0" // IR(31941, 11) - "SDotAccSatKHR\0" // IR(31952, 14) - "UDotAccSat\0" // IR(31966, 11) - "UDotAccSatKHR\0" // IR(31977, 14) - "SUDotAccSat\0" // IR(31991, 12) - "SUDotAccSatKHR\0" // IR(32003, 15) - "TypeCooperativeMatrixKHR\0" // IR(32018, 25) - "CooperativeMatrixLoadKHR\0" // IR(32043, 25) - "CooperativeMatrixStoreKHR\0" // IR(32068, 26) - "SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS\0" // IR(32094, 54) - "CooperativeMatrixMulAddKHR\0" // IR(32148, 27) - "CooperativeMatrixLengthKHR\0" // IR(32175, 27) - "ConstantCompositeReplicateEXT\0" // IR(32202, 30) - "SpecConstantCompositeReplicateEXT\0" // IR(32232, 34) - "CompositeConstructReplicateEXT\0" // IR(32266, 31) - "TypeRayQueryKHR\0" // IR(32297, 16) - "RayQueryInitializeKHR\0" // IR(32313, 22) - "RayQueryTerminateKHR\0" // IR(32335, 21) - "RayQueryGenerateIntersectionKHR\0" // IR(32356, 32) - "RayQueryConfirmIntersectionKHR\0" // IR(32388, 31) - "RayQueryProceedKHR\0" // IR(32419, 19) - "RayQueryGetIntersectionTypeKHR\0" // IR(32438, 31) - "ImageSampleWeightedQCOM\0" // IR(32469, 24) - "ImageBoxFilterQCOM\0" // IR(32493, 19) - "ImageBlockMatchSSDQCOM\0" // IR(32512, 23) - "ImageBlockMatchSADQCOM\0" // IR(32535, 23) - "ImageBlockMatchWindowSSDQCOM\0" // IR(32558, 29) - "ImageBlockMatchWindowSADQCOM\0" // IR(32587, 29) - "ImageBlockMatchGatherSSDQCOM\0" // IR(32616, 29) - "ImageBlockMatchGatherSADQCOM\0" // IR(32645, 29) - "GroupIAddNonUniformAMD\0" // IR(32674, 23) - "GroupFAddNonUniformAMD\0" // IR(32697, 23) - "GroupFMinNonUniformAMD\0" // IR(32720, 23) - "GroupUMinNonUniformAMD\0" // IR(32743, 23) - "GroupSMinNonUniformAMD\0" // IR(32766, 23) - "GroupFMaxNonUniformAMD\0" // IR(32789, 23) - "GroupUMaxNonUniformAMD\0" // IR(32812, 23) - "GroupSMaxNonUniformAMD\0" // IR(32835, 23) - "FragmentMaskFetchAMD\0" // IR(32858, 21) - "FragmentFetchAMD\0" // IR(32879, 17) - "ReadClockKHR\0" // IR(32896, 13) - "AllocateNodePayloadsAMDX\0" // IR(32909, 25) - "EnqueueNodePayloadsAMDX\0" // IR(32934, 24) - "TypeNodePayloadArrayAMDX\0" // IR(32958, 25) - "FinishWritingNodePayloadAMDX\0" // IR(32983, 29) - "NodePayloadArrayLengthAMDX\0" // IR(33012, 27) - "IsNodePayloadValidAMDX\0" // IR(33039, 23) - "ConstantStringAMDX\0" // IR(33062, 19) - "SpecConstantStringAMDX\0" // IR(33081, 23) - "GroupNonUniformQuadAllKHR\0" // IR(33104, 26) - "GroupNonUniformQuadAnyKHR\0" // IR(33130, 26) - "HitObjectRecordHitMotionNV\0" // IR(33156, 27) - "HitObjectRecordHitWithIndexMotionNV\0" // IR(33183, 36) - "HitObjectRecordMissMotionNV\0" // IR(33219, 28) - "HitObjectGetWorldToObjectNV\0" // IR(33247, 28) - "HitObjectGetObjectToWorldNV\0" // IR(33275, 28) - "HitObjectGetObjectRayDirectionNV\0" // IR(33303, 33) - "HitObjectGetObjectRayOriginNV\0" // IR(33336, 30) - "HitObjectTraceRayMotionNV\0" // IR(33366, 26) - "HitObjectGetShaderRecordBufferHandleNV\0" // IR(33392, 39) - "HitObjectGetShaderBindingTableRecordIndexNV\0" // IR(33431, 44) - "HitObjectRecordEmptyNV\0" // IR(33475, 23) - "HitObjectTraceRayNV\0" // IR(33498, 20) - "HitObjectRecordHitNV\0" // IR(33518, 21) - "HitObjectRecordHitWithIndexNV\0" // IR(33539, 30) - "HitObjectRecordMissNV\0" // IR(33569, 22) - "HitObjectExecuteShaderNV\0" // IR(33591, 25) - "HitObjectGetCurrentTimeNV\0" // IR(33616, 26) - "HitObjectGetAttributesNV\0" // IR(33642, 25) - "HitObjectGetHitKindNV\0" // IR(33667, 22) - "HitObjectGetPrimitiveIndexNV\0" // IR(33689, 29) - "HitObjectGetGeometryIndexNV\0" // IR(33718, 28) - "HitObjectGetInstanceIdNV\0" // IR(33746, 25) - "HitObjectGetInstanceCustomIndexNV\0" // IR(33771, 34) - "HitObjectGetWorldRayDirectionNV\0" // IR(33805, 32) - "HitObjectGetWorldRayOriginNV\0" // IR(33837, 29) - "HitObjectGetRayTMaxNV\0" // IR(33866, 22) - "HitObjectGetRayTMinNV\0" // IR(33888, 22) - "HitObjectIsEmptyNV\0" // IR(33910, 19) - "HitObjectIsHitNV\0" // IR(33929, 17) - "HitObjectIsMissNV\0" // IR(33946, 18) - "ReorderThreadWithHitObjectNV\0" // IR(33964, 29) - "ReorderThreadWithHintNV\0" // IR(33993, 24) - "TypeHitObjectNV\0" // IR(34017, 16) - "ImageSampleFootprintNV\0" // IR(34033, 23) - "TypeCooperativeVectorNV\0" // IR(34056, 24) - "CooperativeVectorMatrixMulNV\0" // IR(34080, 29) - "CooperativeVectorOuterProductAccumulateNV\0" // IR(34109, 42) - "CooperativeVectorReduceSumAccumulateNV\0" // IR(34151, 39) - "CooperativeVectorMatrixMulAddNV\0" // IR(34190, 32) - "CooperativeMatrixConvertNV\0" // IR(34222, 27) - "EmitMeshTasksEXT\0" // IR(34249, 17) - "SetMeshOutputsEXT\0" // IR(34266, 18) - "GroupNonUniformPartitionNV\0" // IR(34284, 27) - "WritePackedPrimitiveIndices4x8NV\0" // IR(34311, 33) - "FetchMicroTriangleVertexPositionNV\0" // IR(34344, 35) - "FetchMicroTriangleVertexBarycentricNV\0" // IR(34379, 38) - "CooperativeVectorLoadNV\0" // IR(34417, 24) - "CooperativeVectorStoreNV\0" // IR(34441, 25) - "ReportIntersectionKHR\0" // IR(34466, 22) - "ReportIntersectionNV\0" // IR(34488, 21) - "IgnoreIntersectionNV\0" // IR(34509, 21) - "TerminateRayNV\0" // IR(34530, 15) - "TraceNV\0" // IR(34545, 8) - "TraceMotionNV\0" // IR(34553, 14) - "TraceRayMotionNV\0" // IR(34567, 17) - "RayQueryGetIntersectionTriangleVertexPositionsKHR\0" // IR(34584, 50) - "TypeAccelerationStructureKHR\0" // IR(34634, 29) - "TypeAccelerationStructureNV\0" // IR(34663, 28) - "ExecuteCallableNV\0" // IR(34691, 18) - "RayQueryGetClusterIdNV\0" // IR(34709, 23) - "HitObjectGetClusterIdNV\0" // IR(34732, 24) - "TypeCooperativeMatrixNV\0" // IR(34756, 24) - "CooperativeMatrixLoadNV\0" // IR(34780, 24) - "CooperativeMatrixStoreNV\0" // IR(34804, 25) - "CooperativeMatrixMulAddNV\0" // IR(34829, 26) - "CooperativeMatrixLengthNV\0" // IR(34855, 26) - "BeginInvocationInterlockEXT\0" // IR(34881, 28) - "EndInvocationInterlockEXT\0" // IR(34909, 26) - "SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE\0" // IR(34935, 43) - "CooperativeMatrixReduceNV\0" // IR(34978, 26) - "SPV_OPERAND_TYPE_MEMORY_ACCESS\0" // IR(35004, 31) - "SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS\0" // IR(35035, 44) - "CooperativeMatrixLoadTensorNV\0" // IR(35079, 30) - "CooperativeMatrixStoreTensorNV\0" // IR(35109, 31) - "CooperativeMatrixPerElementOpNV\0" // IR(35140, 32) - "TypeTensorLayoutNV\0" // IR(35172, 19) - "TypeTensorViewNV\0" // IR(35191, 17) - "CreateTensorLayoutNV\0" // IR(35208, 21) - "TensorLayoutSetDimensionNV\0" // IR(35229, 27) - "TensorLayoutSetStrideNV\0" // IR(35256, 24) - "TensorLayoutSliceNV\0" // IR(35280, 20) - "TensorLayoutSetClampValueNV\0" // IR(35300, 28) - "CreateTensorViewNV\0" // IR(35328, 19) - "TensorViewSetDimensionNV\0" // IR(35347, 25) - "TensorViewSetStrideNV\0" // IR(35372, 22) - "IsHelperInvocationEXT\0" // IR(35394, 22) - "TensorViewSetClipNV\0" // IR(35416, 20) - "TensorLayoutSetBlockSizeNV\0" // IR(35436, 27) - "CooperativeMatrixTransposeNV\0" // IR(35463, 29) - "ConvertUToImageNV\0" // IR(35492, 18) - "ConvertUToSamplerNV\0" // IR(35510, 20) - "ConvertImageToUNV\0" // IR(35530, 18) - "ConvertSamplerToUNV\0" // IR(35548, 20) - "ConvertUToSampledImageNV\0" // IR(35568, 25) - "ConvertSampledImageToUNV\0" // IR(35593, 25) - "SamplerImageAddressingModeNV\0" // IR(35618, 29) - "SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS\0" // IR(35647, 52) - "RawAccessChainNV\0" // IR(35699, 17) - "RayQueryGetIntersectionSpherePositionNV\0" // IR(35716, 40) - "RayQueryGetIntersectionSphereRadiusNV\0" // IR(35756, 38) - "RayQueryGetIntersectionLSSPositionsNV\0" // IR(35794, 38) - "RayQueryGetIntersectionLSSRadiiNV\0" // IR(35832, 34) - "RayQueryGetIntersectionLSSHitValueNV\0" // IR(35866, 37) - "HitObjectGetSpherePositionNV\0" // IR(35903, 29) - "HitObjectGetSphereRadiusNV\0" // IR(35932, 27) - "HitObjectGetLSSPositionsNV\0" // IR(35959, 27) - "HitObjectGetLSSRadiiNV\0" // IR(35986, 23) - "HitObjectIsSphereHitNV\0" // IR(36009, 23) - "HitObjectIsLSSHitNV\0" // IR(36032, 20) - "RayQueryIsSphereHitNV\0" // IR(36052, 22) - "RayQueryIsLSSHitNV\0" // IR(36074, 19) - "SubgroupShuffleDownINTEL\0" // IR(36093, 25) - "SubgroupShuffleUpINTEL\0" // IR(36118, 23) - "SubgroupShuffleXorINTEL\0" // IR(36141, 24) - "SubgroupBlockReadINTEL\0" // IR(36165, 23) - "SubgroupBlockWriteINTEL\0" // IR(36188, 24) - "SubgroupImageBlockReadINTEL\0" // IR(36212, 28) - "SubgroupImageBlockWriteINTEL\0" // IR(36240, 29) - "SubgroupImageMediaBlockReadINTEL\0" // IR(36269, 33) - "SubgroupImageMediaBlockWriteINTEL\0" // IR(36302, 34) - "UCountLeadingZerosINTEL\0" // IR(36336, 24) - "UCountTrailingZerosINTEL\0" // IR(36360, 25) - "AbsISubINTEL\0" // IR(36385, 13) - "AbsUSubINTEL\0" // IR(36398, 13) - "IAddSatINTEL\0" // IR(36411, 13) - "UAddSatINTEL\0" // IR(36424, 13) - "IAverageINTEL\0" // IR(36437, 14) - "UAverageINTEL\0" // IR(36451, 14) - "IAverageRoundedINTEL\0" // IR(36465, 21) - "UAverageRoundedINTEL\0" // IR(36486, 21) - "ISubSatINTEL\0" // IR(36507, 13) - "USubSatINTEL\0" // IR(36520, 13) - "IMul32x16INTEL\0" // IR(36533, 15) - "UMul32x16INTEL\0" // IR(36548, 15) - "ConstantFunctionPointerINTEL\0" // IR(36563, 29) - "FunctionPointerCallINTEL\0" // IR(36592, 25) - "AsmTargetINTEL\0" // IR(36617, 15) - "AsmCallINTEL\0" // IR(36632, 13) - "AtomicFMinEXT\0" // IR(36645, 14) - "AtomicFMaxEXT\0" // IR(36659, 14) - "AssumeTrueKHR\0" // IR(36673, 14) - "ExpectKHR\0" // IR(36687, 10) - "DecorateString\0" // IR(36697, 15) - "DecorateStringGOOGLE\0" // IR(36712, 21) - "MemberDecorateString\0" // IR(36733, 21) - "MemberDecorateStringGOOGLE\0" // IR(36754, 27) - "VmeImageINTEL\0" // IR(36781, 14) - "TypeVmeImageINTEL\0" // IR(36795, 18) - "TypeAvcImePayloadINTEL\0" // IR(36813, 23) - "TypeAvcRefPayloadINTEL\0" // IR(36836, 23) - "TypeAvcSicPayloadINTEL\0" // IR(36859, 23) - "TypeAvcMcePayloadINTEL\0" // IR(36882, 23) - "TypeAvcMceResultINTEL\0" // IR(36905, 22) - "TypeAvcImeResultINTEL\0" // IR(36927, 22) - "TypeAvcImeResultSingleReferenceStreamoutINTEL\0" // IR(36949, 46) - "TypeAvcImeResultDualReferenceStreamoutINTEL\0" // IR(36995, 44) - "TypeAvcImeSingleReferenceStreaminINTEL\0" // IR(37039, 39) - "TypeAvcImeDualReferenceStreaminINTEL\0" // IR(37078, 37) - "TypeAvcRefResultINTEL\0" // IR(37115, 22) - "TypeAvcSicResultINTEL\0" // IR(37137, 22) - "SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL\0" // IR(37159, 60) - "SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL\0" // IR(37219, 53) - "SubgroupAvcMceGetDefaultInterShapePenaltyINTEL\0" // IR(37272, 47) - "SubgroupAvcMceSetInterShapePenaltyINTEL\0" // IR(37319, 40) - "SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL\0" // IR(37359, 51) - "SubgroupAvcMceSetInterDirectionPenaltyINTEL\0" // IR(37410, 44) - "SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL\0" // IR(37454, 51) - "SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL\0" // IR(37505, 56) - "SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL\0" // IR(37561, 50) - "SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL\0" // IR(37611, 52) - "SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL\0" // IR(37663, 49) - "SubgroupAvcMceSetMotionVectorCostFunctionINTEL\0" // IR(37712, 47) - "SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL\0" // IR(37759, 50) - "SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL\0" // IR(37809, 51) - "SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL\0" // IR(37860, 56) - "SubgroupAvcMceSetAcOnlyHaarINTEL\0" // IR(37916, 33) - "SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL\0" // IR(37949, 52) - "SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL\0" // IR(38001, 61) - "SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL\0" // IR(38062, 61) - "SubgroupAvcMceConvertToImePayloadINTEL\0" // IR(38123, 39) - "SubgroupAvcMceConvertToImeResultINTEL\0" // IR(38162, 38) - "SubgroupAvcMceConvertToRefPayloadINTEL\0" // IR(38200, 39) - "SubgroupAvcMceConvertToRefResultINTEL\0" // IR(38239, 38) - "SubgroupAvcMceConvertToSicPayloadINTEL\0" // IR(38277, 39) - "SubgroupAvcMceConvertToSicResultINTEL\0" // IR(38316, 38) - "SubgroupAvcMceGetMotionVectorsINTEL\0" // IR(38354, 36) - "SubgroupAvcMceGetInterDistortionsINTEL\0" // IR(38390, 39) - "SubgroupAvcMceGetBestInterDistortionsINTEL\0" // IR(38429, 43) - "SubgroupAvcMceGetInterMajorShapeINTEL\0" // IR(38472, 38) - "SubgroupAvcMceGetInterMinorShapeINTEL\0" // IR(38510, 38) - "SubgroupAvcMceGetInterDirectionsINTEL\0" // IR(38548, 38) - "SubgroupAvcMceGetInterMotionVectorCountINTEL\0" // IR(38586, 45) - "SubgroupAvcMceGetInterReferenceIdsINTEL\0" // IR(38631, 40) - "SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL\0" // IR(38671, 62) - "SubgroupAvcImeInitializeINTEL\0" // IR(38733, 30) - "SubgroupAvcImeSetSingleReferenceINTEL\0" // IR(38763, 38) - "SubgroupAvcImeSetDualReferenceINTEL\0" // IR(38801, 36) - "SubgroupAvcImeRefWindowSizeINTEL\0" // IR(38837, 33) - "SubgroupAvcImeAdjustRefOffsetINTEL\0" // IR(38870, 35) - "SubgroupAvcImeConvertToMcePayloadINTEL\0" // IR(38905, 39) - "SubgroupAvcImeSetMaxMotionVectorCountINTEL\0" // IR(38944, 43) - "SubgroupAvcImeSetUnidirectionalMixDisableINTEL\0" // IR(38987, 47) - "SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL\0" // IR(39034, 54) - "SubgroupAvcImeSetWeightedSadINTEL\0" // IR(39088, 34) - "SubgroupAvcImeEvaluateWithSingleReferenceINTEL\0" // IR(39122, 47) - "SubgroupAvcImeEvaluateWithDualReferenceINTEL\0" // IR(39169, 45) - "SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL\0" // IR(39214, 55) - "SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL\0" // IR(39269, 53) - "SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL\0" // IR(39322, 56) - "SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL\0" // IR(39378, 54) - "SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL\0" // IR(39432, 58) - "SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL\0" // IR(39490, 56) - "SubgroupAvcImeConvertToMceResultINTEL\0" // IR(39546, 38) - "SubgroupAvcImeGetSingleReferenceStreaminINTEL\0" // IR(39584, 46) - "SubgroupAvcImeGetDualReferenceStreaminINTEL\0" // IR(39630, 44) - "SubgroupAvcImeStripSingleReferenceStreamoutINTEL\0" // IR(39674, 49) - "SubgroupAvcImeStripDualReferenceStreamoutINTEL\0" // IR(39723, 47) - "SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL\0" // IR(39770, 70) - "SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL\0" // IR(39840, 68) - "SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL\0" // IR(39908, 69) - "SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL\0" // IR(39977, 68) - "SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL\0" // IR(40045, 66) - "SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL\0" // IR(40111, 67) - "SubgroupAvcImeGetBorderReachedINTEL\0" // IR(40178, 36) - "SubgroupAvcImeGetTruncatedSearchIndicationINTEL\0" // IR(40214, 48) - "SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL\0" // IR(40262, 59) - "SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL\0" // IR(40321, 58) - "SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL\0" // IR(40379, 56) - "SubgroupAvcFmeInitializeINTEL\0" // IR(40435, 30) - "SubgroupAvcBmeInitializeINTEL\0" // IR(40465, 30) - "SubgroupAvcRefConvertToMcePayloadINTEL\0" // IR(40495, 39) - "SubgroupAvcRefSetBidirectionalMixDisableINTEL\0" // IR(40534, 46) - "SubgroupAvcRefSetBilinearFilterEnableINTEL\0" // IR(40580, 43) - "SubgroupAvcRefEvaluateWithSingleReferenceINTEL\0" // IR(40623, 47) - "SubgroupAvcRefEvaluateWithDualReferenceINTEL\0" // IR(40670, 45) - "SubgroupAvcRefEvaluateWithMultiReferenceINTEL\0" // IR(40715, 46) - "SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL\0" // IR(40761, 56) - "SubgroupAvcRefConvertToMceResultINTEL\0" // IR(40817, 38) - "SubgroupAvcSicInitializeINTEL\0" // IR(40855, 30) - "SubgroupAvcSicConfigureSkcINTEL\0" // IR(40885, 32) - "SubgroupAvcSicConfigureIpeLumaINTEL\0" // IR(40917, 36) - "SubgroupAvcSicConfigureIpeLumaChromaINTEL\0" // IR(40953, 42) - "SubgroupAvcSicGetMotionVectorMaskINTEL\0" // IR(40995, 39) - "SubgroupAvcSicConvertToMcePayloadINTEL\0" // IR(41034, 39) - "SubgroupAvcSicSetIntraLumaShapePenaltyINTEL\0" // IR(41073, 44) - "SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL\0" // IR(41117, 48) - "SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL\0" // IR(41165, 50) - "SubgroupAvcSicSetBilinearFilterEnableINTEL\0" // IR(41215, 43) - "SubgroupAvcSicSetSkcForwardTransformEnableINTEL\0" // IR(41258, 48) - "SubgroupAvcSicSetBlockBasedRawSkipSadINTEL\0" // IR(41306, 43) - "SubgroupAvcSicEvaluateIpeINTEL\0" // IR(41349, 31) - "SubgroupAvcSicEvaluateWithSingleReferenceINTEL\0" // IR(41380, 47) - "SubgroupAvcSicEvaluateWithDualReferenceINTEL\0" // IR(41427, 45) - "SubgroupAvcSicEvaluateWithMultiReferenceINTEL\0" // IR(41472, 46) - "SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL\0" // IR(41518, 56) - "SubgroupAvcSicConvertToMceResultINTEL\0" // IR(41574, 38) - "SubgroupAvcSicGetIpeLumaShapeINTEL\0" // IR(41612, 35) - "SubgroupAvcSicGetBestIpeLumaDistortionINTEL\0" // IR(41647, 44) - "SubgroupAvcSicGetBestIpeChromaDistortionINTEL\0" // IR(41691, 46) - "SubgroupAvcSicGetPackedIpeLumaModesINTEL\0" // IR(41737, 41) - "SubgroupAvcSicGetIpeChromaModeINTEL\0" // IR(41778, 36) - "SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL\0" // IR(41814, 50) - "SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL\0" // IR(41864, 48) - "SubgroupAvcSicGetInterRawSadsINTEL\0" // IR(41912, 35) - "SaveMemoryINTEL\0" // IR(41947, 16) - "RestoreMemoryINTEL\0" // IR(41963, 19) - "ArbitraryFloatSinCosPiINTEL\0" // IR(41982, 28) - "ArbitraryFloatCastINTEL\0" // IR(42010, 24) - "ArbitraryFloatCastFromIntINTEL\0" // IR(42034, 31) - "ArbitraryFloatCastToIntINTEL\0" // IR(42065, 29) - "ArbitraryFloatAddINTEL\0" // IR(42094, 23) - "ArbitraryFloatSubINTEL\0" // IR(42117, 23) - "ArbitraryFloatMulINTEL\0" // IR(42140, 23) - "ArbitraryFloatDivINTEL\0" // IR(42163, 23) - "ArbitraryFloatGTINTEL\0" // IR(42186, 22) - "ArbitraryFloatGEINTEL\0" // IR(42208, 22) - "ArbitraryFloatLTINTEL\0" // IR(42230, 22) - "ArbitraryFloatLEINTEL\0" // IR(42252, 22) - "ArbitraryFloatEQINTEL\0" // IR(42274, 22) - "ArbitraryFloatRecipINTEL\0" // IR(42296, 25) - "ArbitraryFloatRSqrtINTEL\0" // IR(42321, 25) - "ArbitraryFloatCbrtINTEL\0" // IR(42346, 24) - "ArbitraryFloatHypotINTEL\0" // IR(42370, 25) - "ArbitraryFloatSqrtINTEL\0" // IR(42395, 24) - "ArbitraryFloatLogINTEL\0" // IR(42419, 23) - "ArbitraryFloatLog2INTEL\0" // IR(42442, 24) - "ArbitraryFloatLog10INTEL\0" // IR(42466, 25) - "ArbitraryFloatLog1pINTEL\0" // IR(42491, 25) - "ArbitraryFloatExpINTEL\0" // IR(42516, 23) - "ArbitraryFloatExp2INTEL\0" // IR(42539, 24) - "ArbitraryFloatExp10INTEL\0" // IR(42563, 25) - "ArbitraryFloatExpm1INTEL\0" // IR(42588, 25) - "ArbitraryFloatSinINTEL\0" // IR(42613, 23) - "ArbitraryFloatCosINTEL\0" // IR(42636, 23) - "ArbitraryFloatSinCosINTEL\0" // IR(42659, 26) - "ArbitraryFloatSinPiINTEL\0" // IR(42685, 25) - "ArbitraryFloatCosPiINTEL\0" // IR(42710, 25) - "ArbitraryFloatASinINTEL\0" // IR(42735, 24) - "ArbitraryFloatASinPiINTEL\0" // IR(42759, 26) - "ArbitraryFloatACosINTEL\0" // IR(42785, 24) - "ArbitraryFloatACosPiINTEL\0" // IR(42809, 26) - "ArbitraryFloatATanINTEL\0" // IR(42835, 24) - "ArbitraryFloatATanPiINTEL\0" // IR(42859, 26) - "ArbitraryFloatATan2INTEL\0" // IR(42885, 25) - "ArbitraryFloatPowINTEL\0" // IR(42910, 23) - "ArbitraryFloatPowRINTEL\0" // IR(42933, 24) - "ArbitraryFloatPowNINTEL\0" // IR(42957, 24) - "LoopControlINTEL\0" // IR(42981, 17) - "AliasDomainDeclINTEL\0" // IR(42998, 21) - "AliasScopeDeclINTEL\0" // IR(43019, 20) - "AliasScopeListDeclINTEL\0" // IR(43039, 24) - "FixedSqrtINTEL\0" // IR(43063, 15) - "FixedRecipINTEL\0" // IR(43078, 16) - "FixedRsqrtINTEL\0" // IR(43094, 16) - "FixedSinINTEL\0" // IR(43110, 14) - "FixedCosINTEL\0" // IR(43124, 14) - "FixedSinCosINTEL\0" // IR(43138, 17) - "FixedSinPiINTEL\0" // IR(43155, 16) - "FixedCosPiINTEL\0" // IR(43171, 16) - "FixedSinCosPiINTEL\0" // IR(43187, 19) - "FixedLogINTEL\0" // IR(43206, 14) - "FixedExpINTEL\0" // IR(43220, 14) - "PtrCastToCrossWorkgroupINTEL\0" // IR(43234, 29) - "CrossWorkgroupCastToPtrINTEL\0" // IR(43263, 29) - "ReadPipeBlockingINTEL\0" // IR(43292, 22) - "WritePipeBlockingINTEL\0" // IR(43314, 23) - "RayQueryGetRayTMinKHR\0" // IR(43337, 22) - "RayQueryGetRayFlagsKHR\0" // IR(43359, 23) - "RayQueryGetIntersectionTKHR\0" // IR(43382, 28) - "RayQueryGetIntersectionInstanceCustomIndexKHR\0" // IR(43410, 46) - "RayQueryGetIntersectionInstanceIdKHR\0" // IR(43456, 37) - "RayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR\0" // IR(43493, 65) - "RayQueryGetIntersectionGeometryIndexKHR\0" // IR(43558, 40) - "RayQueryGetIntersectionPrimitiveIndexKHR\0" // IR(43598, 41) - "RayQueryGetIntersectionBarycentricsKHR\0" // IR(43639, 39) - "RayQueryGetIntersectionFrontFaceKHR\0" // IR(43678, 36) - "RayQueryGetIntersectionCandidateAABBOpaqueKHR\0" // IR(43714, 46) - "RayQueryGetIntersectionObjectRayDirectionKHR\0" // IR(43760, 45) - "RayQueryGetIntersectionObjectRayOriginKHR\0" // IR(43805, 42) - "RayQueryGetWorldRayDirectionKHR\0" // IR(43847, 32) - "RayQueryGetWorldRayOriginKHR\0" // IR(43879, 29) - "RayQueryGetIntersectionObjectToWorldKHR\0" // IR(43908, 40) - "RayQueryGetIntersectionWorldToObjectKHR\0" // IR(43948, 40) - "AtomicFAddEXT\0" // IR(43988, 14) - "TypeBufferSurfaceINTEL\0" // IR(44002, 23) - "TypeStructContinuedINTEL\0" // IR(44025, 25) - "ConstantCompositeContinuedINTEL\0" // IR(44050, 32) - "SpecConstantCompositeContinuedINTEL\0" // IR(44082, 36) - "CompositeConstructContinuedINTEL\0" // IR(44118, 33) - "ConvertFToBF16INTEL\0" // IR(44151, 20) - "ConvertBF16ToFINTEL\0" // IR(44171, 20) - "ControlBarrierArriveINTEL\0" // IR(44191, 26) - "ControlBarrierWaitINTEL\0" // IR(44217, 24) - "TaskSequenceCreateINTEL\0" // IR(44241, 24) - "TaskSequenceAsyncINTEL\0" // IR(44265, 23) - "TaskSequenceGetINTEL\0" // IR(44288, 21) - "TaskSequenceReleaseINTEL\0" // IR(44309, 25) - "TypeTaskSequenceINTEL\0" // IR(44334, 22) - "SubgroupBlockPrefetchINTEL\0" // IR(44356, 27) - "Subgroup2DBlockLoadINTEL\0" // IR(44383, 25) - "Subgroup2DBlockLoadTransformINTEL\0" // IR(44408, 34) - "Subgroup2DBlockLoadTransposeINTEL\0" // IR(44442, 34) - "Subgroup2DBlockPrefetchINTEL\0" // IR(44476, 29) - "Subgroup2DBlockStoreINTEL\0" // IR(44505, 26) - "SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS\0" // IR(44531, 62) - "BitwiseFunctionINTEL\0" // IR(44593, 21) - "GroupIMulKHR\0" // IR(44614, 13) - "GroupFMulKHR\0" // IR(44627, 13) - "GroupBitwiseAndKHR\0" // IR(44640, 19) - "GroupBitwiseOrKHR\0" // IR(44659, 18) - "GroupBitwiseXorKHR\0" // IR(44677, 19) - "GroupLogicalAndKHR\0" // IR(44696, 19) - "GroupLogicalOrKHR\0" // IR(44715, 18) - "GroupLogicalXorKHR\0" // IR(44733, 19) - "RoundFToTF32INTEL\0" // IR(44752, 18) - "MaskedGatherINTEL\0" // IR(44770, 18) - "MaskedScatterINTEL\0" // IR(44788, 19) - "ConvertHandleToImageINTEL\0" // IR(44807, 26) - "ConvertHandleToSamplerINTEL\0" // IR(44833, 28) - "ConvertHandleToSampledImageINTEL\0" // IR(44861, 33) - "DebugInfoNone\0" // IR(44894, 14) - "DebugCompilationUnit\0" // IR(44908, 21) - "SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING\0" // IR(44929, 52) - "DebugTypeBasic\0" // IR(44981, 15) - "SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS\0" // IR(44996, 34) - "DebugTypePointer\0" // IR(45030, 17) - "SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER\0" // IR(45047, 38) - "DebugTypeQualifier\0" // IR(45085, 19) - "DebugTypeArray\0" // IR(45104, 15) - "DebugTypeVector\0" // IR(45119, 16) - "DebugTypedef\0" // IR(45135, 13) - "DebugTypeFunction\0" // IR(45148, 18) - "DebugTypeEnum\0" // IR(45166, 14) - "SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE\0" // IR(45180, 38) - "DebugTypeComposite\0" // IR(45218, 19) - "DebugTypeMember\0" // IR(45237, 16) - "DebugTypeInheritance\0" // IR(45253, 21) - "DebugTypePtrToMember\0" // IR(45274, 21) - "DebugTypeTemplate\0" // IR(45295, 18) - "DebugTypeTemplateParameter\0" // IR(45313, 27) - "DebugTypeTemplateTemplateParameter\0" // IR(45340, 35) - "DebugTypeTemplateParameterPack\0" // IR(45375, 31) - "DebugGlobalVariable\0" // IR(45406, 20) - "DebugFunctionDeclaration\0" // IR(45426, 25) - "DebugFunction\0" // IR(45451, 14) - "DebugLexicalBlock\0" // IR(45465, 18) - "DebugLexicalBlockDiscriminator\0" // IR(45483, 31) - "DebugScope\0" // IR(45514, 11) - "DebugNoScope\0" // IR(45525, 13) - "DebugInlinedAt\0" // IR(45538, 15) - "SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER\0" // IR(45553, 42) - "DebugLocalVariable\0" // IR(45595, 19) - "DebugInlinedVariable\0" // IR(45614, 21) - "DebugDeclare\0" // IR(45635, 13) - "DebugValue\0" // IR(45648, 11) - "SPV_OPERAND_TYPE_DEBUG_OPERATION\0" // IR(45659, 33) - "DebugOperation\0" // IR(45692, 15) - "DebugExpression\0" // IR(45707, 16) - "DebugMacroDef\0" // IR(45723, 14) - "DebugMacroUndef\0" // IR(45737, 16) - "Round\0" // IR(45753, 6) - "RoundEven\0" // IR(45759, 10) - "Trunc\0" // IR(45769, 6) - "FAbs\0" // IR(45775, 5) - "SAbs\0" // IR(45780, 5) - "FSign\0" // IR(45785, 6) - "SSign\0" // IR(45791, 6) - "Floor\0" // IR(45797, 6) - "Ceil\0" // IR(45803, 5) - "Fract\0" // IR(45808, 6) - "Radians\0" // IR(45814, 8) - "Degrees\0" // IR(45822, 8) - "Sin\0" // IR(45830, 4) - "Cos\0" // IR(45834, 4) - "Tan\0" // IR(45838, 4) - "Asin\0" // IR(45842, 5) - "Acos\0" // IR(45847, 5) - "Atan\0" // IR(45852, 5) - "Sinh\0" // IR(45857, 5) - "Cosh\0" // IR(45862, 5) - "Tanh\0" // IR(45867, 5) - "Asinh\0" // IR(45872, 6) - "Acosh\0" // IR(45878, 6) - "Atanh\0" // IR(45884, 6) - "Atan2\0" // IR(45890, 6) - "Pow\0" // IR(45896, 4) - "Exp\0" // IR(45900, 4) - "Log\0" // IR(45904, 4) - "Exp2\0" // IR(45908, 5) - "Log2\0" // IR(45913, 5) - "Sqrt\0" // IR(45918, 5) - "InverseSqrt\0" // IR(45923, 12) - "Determinant\0" // IR(45935, 12) - "MatrixInverse\0" // IR(45947, 14) - "Modf\0" // IR(45961, 5) - "ModfStruct\0" // IR(45966, 11) - "FMin\0" // IR(45977, 5) - "UMin\0" // IR(45982, 5) - "SMin\0" // IR(45987, 5) - "FMax\0" // IR(45992, 5) - "UMax\0" // IR(45997, 5) - "SMax\0" // IR(46002, 5) - "FClamp\0" // IR(46007, 7) - "UClamp\0" // IR(46014, 7) - "SClamp\0" // IR(46021, 7) - "FMix\0" // IR(46028, 5) - "IMix\0" // IR(46033, 5) - "Step\0" // IR(46038, 5) - "SmoothStep\0" // IR(46043, 11) - "Fma\0" // IR(46054, 4) - "Frexp\0" // IR(46058, 6) - "FrexpStruct\0" // IR(46064, 12) - "Ldexp\0" // IR(46076, 6) - "PackSnorm4x8\0" // IR(46082, 13) - "PackUnorm4x8\0" // IR(46095, 13) - "PackSnorm2x16\0" // IR(46108, 14) - "PackUnorm2x16\0" // IR(46122, 14) - "PackHalf2x16\0" // IR(46136, 13) - "PackDouble2x32\0" // IR(46149, 15) - "UnpackSnorm2x16\0" // IR(46164, 16) - "UnpackUnorm2x16\0" // IR(46180, 16) - "UnpackHalf2x16\0" // IR(46196, 15) - "UnpackSnorm4x8\0" // IR(46211, 15) - "UnpackUnorm4x8\0" // IR(46226, 15) - "UnpackDouble2x32\0" // IR(46241, 17) - "Length\0" // IR(46258, 7) - "Distance\0" // IR(46265, 9) - "Cross\0" // IR(46274, 6) - "Normalize\0" // IR(46280, 10) - "FaceForward\0" // IR(46290, 12) - "Reflect\0" // IR(46302, 8) - "Refract\0" // IR(46310, 8) - "FindILsb\0" // IR(46318, 9) - "FindSMsb\0" // IR(46327, 9) - "FindUMsb\0" // IR(46336, 9) - "InterpolateAtCentroid\0" // IR(46345, 22) - "InterpolateAtSample\0" // IR(46367, 20) - "InterpolateAtOffset\0" // IR(46387, 20) - "NMin\0" // IR(46407, 5) - "NMax\0" // IR(46412, 5) - "NClamp\0" // IR(46417, 7) - "ArgumentInfo\0" // IR(46424, 13) - "ArgumentStorageBuffer\0" // IR(46437, 22) - "ArgumentUniform\0" // IR(46459, 16) - "ArgumentPodStorageBuffer\0" // IR(46475, 25) - "ArgumentPodUniform\0" // IR(46500, 19) - "ArgumentPodPushConstant\0" // IR(46519, 24) - "ArgumentSampledImage\0" // IR(46543, 21) - "ArgumentStorageImage\0" // IR(46564, 21) - "ArgumentSampler\0" // IR(46585, 16) - "ArgumentWorkgroup\0" // IR(46601, 18) - "SpecConstantWorkgroupSize\0" // IR(46619, 26) - "SpecConstantGlobalOffset\0" // IR(46645, 25) - "SpecConstantWorkDim\0" // IR(46670, 20) - "PushConstantGlobalOffset\0" // IR(46690, 25) - "PushConstantEnqueuedLocalSize\0" // IR(46715, 30) - "PushConstantGlobalSize\0" // IR(46745, 23) - "PushConstantRegionOffset\0" // IR(46768, 25) - "PushConstantNumWorkgroups\0" // IR(46793, 26) - "PushConstantRegionGroupOffset\0" // IR(46819, 30) - "ConstantDataStorageBuffer\0" // IR(46849, 26) - "ConstantDataUniform\0" // IR(46875, 20) - "PropertyRequiredWorkgroupSize\0" // IR(46895, 30) - "SpecConstantSubgroupMaxSize\0" // IR(46925, 28) - "ArgumentPointerPushConstant\0" // IR(46953, 28) - "ArgumentPointerUniform\0" // IR(46981, 23) - "ProgramScopeVariablesStorageBuffer\0" // IR(47004, 35) - "ProgramScopeVariablePointerRelocation\0" // IR(47039, 38) - "ImageArgumentInfoChannelOrderPushConstant\0" // IR(47077, 42) - "ImageArgumentInfoChannelDataTypePushConstant\0" // IR(47119, 45) - "ImageArgumentInfoChannelOrderUniform\0" // IR(47164, 37) - "ImageArgumentInfoChannelDataTypeUniform\0" // IR(47201, 40) - "ArgumentStorageTexelBuffer\0" // IR(47241, 27) - "ArgumentUniformTexelBuffer\0" // IR(47268, 27) - "ConstantDataPointerPushConstant\0" // IR(47295, 32) - "ProgramScopeVariablePointerPushConstant\0" // IR(47327, 40) - "PrintfInfo\0" // IR(47367, 11) - "PrintfBufferStorageBuffer\0" // IR(47378, 26) - "PrintfBufferPointerPushConstant\0" // IR(47404, 32) - "NormalizedSamplerMaskPushConstant\0" // IR(47436, 34) - "WorkgroupVariableSize\0" // IR(47470, 22) - "DebugImportedEntity\0" // IR(47492, 20) - "DebugSource\0" // IR(47512, 12) - "DebugFunctionDefinition\0" // IR(47524, 24) - "DebugSourceContinued\0" // IR(47548, 21) - "DebugLine\0" // IR(47569, 10) - "DebugNoLine\0" // IR(47579, 12) - "DebugBuildIdentifier\0" // IR(47591, 21) - "DebugStoragePath\0" // IR(47612, 17) - "DebugEntryPoint\0" // IR(47629, 16) - "DebugTypeMatrix\0" // IR(47645, 16) - "Configuration\0" // IR(47661, 14) - "StartCounter\0" // IR(47675, 13) - "StopCounter\0" // IR(47688, 12) - "PushConstants\0" // IR(47700, 14) - "SpecializationMapEntry\0" // IR(47714, 23) - "DescriptorSetBuffer\0" // IR(47737, 20) - "DescriptorSetImage\0" // IR(47757, 19) - "DescriptorSetSampler\0" // IR(47776, 21) - "SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING\0" // IR(47797, 63) - "SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS\0" // IR(47860, 45) - "SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER\0" // IR(47905, 49) - "SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE\0" // IR(47954, 49) - "SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION\0" // IR(48003, 44) - "SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY\0" // IR(48047, 50) - "DebugModuleINTEL\0" // IR(48097, 17) - "acos\0" // IR(48114, 5) - "acosh\0" // IR(48119, 6) - "acospi\0" // IR(48125, 7) - "asin\0" // IR(48132, 5) - "asinh\0" // IR(48137, 6) - "asinpi\0" // IR(48143, 7) - "atan\0" // IR(48150, 5) - "atan2\0" // IR(48155, 6) - "atanh\0" // IR(48161, 6) - "atanpi\0" // IR(48167, 7) - "atan2pi\0" // IR(48174, 8) - "cbrt\0" // IR(48182, 5) - "ceil\0" // IR(48187, 5) - "copysign\0" // IR(48192, 9) - "cos\0" // IR(48201, 4) - "cosh\0" // IR(48205, 5) - "cospi\0" // IR(48210, 6) - "erfc\0" // IR(48216, 5) - "erf\0" // IR(48221, 4) - "exp\0" // IR(48225, 4) - "exp2\0" // IR(48229, 5) - "exp10\0" // IR(48234, 6) - "expm1\0" // IR(48240, 6) - "fabs\0" // IR(48246, 5) - "fdim\0" // IR(48251, 5) - "floor\0" // IR(48256, 6) - "fma\0" // IR(48262, 4) - "fmax\0" // IR(48266, 5) - "fmin\0" // IR(48271, 5) - "fmod\0" // IR(48276, 5) - "fract\0" // IR(48281, 6) - "frexp\0" // IR(48287, 6) - "hypot\0" // IR(48293, 6) - "ilogb\0" // IR(48299, 6) - "ldexp\0" // IR(48305, 6) - "lgamma\0" // IR(48311, 7) - "lgamma_r\0" // IR(48318, 9) - "log\0" // IR(48327, 4) - "log2\0" // IR(48331, 5) - "log10\0" // IR(48336, 6) - "log1p\0" // IR(48342, 6) - "logb\0" // IR(48348, 5) - "mad\0" // IR(48353, 4) - "maxmag\0" // IR(48357, 7) - "minmag\0" // IR(48364, 7) - "modf\0" // IR(48371, 5) - "nan\0" // IR(48376, 4) - "nextafter\0" // IR(48380, 10) - "pow\0" // IR(48390, 4) - "pown\0" // IR(48394, 5) - "powr\0" // IR(48399, 5) - "remainder\0" // IR(48404, 10) - "remquo\0" // IR(48414, 7) - "rint\0" // IR(48421, 5) - "rootn\0" // IR(48426, 6) - "round\0" // IR(48432, 6) - "rsqrt\0" // IR(48438, 6) - "sin\0" // IR(48444, 4) - "sincos\0" // IR(48448, 7) - "sinh\0" // IR(48455, 5) - "sinpi\0" // IR(48460, 6) - "sqrt\0" // IR(48466, 5) - "tan\0" // IR(48471, 4) - "tanh\0" // IR(48475, 5) - "tanpi\0" // IR(48480, 6) - "tgamma\0" // IR(48486, 7) - "trunc\0" // IR(48493, 6) - "half_cos\0" // IR(48499, 9) - "half_divide\0" // IR(48508, 12) - "half_exp\0" // IR(48520, 9) - "half_exp2\0" // IR(48529, 10) - "half_exp10\0" // IR(48539, 11) - "half_log\0" // IR(48550, 9) - "half_log2\0" // IR(48559, 10) - "half_log10\0" // IR(48569, 11) - "half_powr\0" // IR(48580, 10) - "half_recip\0" // IR(48590, 11) - "half_rsqrt\0" // IR(48601, 11) - "half_sin\0" // IR(48612, 9) - "half_sqrt\0" // IR(48621, 10) - "half_tan\0" // IR(48631, 9) - "native_cos\0" // IR(48640, 11) - "native_divide\0" // IR(48651, 14) - "native_exp\0" // IR(48665, 11) - "native_exp2\0" // IR(48676, 12) - "native_exp10\0" // IR(48688, 13) - "native_log\0" // IR(48701, 11) - "native_log2\0" // IR(48712, 12) - "native_log10\0" // IR(48724, 13) - "native_powr\0" // IR(48737, 12) - "native_recip\0" // IR(48749, 13) - "native_rsqrt\0" // IR(48762, 13) - "native_sin\0" // IR(48775, 11) - "native_sqrt\0" // IR(48786, 12) - "native_tan\0" // IR(48798, 11) - "fclamp\0" // IR(48809, 7) - "degrees\0" // IR(48816, 8) - "fmax_common\0" // IR(48824, 12) - "fmin_common\0" // IR(48836, 12) - "mix\0" // IR(48848, 4) - "radians\0" // IR(48852, 8) - "step\0" // IR(48860, 5) - "smoothstep\0" // IR(48865, 11) - "sign\0" // IR(48876, 5) - "cross\0" // IR(48881, 6) - "distance\0" // IR(48887, 9) - "length\0" // IR(48896, 7) - "normalize\0" // IR(48903, 10) - "fast_distance\0" // IR(48913, 14) - "fast_length\0" // IR(48927, 12) - "fast_normalize\0" // IR(48939, 15) - "s_abs\0" // IR(48954, 6) - "s_abs_diff\0" // IR(48960, 11) - "s_add_sat\0" // IR(48971, 10) - "u_add_sat\0" // IR(48981, 10) - "s_hadd\0" // IR(48991, 7) - "u_hadd\0" // IR(48998, 7) - "s_rhadd\0" // IR(49005, 8) - "u_rhadd\0" // IR(49013, 8) - "s_clamp\0" // IR(49021, 8) - "u_clamp\0" // IR(49029, 8) - "clz\0" // IR(49037, 4) - "ctz\0" // IR(49041, 4) - "s_mad_hi\0" // IR(49045, 9) - "u_mad_sat\0" // IR(49054, 10) - "s_mad_sat\0" // IR(49064, 10) - "s_max\0" // IR(49074, 6) - "u_max\0" // IR(49080, 6) - "s_min\0" // IR(49086, 6) - "u_min\0" // IR(49092, 6) - "s_mul_hi\0" // IR(49098, 9) - "rotate\0" // IR(49107, 7) - "s_sub_sat\0" // IR(49114, 10) - "u_sub_sat\0" // IR(49124, 10) - "u_upsample\0" // IR(49134, 11) - "s_upsample\0" // IR(49145, 11) - "popcount\0" // IR(49156, 9) - "s_mad24\0" // IR(49165, 8) - "u_mad24\0" // IR(49173, 8) - "s_mul24\0" // IR(49181, 8) - "u_mul24\0" // IR(49189, 8) - "vloadn\0" // IR(49197, 7) - "vstoren\0" // IR(49204, 8) - "vload_half\0" // IR(49212, 11) - "vload_halfn\0" // IR(49223, 12) - "vstore_half\0" // IR(49235, 12) - "vstore_half_r\0" // IR(49247, 14) - "vstore_halfn\0" // IR(49261, 13) - "vstore_halfn_r\0" // IR(49274, 15) - "vloada_halfn\0" // IR(49289, 13) - "vstorea_halfn\0" // IR(49302, 14) - "vstorea_halfn_r\0" // IR(49316, 16) - "shuffle\0" // IR(49332, 8) - "shuffle2\0" // IR(49340, 9) - "printf\0" // IR(49349, 7) - "prefetch\0" // IR(49356, 9) - "bitselect\0" // IR(49365, 10) - "select\0" // IR(49375, 7) - "u_abs\0" // IR(49382, 6) - "u_abs_diff\0" // IR(49388, 11) - "u_mul_hi\0" // IR(49399, 9) - "u_mad_hi\0" // IR(49408, 9) - "CubeFaceIndexAMD\0" // IR(49417, 17) - "CubeFaceCoordAMD\0" // IR(49434, 17) - "TimeAMD\0" // IR(49451, 8) - "SwizzleInvocationsAMD\0" // IR(49459, 22) - "SwizzleInvocationsMaskedAMD\0" // IR(49481, 28) - "WriteInvocationAMD\0" // IR(49509, 19) - "MbcntAMD\0" // IR(49528, 9) - "InterpolateAtVertexAMD\0" // IR(49537, 23) - "FMin3AMD\0" // IR(49560, 9) - "UMin3AMD\0" // IR(49569, 9) - "SMin3AMD\0" // IR(49578, 9) - "FMax3AMD\0" // IR(49587, 9) - "UMax3AMD\0" // IR(49596, 9) - "SMax3AMD\0" // IR(49605, 9) - "FMid3AMD\0" // IR(49614, 9) - "UMid3AMD\0" // IR(49623, 9) - "SMid3AMD\0" // IR(49632, 9) + "SPV_ARM_graph\0" // IR(426, 14) + "SPV_ARM_tensors\0" // IR(440, 16) + "SPV_EXT_arithmetic_fence\0" // IR(456, 25) + "SPV_EXT_demote_to_helper_invocation\0" // IR(481, 36) + "SPV_EXT_descriptor_indexing\0" // IR(517, 28) + "SPV_EXT_float8\0" // IR(545, 15) + "SPV_EXT_fragment_fully_covered\0" // IR(560, 31) + "SPV_EXT_fragment_invocation_density\0" // IR(591, 36) + "SPV_EXT_fragment_shader_interlock\0" // IR(627, 34) + "SPV_EXT_mesh_shader\0" // IR(661, 20) + "SPV_EXT_opacity_micromap\0" // IR(681, 25) + "SPV_EXT_optnone\0" // IR(706, 16) + "SPV_EXT_physical_storage_buffer\0" // IR(722, 32) + "SPV_EXT_relaxed_printf_string_address_space\0" // IR(754, 44) + "SPV_EXT_replicated_composites\0" // IR(798, 30) + "SPV_EXT_shader_atomic_float16_add\0" // IR(828, 34) + "SPV_EXT_shader_atomic_float_add\0" // IR(862, 32) + "SPV_EXT_shader_atomic_float_min_max\0" // IR(894, 36) + "SPV_EXT_shader_image_int64\0" // IR(930, 27) + "SPV_EXT_shader_stencil_export\0" // IR(957, 30) + "SPV_EXT_shader_tile_image\0" // IR(987, 26) + "SPV_EXT_shader_viewport_index_layer\0" // IR(1013, 36) + "SPV_GOOGLE_decorate_string\0" // IR(1049, 27) + "SPV_GOOGLE_hlsl_functionality1\0" // IR(1076, 31) + "SPV_GOOGLE_user_type\0" // IR(1107, 21) + "SPV_INTEL_2d_block_io\0" // IR(1128, 22) + "SPV_INTEL_arbitrary_precision_fixed_point\0" // IR(1150, 42) + "SPV_INTEL_arbitrary_precision_floating_point\0" // IR(1192, 45) + "SPV_INTEL_arbitrary_precision_integers\0" // IR(1237, 39) + "SPV_INTEL_bfloat16_conversion\0" // IR(1276, 30) + "SPV_INTEL_bindless_images\0" // IR(1306, 26) + "SPV_INTEL_blocking_pipes\0" // IR(1332, 25) + "SPV_INTEL_cache_controls\0" // IR(1357, 25) + "SPV_INTEL_debug_module\0" // IR(1382, 23) + "SPV_INTEL_device_side_avc_motion_estimation\0" // IR(1405, 44) + "SPV_INTEL_float_controls2\0" // IR(1449, 26) + "SPV_INTEL_fp_fast_math_mode\0" // IR(1475, 28) + "SPV_INTEL_fp_max_error\0" // IR(1503, 23) + "SPV_INTEL_fpga_argument_interfaces\0" // IR(1526, 35) + "SPV_INTEL_fpga_buffer_location\0" // IR(1561, 31) + "SPV_INTEL_fpga_cluster_attributes\0" // IR(1592, 34) + "SPV_INTEL_fpga_dsp_control\0" // IR(1626, 27) + "SPV_INTEL_fpga_invocation_pipelining_attributes\0" // IR(1653, 48) + "SPV_INTEL_fpga_latency_control\0" // IR(1701, 31) + "SPV_INTEL_fpga_loop_controls\0" // IR(1732, 29) + "SPV_INTEL_fpga_memory_accesses\0" // IR(1761, 31) + "SPV_INTEL_fpga_memory_attributes\0" // IR(1792, 33) + "SPV_INTEL_fpga_reg\0" // IR(1825, 19) + "SPV_INTEL_function_pointers\0" // IR(1844, 28) + "SPV_INTEL_function_variants\0" // IR(1872, 28) + "SPV_INTEL_global_variable_fpga_decorations\0" // IR(1900, 43) + "SPV_INTEL_global_variable_host_access\0" // IR(1943, 38) + "SPV_INTEL_inline_assembly\0" // IR(1981, 26) + "SPV_INTEL_int4\0" // IR(2007, 15) + "SPV_INTEL_io_pipes\0" // IR(2022, 19) + "SPV_INTEL_kernel_attributes\0" // IR(2041, 28) + "SPV_INTEL_long_composites\0" // IR(2069, 26) + "SPV_INTEL_loop_fuse\0" // IR(2095, 20) + "SPV_INTEL_masked_gather_scatter\0" // IR(2115, 32) + "SPV_INTEL_maximum_registers\0" // IR(2147, 28) + "SPV_INTEL_media_block_io\0" // IR(2175, 25) + "SPV_INTEL_memory_access_aliasing\0" // IR(2200, 33) + "SPV_INTEL_optnone\0" // IR(2233, 18) + "SPV_INTEL_runtime_aligned\0" // IR(2251, 26) + "SPV_INTEL_shader_integer_functions2\0" // IR(2277, 36) + "SPV_INTEL_split_barrier\0" // IR(2313, 24) + "SPV_INTEL_subgroup_buffer_prefetch\0" // IR(2337, 35) + "SPV_INTEL_subgroup_matrix_multiply_accumulate\0" // IR(2372, 46) + "SPV_INTEL_subgroups\0" // IR(2418, 20) + "SPV_INTEL_task_sequence\0" // IR(2438, 24) + "SPV_INTEL_tensor_float32_conversion\0" // IR(2462, 36) + "SPV_INTEL_ternary_bitwise_function\0" // IR(2498, 35) + "SPV_INTEL_unstructured_loop_controls\0" // IR(2533, 37) + "SPV_INTEL_usm_storage_classes\0" // IR(2570, 30) + "SPV_INTEL_variable_length_array\0" // IR(2600, 32) + "SPV_INTEL_vector_compute\0" // IR(2632, 25) + "SPV_KHR_16bit_storage\0" // IR(2657, 22) + "SPV_KHR_8bit_storage\0" // IR(2679, 21) + "SPV_KHR_bfloat16\0" // IR(2700, 17) + "SPV_KHR_bit_instructions\0" // IR(2717, 25) + "SPV_KHR_compute_shader_derivatives\0" // IR(2742, 35) + "SPV_KHR_cooperative_matrix\0" // IR(2777, 27) + "SPV_KHR_device_group\0" // IR(2804, 21) + "SPV_KHR_expect_assume\0" // IR(2825, 22) + "SPV_KHR_float_controls\0" // IR(2847, 23) + "SPV_KHR_float_controls2\0" // IR(2870, 24) + "SPV_KHR_fma\0" // IR(2894, 12) + "SPV_KHR_fragment_shader_barycentric\0" // IR(2906, 36) + "SPV_KHR_fragment_shading_rate\0" // IR(2942, 30) + "SPV_KHR_integer_dot_product\0" // IR(2972, 28) + "SPV_KHR_linkonce_odr\0" // IR(3000, 21) + "SPV_KHR_maximal_reconvergence\0" // IR(3021, 30) + "SPV_KHR_multiview\0" // IR(3051, 18) + "SPV_KHR_no_integer_wrap_decoration\0" // IR(3069, 35) + "SPV_KHR_non_semantic_info\0" // IR(3104, 26) + "SPV_KHR_physical_storage_buffer\0" // IR(3130, 32) + "SPV_KHR_post_depth_coverage\0" // IR(3162, 28) + "SPV_KHR_quad_control\0" // IR(3190, 21) + "SPV_KHR_ray_cull_mask\0" // IR(3211, 22) + "SPV_KHR_ray_query\0" // IR(3233, 18) + "SPV_KHR_ray_tracing\0" // IR(3251, 20) + "SPV_KHR_ray_tracing_position_fetch\0" // IR(3271, 35) + "SPV_KHR_relaxed_extended_instruction\0" // IR(3306, 37) + "SPV_KHR_shader_atomic_counter_ops\0" // IR(3343, 34) + "SPV_KHR_shader_ballot\0" // IR(3377, 22) + "SPV_KHR_shader_clock\0" // IR(3399, 21) + "SPV_KHR_shader_draw_parameters\0" // IR(3420, 31) + "SPV_KHR_storage_buffer_storage_class\0" // IR(3451, 37) + "SPV_KHR_subgroup_rotate\0" // IR(3488, 24) + "SPV_KHR_subgroup_uniform_control_flow\0" // IR(3512, 38) + "SPV_KHR_subgroup_vote\0" // IR(3550, 22) + "SPV_KHR_terminate_invocation\0" // IR(3572, 29) + "SPV_KHR_uniform_group_instructions\0" // IR(3601, 35) + "SPV_KHR_untyped_pointers\0" // IR(3636, 25) + "SPV_KHR_variable_pointers\0" // IR(3661, 26) + "SPV_KHR_vulkan_memory_model\0" // IR(3687, 28) + "SPV_KHR_workgroup_memory_explicit_layout\0" // IR(3715, 41) + "SPV_NVX_multiview_per_view_attributes\0" // IR(3756, 38) + "SPV_NV_bindless_texture\0" // IR(3794, 24) + "SPV_NV_cluster_acceleration_structure\0" // IR(3818, 38) + "SPV_NV_compute_shader_derivatives\0" // IR(3856, 34) + "SPV_NV_cooperative_matrix\0" // IR(3890, 26) + "SPV_NV_cooperative_matrix2\0" // IR(3916, 27) + "SPV_NV_cooperative_vector\0" // IR(3943, 26) + "SPV_NV_displacement_micromap\0" // IR(3969, 29) + "SPV_NV_fragment_shader_barycentric\0" // IR(3998, 35) + "SPV_NV_geometry_shader_passthrough\0" // IR(4033, 35) + "SPV_NV_linear_swept_spheres\0" // IR(4068, 28) + "SPV_NV_mesh_shader\0" // IR(4096, 19) + "SPV_NV_raw_access_chains\0" // IR(4115, 25) + "SPV_NV_ray_tracing\0" // IR(4140, 19) + "SPV_NV_ray_tracing_motion_blur\0" // IR(4159, 31) + "SPV_NV_sample_mask_override_coverage\0" // IR(4190, 37) + "SPV_NV_shader_atomic_fp16_vector\0" // IR(4227, 33) + "SPV_NV_shader_image_footprint\0" // IR(4260, 30) + "SPV_NV_shader_invocation_reorder\0" // IR(4290, 33) + "SPV_NV_shader_sm_builtins\0" // IR(4323, 26) + "SPV_NV_shader_subgroup_partitioned\0" // IR(4349, 35) + "SPV_NV_shading_rate\0" // IR(4384, 20) + "SPV_NV_stereo_view_rendering\0" // IR(4404, 29) + "SPV_NV_tensor_addressing\0" // IR(4433, 25) + "SPV_NV_viewport_array2\0" // IR(4458, 23) + "SPV_QCOM_cooperative_matrix_conversion\0" // IR(4481, 39) + "SPV_QCOM_image_processing\0" // IR(4520, 26) + "SPV_QCOM_image_processing2\0" // IR(4546, 27) + "SPV_QCOM_tile_shading\0" // IR(4573, 22) + "SPV_VALIDATOR_ignore_type_decl_unique\0" // IR(4595, 38) + "ReadOnly\0" // IR(4633, 9) + "Kernel\0" // IR(4642, 7) + "WriteOnly\0" // IR(4649, 10) + "ReadWrite\0" // IR(4659, 10) + "Logical\0" // IR(4669, 8) + "Physical32\0" // IR(4677, 11) + "Addresses\0" // IR(4688, 10) + "Physical64\0" // IR(4698, 11) + "PhysicalStorageBuffer64\0" // IR(4709, 24) + "PhysicalStorageBuffer64EXT\0" // IR(4733, 27) + "PhysicalStorageBufferAddresses\0" // IR(4760, 31) + "Position\0" // IR(4791, 9) + "Shader\0" // IR(4800, 7) + "PointSize\0" // IR(4807, 10) + "ClipDistance\0" // IR(4817, 13) + "CullDistance\0" // IR(4830, 13) + "VertexId\0" // IR(4843, 9) + "InstanceId\0" // IR(4852, 11) + "PrimitiveId\0" // IR(4863, 12) + "Geometry\0" // IR(4875, 9) + "Tessellation\0" // IR(4884, 13) + "RayTracingNV\0" // IR(4897, 13) + "RayTracingKHR\0" // IR(4910, 14) + "MeshShadingNV\0" // IR(4924, 14) + "MeshShadingEXT\0" // IR(4938, 15) + "InvocationId\0" // IR(4953, 13) + "Layer\0" // IR(4966, 6) + "ShaderLayer\0" // IR(4972, 12) + "ShaderViewportIndexLayerEXT\0" // IR(4984, 28) + "ViewportIndex\0" // IR(5012, 14) + "MultiViewport\0" // IR(5026, 14) + "ShaderViewportIndex\0" // IR(5040, 20) + "TessLevelOuter\0" // IR(5060, 15) + "TessLevelInner\0" // IR(5075, 15) + "TessCoord\0" // IR(5090, 10) + "PatchVertices\0" // IR(5100, 14) + "FragCoord\0" // IR(5114, 10) + "PointCoord\0" // IR(5124, 11) + "FrontFacing\0" // IR(5135, 12) + "SampleId\0" // IR(5147, 9) + "SampleRateShading\0" // IR(5156, 18) + "SamplePosition\0" // IR(5174, 15) + "SampleMask\0" // IR(5189, 11) + "FragDepth\0" // IR(5200, 10) + "HelperInvocation\0" // IR(5210, 17) + "NumWorkgroups\0" // IR(5227, 14) + "WorkgroupSize\0" // IR(5241, 14) + "WorkgroupId\0" // IR(5255, 12) + "LocalInvocationId\0" // IR(5267, 18) + "GlobalInvocationId\0" // IR(5285, 19) + "LocalInvocationIndex\0" // IR(5304, 21) + "WorkDim\0" // IR(5325, 8) + "GlobalSize\0" // IR(5333, 11) + "EnqueuedWorkgroupSize\0" // IR(5344, 22) + "GlobalOffset\0" // IR(5366, 13) + "GlobalLinearId\0" // IR(5379, 15) + "SubgroupSize\0" // IR(5394, 13) + "GroupNonUniform\0" // IR(5407, 16) + "SubgroupBallotKHR\0" // IR(5423, 18) + "SubgroupMaxSize\0" // IR(5441, 16) + "NumSubgroups\0" // IR(5457, 13) + "NumEnqueuedSubgroups\0" // IR(5470, 21) + "SubgroupId\0" // IR(5491, 11) + "SubgroupLocalInvocationId\0" // IR(5502, 26) + "VertexIndex\0" // IR(5528, 12) + "InstanceIndex\0" // IR(5540, 14) + "CoreIDARM\0" // IR(5554, 10) + "CoreBuiltinsARM\0" // IR(5564, 16) + "CoreCountARM\0" // IR(5580, 13) + "CoreMaxIDARM\0" // IR(5593, 13) + "WarpIDARM\0" // IR(5606, 10) + "WarpMaxIDARM\0" // IR(5616, 13) + "SubgroupEqMask\0" // IR(5629, 15) + "SubgroupEqMaskKHR\0" // IR(5644, 18) + "GroupNonUniformBallot\0" // IR(5662, 22) + "SubgroupGeMask\0" // IR(5684, 15) + "SubgroupGeMaskKHR\0" // IR(5699, 18) + "SubgroupGtMask\0" // IR(5717, 15) + "SubgroupGtMaskKHR\0" // IR(5732, 18) + "SubgroupLeMask\0" // IR(5750, 15) + "SubgroupLeMaskKHR\0" // IR(5765, 18) + "SubgroupLtMask\0" // IR(5783, 15) + "SubgroupLtMaskKHR\0" // IR(5798, 18) + "BaseVertex\0" // IR(5816, 11) + "DrawParameters\0" // IR(5827, 15) + "BaseInstance\0" // IR(5842, 13) + "DrawIndex\0" // IR(5855, 10) + "PrimitiveShadingRateKHR\0" // IR(5865, 24) + "FragmentShadingRateKHR\0" // IR(5889, 23) + "DeviceIndex\0" // IR(5912, 12) + "DeviceGroup\0" // IR(5924, 12) + "ViewIndex\0" // IR(5936, 10) + "MultiView\0" // IR(5946, 10) + "ShadingRateKHR\0" // IR(5956, 15) + "TileOffsetQCOM\0" // IR(5971, 15) + "TileShadingQCOM\0" // IR(5986, 16) + "TileDimensionQCOM\0" // IR(6002, 18) + "TileApronSizeQCOM\0" // IR(6020, 18) + "BaryCoordNoPerspAMD\0" // IR(6038, 20) + "BaryCoordNoPerspCentroidAMD\0" // IR(6058, 28) + "BaryCoordNoPerspSampleAMD\0" // IR(6086, 26) + "BaryCoordSmoothAMD\0" // IR(6112, 19) + "BaryCoordSmoothCentroidAMD\0" // IR(6131, 27) + "BaryCoordSmoothSampleAMD\0" // IR(6158, 25) + "BaryCoordPullModelAMD\0" // IR(6183, 22) + "FragStencilRefEXT\0" // IR(6205, 18) + "StencilExportEXT\0" // IR(6223, 17) + "RemainingRecursionLevelsAMDX\0" // IR(6240, 29) + "ShaderEnqueueAMDX\0" // IR(6269, 18) + "ShaderIndexAMDX\0" // IR(6287, 16) + "ViewportMaskNV\0" // IR(6303, 15) + "ShaderViewportMaskNV\0" // IR(6318, 21) + "SecondaryPositionNV\0" // IR(6339, 20) + "ShaderStereoViewNV\0" // IR(6359, 19) + "SecondaryViewportMaskNV\0" // IR(6378, 24) + "PositionPerViewNV\0" // IR(6402, 18) + "PerViewAttributesNV\0" // IR(6420, 20) + "ViewportMaskPerViewNV\0" // IR(6440, 22) + "FullyCoveredEXT\0" // IR(6462, 16) + "FragmentFullyCoveredEXT\0" // IR(6478, 24) + "TaskCountNV\0" // IR(6502, 12) + "PrimitiveCountNV\0" // IR(6514, 17) + "PrimitiveIndicesNV\0" // IR(6531, 19) + "ClipDistancePerViewNV\0" // IR(6550, 22) + "CullDistancePerViewNV\0" // IR(6572, 22) + "LayerPerViewNV\0" // IR(6594, 15) + "MeshViewCountNV\0" // IR(6609, 16) + "MeshViewIndicesNV\0" // IR(6625, 18) + "BaryCoordKHR\0" // IR(6643, 13) + "BaryCoordNV\0" // IR(6656, 12) + "FragmentBarycentricKHR\0" // IR(6668, 23) + "BaryCoordNoPerspKHR\0" // IR(6691, 20) + "BaryCoordNoPerspNV\0" // IR(6711, 19) + "FragSizeEXT\0" // IR(6730, 12) + "FragmentSizeNV\0" // IR(6742, 15) + "FragmentDensityEXT\0" // IR(6757, 19) + "FragInvocationCountEXT\0" // IR(6776, 23) + "InvocationsPerPixelNV\0" // IR(6799, 22) + "PrimitivePointIndicesEXT\0" // IR(6821, 25) + "PrimitiveLineIndicesEXT\0" // IR(6846, 24) + "PrimitiveTriangleIndicesEXT\0" // IR(6870, 28) + "CullPrimitiveEXT\0" // IR(6898, 17) + "LaunchIdKHR\0" // IR(6915, 12) + "LaunchIdNV\0" // IR(6927, 11) + "LaunchSizeKHR\0" // IR(6938, 14) + "LaunchSizeNV\0" // IR(6952, 13) + "WorldRayOriginKHR\0" // IR(6965, 18) + "WorldRayOriginNV\0" // IR(6983, 17) + "WorldRayDirectionKHR\0" // IR(7000, 21) + "WorldRayDirectionNV\0" // IR(7021, 20) + "ObjectRayOriginKHR\0" // IR(7041, 19) + "ObjectRayOriginNV\0" // IR(7060, 18) + "ObjectRayDirectionKHR\0" // IR(7078, 22) + "ObjectRayDirectionNV\0" // IR(7100, 21) + "RayTminKHR\0" // IR(7121, 11) + "RayTminNV\0" // IR(7132, 10) + "RayTmaxKHR\0" // IR(7142, 11) + "RayTmaxNV\0" // IR(7153, 10) + "InstanceCustomIndexKHR\0" // IR(7163, 23) + "InstanceCustomIndexNV\0" // IR(7186, 22) + "ObjectToWorldKHR\0" // IR(7208, 17) + "ObjectToWorldNV\0" // IR(7225, 16) + "WorldToObjectKHR\0" // IR(7241, 17) + "WorldToObjectNV\0" // IR(7258, 16) + "HitTNV\0" // IR(7274, 7) + "HitKindKHR\0" // IR(7281, 11) + "HitKindNV\0" // IR(7292, 10) + "CurrentRayTimeNV\0" // IR(7302, 17) + "RayTracingMotionBlurNV\0" // IR(7319, 23) + "HitTriangleVertexPositionsKHR\0" // IR(7342, 30) + "RayTracingPositionFetchKHR\0" // IR(7372, 27) + "HitMicroTriangleVertexPositionsNV\0" // IR(7399, 34) + "RayTracingDisplacementMicromapNV\0" // IR(7433, 33) + "HitMicroTriangleVertexBarycentricsNV\0" // IR(7466, 37) + "IncomingRayFlagsKHR\0" // IR(7503, 20) + "IncomingRayFlagsNV\0" // IR(7523, 19) + "RayGeometryIndexKHR\0" // IR(7542, 20) + "HitIsSphereNV\0" // IR(7562, 14) + "RayTracingSpheresGeometryNV\0" // IR(7576, 28) + "HitIsLSSNV\0" // IR(7604, 11) + "RayTracingLinearSweptSpheresGeometryNV\0" // IR(7615, 39) + "HitSpherePositionNV\0" // IR(7654, 20) + "WarpsPerSMNV\0" // IR(7674, 13) + "ShaderSMBuiltinsNV\0" // IR(7687, 19) + "SMCountNV\0" // IR(7706, 10) + "WarpIDNV\0" // IR(7716, 9) + "SMIDNV\0" // IR(7725, 7) + "HitLSSPositionsNV\0" // IR(7732, 18) + "HitKindFrontFacingMicroTriangleNV\0" // IR(7750, 34) + "HitKindBackFacingMicroTriangleNV\0" // IR(7784, 33) + "HitSphereRadiusNV\0" // IR(7817, 18) + "HitLSSRadiiNV\0" // IR(7835, 14) + "ClusterIDNV\0" // IR(7849, 12) + "RayTracingClusterAccelerationStructureNV\0" // IR(7861, 41) + "CullMaskKHR\0" // IR(7902, 12) + "RayCullMaskKHR\0" // IR(7914, 15) + "Matrix\0" // IR(7929, 7) + "Linkage\0" // IR(7936, 8) + "Vector16\0" // IR(7944, 9) + "Float16Buffer\0" // IR(7953, 14) + "Float16\0" // IR(7967, 8) + "Float64\0" // IR(7975, 8) + "Int64\0" // IR(7983, 6) + "Int64Atomics\0" // IR(7989, 13) + "ImageBasic\0" // IR(8002, 11) + "ImageReadWrite\0" // IR(8013, 15) + "ImageMipmap\0" // IR(8028, 12) + "Pipes\0" // IR(8040, 6) + "Groups\0" // IR(8046, 7) + "DeviceEnqueue\0" // IR(8053, 14) + "LiteralSampler\0" // IR(8067, 15) + "AtomicStorage\0" // IR(8082, 14) + "Int16\0" // IR(8096, 6) + "TessellationPointSize\0" // IR(8102, 22) + "GeometryPointSize\0" // IR(8124, 18) + "ImageGatherExtended\0" // IR(8142, 20) + "StorageImageMultisample\0" // IR(8162, 24) + "UniformBufferArrayDynamicIndexing\0" // IR(8186, 34) + "SampledImageArrayDynamicIndexing\0" // IR(8220, 33) + "StorageBufferArrayDynamicIndexing\0" // IR(8253, 34) + "StorageImageArrayDynamicIndexing\0" // IR(8287, 33) + "ImageCubeArray\0" // IR(8320, 15) + "SampledCubeArray\0" // IR(8335, 17) + "ImageRect\0" // IR(8352, 10) + "SampledRect\0" // IR(8362, 12) + "GenericPointer\0" // IR(8374, 15) + "Int8\0" // IR(8389, 5) + "InputAttachment\0" // IR(8394, 16) + "SparseResidency\0" // IR(8410, 16) + "MinLod\0" // IR(8426, 7) + "Sampled1D\0" // IR(8433, 10) + "Image1D\0" // IR(8443, 8) + "SampledBuffer\0" // IR(8451, 14) + "ImageBuffer\0" // IR(8465, 12) + "ImageMSArray\0" // IR(8477, 13) + "StorageImageExtendedFormats\0" // IR(8490, 28) + "ImageQuery\0" // IR(8518, 11) + "DerivativeControl\0" // IR(8529, 18) + "InterpolationFunction\0" // IR(8547, 22) + "TransformFeedback\0" // IR(8569, 18) + "GeometryStreams\0" // IR(8587, 16) + "StorageImageReadWithoutFormat\0" // IR(8603, 30) + "StorageImageWriteWithoutFormat\0" // IR(8633, 31) + "SubgroupDispatch\0" // IR(8664, 17) + "NamedBarrier\0" // IR(8681, 13) + "PipeStorage\0" // IR(8694, 12) + "GroupNonUniformVote\0" // IR(8706, 20) + "GroupNonUniformArithmetic\0" // IR(8726, 26) + "GroupNonUniformShuffle\0" // IR(8752, 23) + "GroupNonUniformShuffleRelative\0" // IR(8775, 31) + "GroupNonUniformClustered\0" // IR(8806, 25) + "GroupNonUniformQuad\0" // IR(8831, 20) + "UniformDecoration\0" // IR(8851, 18) + "TileImageColorReadAccessEXT\0" // IR(8869, 28) + "TileImageDepthReadAccessEXT\0" // IR(8897, 28) + "TileImageStencilReadAccessEXT\0" // IR(8925, 30) + "TensorsARM\0" // IR(8955, 11) + "StorageTensorArrayDynamicIndexingARM\0" // IR(8966, 37) + "StorageTensorArrayNonUniformIndexingARM\0" // IR(9003, 40) + "GraphARM\0" // IR(9043, 9) + "CooperativeMatrixLayoutsARM\0" // IR(9052, 28) + "Float8EXT\0" // IR(9080, 10) + "Float8CooperativeMatrixEXT\0" // IR(9090, 27) + "CooperativeMatrixKHR\0" // IR(9117, 21) + "WorkgroupMemoryExplicitLayoutKHR\0" // IR(9138, 33) + "WorkgroupMemoryExplicitLayout8BitAccessKHR\0" // IR(9171, 43) + "WorkgroupMemoryExplicitLayout16BitAccessKHR\0" // IR(9214, 44) + "SubgroupVoteKHR\0" // IR(9258, 16) + "StorageBuffer16BitAccess\0" // IR(9274, 25) + "StorageUniformBufferBlock16\0" // IR(9299, 28) + "UniformAndStorageBuffer16BitAccess\0" // IR(9327, 35) + "StorageUniform16\0" // IR(9362, 17) + "StoragePushConstant16\0" // IR(9379, 22) + "StorageInputOutput16\0" // IR(9401, 21) + "VariablePointersStorageBuffer\0" // IR(9422, 30) + "VariablePointers\0" // IR(9452, 17) + "AtomicStorageOps\0" // IR(9469, 17) + "SampleMaskPostDepthCoverage\0" // IR(9486, 28) + "StorageBuffer8BitAccess\0" // IR(9514, 24) + "UniformAndStorageBuffer8BitAccess\0" // IR(9538, 34) + "StoragePushConstant8\0" // IR(9572, 21) + "DenormPreserve\0" // IR(9593, 15) + "DenormFlushToZero\0" // IR(9608, 18) + "SignedZeroInfNanPreserve\0" // IR(9626, 25) + "RoundingModeRTE\0" // IR(9651, 16) + "RoundingModeRTZ\0" // IR(9667, 16) + "RayQueryProvisionalKHR\0" // IR(9683, 23) + "RayQueryKHR\0" // IR(9706, 12) + "UntypedPointersKHR\0" // IR(9718, 19) + "RayTraversalPrimitiveCullingKHR\0" // IR(9737, 32) + "TextureSampleWeightedQCOM\0" // IR(9769, 26) + "TextureBoxFilterQCOM\0" // IR(9795, 21) + "TextureBlockMatchQCOM\0" // IR(9816, 22) + "CooperativeMatrixConversionQCOM\0" // IR(9838, 32) + "TextureBlockMatch2QCOM\0" // IR(9870, 23) + "Float16ImageAMD\0" // IR(9893, 16) + "ImageGatherBiasLodAMD\0" // IR(9909, 22) + "FragmentMaskAMD\0" // IR(9931, 16) + "ImageReadWriteLodAMD\0" // IR(9947, 21) + "Int64ImageEXT\0" // IR(9968, 14) + "ShaderClockKHR\0" // IR(9982, 15) + "QuadControlKHR\0" // IR(9997, 15) + "Int4TypeINTEL\0" // IR(10012, 14) + "Int4CooperativeMatrixINTEL\0" // IR(10026, 27) + "BFloat16TypeKHR\0" // IR(10053, 16) + "BFloat16DotProductKHR\0" // IR(10069, 22) + "BFloat16CooperativeMatrixKHR\0" // IR(10091, 29) + "SampleMaskOverrideCoverageNV\0" // IR(10120, 29) + "GeometryShaderPassthroughNV\0" // IR(10149, 28) + "ShaderViewportIndexLayerNV\0" // IR(10177, 27) + "ImageFootprintNV\0" // IR(10204, 17) + "FragmentBarycentricNV\0" // IR(10221, 22) + "ComputeDerivativeGroupQuadsKHR\0" // IR(10243, 31) + "ComputeDerivativeGroupQuadsNV\0" // IR(10274, 30) + "ShadingRateNV\0" // IR(10304, 14) + "GroupNonUniformPartitionedNV\0" // IR(10318, 29) + "ShaderNonUniform\0" // IR(10347, 17) + "ShaderNonUniformEXT\0" // IR(10364, 20) + "RuntimeDescriptorArray\0" // IR(10384, 23) + "RuntimeDescriptorArrayEXT\0" // IR(10407, 26) + "InputAttachmentArrayDynamicIndexing\0" // IR(10433, 36) + "InputAttachmentArrayDynamicIndexingEXT\0" // IR(10469, 39) + "UniformTexelBufferArrayDynamicIndexing\0" // IR(10508, 39) + "UniformTexelBufferArrayDynamicIndexingEXT\0" // IR(10547, 42) + "StorageTexelBufferArrayDynamicIndexing\0" // IR(10589, 39) + "StorageTexelBufferArrayDynamicIndexingEXT\0" // IR(10628, 42) + "UniformBufferArrayNonUniformIndexing\0" // IR(10670, 37) + "UniformBufferArrayNonUniformIndexingEXT\0" // IR(10707, 40) + "SampledImageArrayNonUniformIndexing\0" // IR(10747, 36) + "SampledImageArrayNonUniformIndexingEXT\0" // IR(10783, 39) + "StorageBufferArrayNonUniformIndexing\0" // IR(10822, 37) + "StorageBufferArrayNonUniformIndexingEXT\0" // IR(10859, 40) + "StorageImageArrayNonUniformIndexing\0" // IR(10899, 36) + "StorageImageArrayNonUniformIndexingEXT\0" // IR(10935, 39) + "InputAttachmentArrayNonUniformIndexing\0" // IR(10974, 39) + "InputAttachmentArrayNonUniformIndexingEXT\0" // IR(11013, 42) + "UniformTexelBufferArrayNonUniformIndexing\0" // IR(11055, 42) + "UniformTexelBufferArrayNonUniformIndexingEXT\0" // IR(11097, 45) + "StorageTexelBufferArrayNonUniformIndexing\0" // IR(11142, 42) + "StorageTexelBufferArrayNonUniformIndexingEXT\0" // IR(11184, 45) + "VulkanMemoryModel\0" // IR(11229, 18) + "VulkanMemoryModelKHR\0" // IR(11247, 21) + "VulkanMemoryModelDeviceScope\0" // IR(11268, 29) + "VulkanMemoryModelDeviceScopeKHR\0" // IR(11297, 32) + "PhysicalStorageBufferAddressesEXT\0" // IR(11329, 34) + "ComputeDerivativeGroupLinearKHR\0" // IR(11363, 32) + "ComputeDerivativeGroupLinearNV\0" // IR(11395, 31) + "RayTracingProvisionalKHR\0" // IR(11426, 25) + "CooperativeMatrixNV\0" // IR(11451, 20) + "FragmentShaderSampleInterlockEXT\0" // IR(11471, 33) + "FragmentShaderShadingRateInterlockEXT\0" // IR(11504, 38) + "FragmentShaderPixelInterlockEXT\0" // IR(11542, 32) + "DemoteToHelperInvocation\0" // IR(11574, 25) + "DemoteToHelperInvocationEXT\0" // IR(11599, 28) + "DisplacementMicromapNV\0" // IR(11627, 23) + "RayTracingOpacityMicromapEXT\0" // IR(11650, 29) + "ShaderInvocationReorderNV\0" // IR(11679, 26) + "BindlessTextureNV\0" // IR(11705, 18) + "RayQueryPositionFetchKHR\0" // IR(11723, 25) + "CooperativeVectorNV\0" // IR(11748, 20) + "AtomicFloat16VectorNV\0" // IR(11768, 22) + "RawAccessChainsNV\0" // IR(11790, 18) + "CooperativeMatrixReductionsNV\0" // IR(11808, 30) + "CooperativeMatrixConversionsNV\0" // IR(11838, 31) + "CooperativeMatrixPerElementOperationsNV\0" // IR(11869, 40) + "CooperativeMatrixTensorAddressingNV\0" // IR(11909, 36) + "CooperativeMatrixBlockLoadsNV\0" // IR(11945, 30) + "CooperativeVectorTrainingNV\0" // IR(11975, 28) + "TensorAddressingNV\0" // IR(12003, 19) + "SubgroupShuffleINTEL\0" // IR(12022, 21) + "SubgroupBufferBlockIOINTEL\0" // IR(12043, 27) + "SubgroupImageBlockIOINTEL\0" // IR(12070, 26) + "SubgroupImageMediaBlockIOINTEL\0" // IR(12096, 31) + "RoundToInfinityINTEL\0" // IR(12127, 21) + "FloatingPointModeINTEL\0" // IR(12148, 23) + "IntegerFunctions2INTEL\0" // IR(12171, 23) + "FunctionPointersINTEL\0" // IR(12194, 22) + "IndirectReferencesINTEL\0" // IR(12216, 24) + "AsmINTEL\0" // IR(12240, 9) + "AtomicFloat32MinMaxEXT\0" // IR(12249, 23) + "AtomicFloat64MinMaxEXT\0" // IR(12272, 23) + "AtomicFloat16MinMaxEXT\0" // IR(12295, 23) + "VectorComputeINTEL\0" // IR(12318, 19) + "VectorAnyINTEL\0" // IR(12337, 15) + "ExpectAssumeKHR\0" // IR(12352, 16) + "SubgroupAvcMotionEstimationINTEL\0" // IR(12368, 33) + "SubgroupAvcMotionEstimationIntraINTEL\0" // IR(12401, 38) + "SubgroupAvcMotionEstimationChromaINTEL\0" // IR(12439, 39) + "VariableLengthArrayINTEL\0" // IR(12478, 25) + "FunctionFloatControlINTEL\0" // IR(12503, 26) + "FPGAMemoryAttributesINTEL\0" // IR(12529, 26) + "FPFastMathModeINTEL\0" // IR(12555, 20) + "ArbitraryPrecisionIntegersINTEL\0" // IR(12575, 32) + "ArbitraryPrecisionFloatingPointINTEL\0" // IR(12607, 37) + "UnstructuredLoopControlsINTEL\0" // IR(12644, 30) + "FPGALoopControlsINTEL\0" // IR(12674, 22) + "KernelAttributesINTEL\0" // IR(12696, 22) + "FPGAKernelAttributesINTEL\0" // IR(12718, 26) + "FPGAMemoryAccessesINTEL\0" // IR(12744, 24) + "FPGAClusterAttributesINTEL\0" // IR(12768, 27) + "LoopFuseINTEL\0" // IR(12795, 14) + "FPGADSPControlINTEL\0" // IR(12809, 20) + "MemoryAccessAliasingINTEL\0" // IR(12829, 26) + "FPGAInvocationPipeliningAttributesINTEL\0" // IR(12855, 40) + "FPGABufferLocationINTEL\0" // IR(12895, 24) + "ArbitraryPrecisionFixedPointINTEL\0" // IR(12919, 34) + "USMStorageClassesINTEL\0" // IR(12953, 23) + "RuntimeAlignedAttributeINTEL\0" // IR(12976, 29) + "IOPipesINTEL\0" // IR(13005, 13) + "BlockingPipesINTEL\0" // IR(13018, 19) + "FPGARegINTEL\0" // IR(13037, 13) + "DotProductInputAll\0" // IR(13050, 19) + "DotProductInputAllKHR\0" // IR(13069, 22) + "DotProductInput4x8Bit\0" // IR(13091, 22) + "DotProductInput4x8BitKHR\0" // IR(13113, 25) + "DotProductInput4x8BitPacked\0" // IR(13138, 28) + "DotProductInput4x8BitPackedKHR\0" // IR(13166, 31) + "DotProduct\0" // IR(13197, 11) + "DotProductKHR\0" // IR(13208, 14) + "ReplicatedCompositesEXT\0" // IR(13222, 24) + "BitInstructions\0" // IR(13246, 16) + "GroupNonUniformRotateKHR\0" // IR(13262, 25) + "FloatControls2\0" // IR(13287, 15) + "FMAKHR\0" // IR(13302, 7) + "AtomicFloat32AddEXT\0" // IR(13309, 20) + "AtomicFloat64AddEXT\0" // IR(13329, 20) + "LongCompositesINTEL\0" // IR(13349, 20) + "OptNoneEXT\0" // IR(13369, 11) + "OptNoneINTEL\0" // IR(13380, 13) + "AtomicFloat16AddEXT\0" // IR(13393, 20) + "DebugInfoModuleINTEL\0" // IR(13413, 21) + "BFloat16ConversionINTEL\0" // IR(13434, 24) + "SplitBarrierINTEL\0" // IR(13458, 18) + "ArithmeticFenceEXT\0" // IR(13476, 19) + "FPGAClusterAttributesV2INTEL\0" // IR(13495, 29) + "FPGAKernelAttributesv2INTEL\0" // IR(13524, 28) + "TaskSequenceINTEL\0" // IR(13552, 18) + "FPMaxErrorINTEL\0" // IR(13570, 16) + "FPGALatencyControlINTEL\0" // IR(13586, 24) + "FPGAArgumentInterfacesINTEL\0" // IR(13610, 28) + "GlobalVariableHostAccessINTEL\0" // IR(13638, 30) + "GlobalVariableFPGADecorationsINTEL\0" // IR(13668, 35) + "SubgroupBufferPrefetchINTEL\0" // IR(13703, 28) + "Subgroup2DBlockIOINTEL\0" // IR(13731, 23) + "Subgroup2DBlockTransformINTEL\0" // IR(13754, 30) + "Subgroup2DBlockTransposeINTEL\0" // IR(13784, 30) + "SubgroupMatrixMultiplyAccumulateINTEL\0" // IR(13814, 38) + "TernaryBitwiseFunctionINTEL\0" // IR(13852, 28) + "UntypedVariableLengthArrayINTEL\0" // IR(13880, 32) + "SpecConditionalINTEL\0" // IR(13912, 21) + "FunctionVariantsINTEL\0" // IR(13933, 22) + "GroupUniformArithmeticKHR\0" // IR(13955, 26) + "TensorFloat32RoundingINTEL\0" // IR(13981, 27) + "MaskedGatherScatterINTEL\0" // IR(14008, 25) + "CacheControlsINTEL\0" // IR(14033, 19) + "RegisterLimitsINTEL\0" // IR(14052, 20) + "BindlessImagesINTEL\0" // IR(14072, 20) + "Unspecified\0" // IR(14092, 12) + "Address\0" // IR(14104, 8) + "Boolean\0" // IR(14112, 8) + "Float\0" // IR(14120, 6) + "Signed\0" // IR(14126, 7) + "SignedChar\0" // IR(14133, 11) + "Unsigned\0" // IR(14144, 9) + "UnsignedChar\0" // IR(14153, 13) + "Class\0" // IR(14166, 6) + "Structure\0" // IR(14172, 10) + "Union\0" // IR(14182, 6) + "ImportedModule\0" // IR(14188, 15) + "ImportedDeclaration\0" // IR(14203, 20) + "None\0" // IR(14223, 5) + "FlagIsProtected\0" // IR(14228, 16) + "FlagIsPrivate\0" // IR(14244, 14) + "FlagIsPublic\0" // IR(14258, 13) + "FlagIsLocal\0" // IR(14271, 12) + "FlagIsDefinition\0" // IR(14283, 17) + "FlagFwdDecl\0" // IR(14300, 12) + "FlagArtificial\0" // IR(14312, 15) + "FlagExplicit\0" // IR(14327, 13) + "FlagPrototyped\0" // IR(14340, 15) + "FlagObjectPointer\0" // IR(14355, 18) + "FlagStaticMember\0" // IR(14373, 17) + "FlagIndirectVariable\0" // IR(14390, 21) + "FlagLValueReference\0" // IR(14411, 20) + "FlagRValueReference\0" // IR(14431, 20) + "FlagIsOptimized\0" // IR(14451, 16) + "FlagIsEnumClass\0" // IR(14467, 16) + "FlagTypePassByValue\0" // IR(14483, 20) + "FlagTypePassByReference\0" // IR(14503, 24) + "Deref\0" // IR(14527, 6) + "Plus\0" // IR(14533, 5) + "Minus\0" // IR(14538, 6) + "SPV_OPERAND_TYPE_LITERAL_INTEGER\0" // IR(14544, 33) + "PlusUconst\0" // IR(14577, 11) + "BitPiece\0" // IR(14588, 9) + "Swap\0" // IR(14597, 5) + "Xderef\0" // IR(14602, 7) + "StackValue\0" // IR(14609, 11) + "Constu\0" // IR(14620, 7) + "Fragment\0" // IR(14627, 9) + "ConstType\0" // IR(14636, 10) + "VolatileType\0" // IR(14646, 13) + "RestrictType\0" // IR(14659, 13) + "AtomicType\0" // IR(14672, 11) + "Float16NV\0" // IR(14683, 10) + "Float32NV\0" // IR(14693, 10) + "Float64NV\0" // IR(14703, 10) + "SignedInt8NV\0" // IR(14713, 13) + "SignedInt16NV\0" // IR(14726, 14) + "SignedInt32NV\0" // IR(14740, 14) + "SignedInt64NV\0" // IR(14754, 14) + "UnsignedInt8NV\0" // IR(14768, 15) + "UnsignedInt16NV\0" // IR(14783, 16) + "UnsignedInt32NV\0" // IR(14799, 16) + "UnsignedInt64NV\0" // IR(14815, 16) + "SignedInt8PackedNV\0" // IR(14831, 19) + "UnsignedInt8PackedNV\0" // IR(14850, 21) + "FloatE4M3NV\0" // IR(14871, 12) + "FloatE5M2NV\0" // IR(14883, 12) + "RowMajorKHR\0" // IR(14895, 12) + "ColumnMajorKHR\0" // IR(14907, 15) + "RowBlockedInterleavedARM\0" // IR(14922, 25) + "ColumnBlockedInterleavedARM\0" // IR(14947, 28) + "NoneKHR\0" // IR(14975, 8) + "MatrixASignedComponentsKHR\0" // IR(14983, 27) + "MatrixBSignedComponentsKHR\0" // IR(15010, 27) + "MatrixCSignedComponentsKHR\0" // IR(15037, 27) + "MatrixResultSignedComponentsKHR\0" // IR(15064, 32) + "SaturatingAccumulationKHR\0" // IR(15096, 26) + "Row\0" // IR(15122, 4) + "Column\0" // IR(15126, 7) + "2x2\0" // IR(15133, 4) + "MatrixAKHR\0" // IR(15137, 11) + "MatrixBKHR\0" // IR(15148, 11) + "MatrixAccumulatorKHR\0" // IR(15159, 21) + "RowMajorNV\0" // IR(15180, 11) + "ColumnMajorNV\0" // IR(15191, 14) + "InferencingOptimalNV\0" // IR(15205, 21) + "TrainingOptimalNV\0" // IR(15226, 18) + "RelaxedPrecision\0" // IR(15244, 17) + "SpecId\0" // IR(15261, 7) + "Block\0" // IR(15268, 6) + "BufferBlock\0" // IR(15274, 12) + "RowMajor\0" // IR(15286, 9) + "ColMajor\0" // IR(15295, 9) + "ArrayStride\0" // IR(15304, 12) + "MatrixStride\0" // IR(15316, 13) + "GLSLShared\0" // IR(15329, 11) + "GLSLPacked\0" // IR(15340, 11) + "CPacked\0" // IR(15351, 8) + "SPV_OPERAND_TYPE_BUILT_IN\0" // IR(15359, 26) + "BuiltIn\0" // IR(15385, 8) + "NoPerspective\0" // IR(15393, 14) + "Flat\0" // IR(15407, 5) + "Patch\0" // IR(15412, 6) + "Centroid\0" // IR(15418, 9) + "Sample\0" // IR(15427, 7) + "Invariant\0" // IR(15434, 10) + "Restrict\0" // IR(15444, 9) + "Aliased\0" // IR(15453, 8) + "Volatile\0" // IR(15461, 9) + "Constant\0" // IR(15470, 9) + "Coherent\0" // IR(15479, 9) + "NonWritable\0" // IR(15488, 12) + "NonReadable\0" // IR(15500, 12) + "Uniform\0" // IR(15512, 8) + "SPV_OPERAND_TYPE_SCOPE_ID\0" // IR(15520, 26) + "UniformId\0" // IR(15546, 10) + "SaturatedConversion\0" // IR(15556, 20) + "Stream\0" // IR(15576, 7) + "Location\0" // IR(15583, 9) + "Component\0" // IR(15592, 10) + "Index\0" // IR(15602, 6) + "Binding\0" // IR(15608, 8) + "DescriptorSet\0" // IR(15616, 14) + "Offset\0" // IR(15630, 7) + "XfbBuffer\0" // IR(15637, 10) + "XfbStride\0" // IR(15647, 10) + "SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE\0" // IR(15657, 46) + "FuncParamAttr\0" // IR(15703, 14) + "SPV_OPERAND_TYPE_FP_ROUNDING_MODE\0" // IR(15717, 34) + "FPRoundingMode\0" // IR(15751, 15) + "SPV_OPERAND_TYPE_FP_FAST_MATH_MODE\0" // IR(15766, 35) + "FPFastMathMode\0" // IR(15801, 15) + "SPV_OPERAND_TYPE_LITERAL_STRING\0" // IR(15816, 32) + "SPV_OPERAND_TYPE_LINKAGE_TYPE\0" // IR(15848, 30) + "LinkageAttributes\0" // IR(15878, 18) + "NoContraction\0" // IR(15896, 14) + "InputAttachmentIndex\0" // IR(15910, 21) + "Alignment\0" // IR(15931, 10) + "MaxByteOffset\0" // IR(15941, 14) + "SPV_OPERAND_TYPE_ID\0" // IR(15955, 20) + "AlignmentId\0" // IR(15975, 12) + "MaxByteOffsetId\0" // IR(15987, 16) + "SaturatedToLargestFloat8NormalConversionEXT\0" // IR(16003, 44) + "NoSignedWrap\0" // IR(16047, 13) + "NoUnsignedWrap\0" // IR(16060, 15) + "WeightTextureQCOM\0" // IR(16075, 18) + "BlockMatchTextureQCOM\0" // IR(16093, 22) + "BlockMatchSamplerQCOM\0" // IR(16115, 22) + "ExplicitInterpAMD\0" // IR(16137, 18) + "NodeSharesPayloadLimitsWithAMDX\0" // IR(16155, 32) + "NodeMaxPayloadsAMDX\0" // IR(16187, 20) + "TrackFinishWritingAMDX\0" // IR(16207, 23) + "PayloadNodeNameAMDX\0" // IR(16230, 20) + "PayloadNodeBaseIndexAMDX\0" // IR(16250, 25) + "PayloadNodeSparseArrayAMDX\0" // IR(16275, 27) + "PayloadNodeArraySizeAMDX\0" // IR(16302, 25) + "PayloadDispatchIndirectAMDX\0" // IR(16327, 28) + "OverrideCoverageNV\0" // IR(16355, 19) + "PassthroughNV\0" // IR(16374, 14) + "ViewportRelativeNV\0" // IR(16388, 19) + "SecondaryViewportRelativeNV\0" // IR(16407, 28) + "PerPrimitiveEXT\0" // IR(16435, 16) + "PerPrimitiveNV\0" // IR(16451, 15) + "PerViewNV\0" // IR(16466, 10) + "PerTaskNV\0" // IR(16476, 10) + "PerVertexKHR\0" // IR(16486, 13) + "PerVertexNV\0" // IR(16499, 12) + "NonUniform\0" // IR(16511, 11) + "NonUniformEXT\0" // IR(16522, 14) + "RestrictPointer\0" // IR(16536, 16) + "RestrictPointerEXT\0" // IR(16552, 19) + "AliasedPointer\0" // IR(16571, 15) + "AliasedPointerEXT\0" // IR(16586, 18) + "HitObjectShaderRecordBufferNV\0" // IR(16604, 30) + "BindlessSamplerNV\0" // IR(16634, 18) + "BindlessImageNV\0" // IR(16652, 16) + "BoundSamplerNV\0" // IR(16668, 15) + "BoundImageNV\0" // IR(16683, 13) + "SIMTCallINTEL\0" // IR(16696, 14) + "ReferencedIndirectlyINTEL\0" // IR(16710, 26) + "ClobberINTEL\0" // IR(16736, 13) + "SideEffectsINTEL\0" // IR(16749, 17) + "VectorComputeVariableINTEL\0" // IR(16766, 27) + "FuncParamIOKindINTEL\0" // IR(16793, 21) + "VectorComputeFunctionINTEL\0" // IR(16814, 27) + "StackCallINTEL\0" // IR(16841, 15) + "GlobalVariableOffsetINTEL\0" // IR(16856, 26) + "CounterBuffer\0" // IR(16882, 14) + "HlslCounterBufferGOOGLE\0" // IR(16896, 24) + "UserSemantic\0" // IR(16920, 13) + "HlslSemanticGOOGLE\0" // IR(16933, 19) + "UserTypeGOOGLE\0" // IR(16952, 15) + "FunctionRoundingModeINTEL\0" // IR(16967, 26) + "SPV_OPERAND_TYPE_FPDENORM_MODE\0" // IR(16993, 31) + "FunctionDenormModeINTEL\0" // IR(17024, 24) + "RegisterINTEL\0" // IR(17048, 14) + "MemoryINTEL\0" // IR(17062, 12) + "NumbanksINTEL\0" // IR(17074, 14) + "BankwidthINTEL\0" // IR(17088, 15) + "MaxPrivateCopiesINTEL\0" // IR(17103, 22) + "SinglepumpINTEL\0" // IR(17125, 16) + "DoublepumpINTEL\0" // IR(17141, 16) + "MaxReplicatesINTEL\0" // IR(17157, 19) + "SimpleDualPortINTEL\0" // IR(17176, 20) + "MergeINTEL\0" // IR(17196, 11) + "SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER\0" // IR(17207, 42) + "BankBitsINTEL\0" // IR(17249, 14) + "ForcePow2DepthINTEL\0" // IR(17263, 20) + "StridesizeINTEL\0" // IR(17283, 16) + "WordsizeINTEL\0" // IR(17299, 14) + "TrueDualPortINTEL\0" // IR(17313, 18) + "BurstCoalesceINTEL\0" // IR(17331, 19) + "CacheSizeINTEL\0" // IR(17350, 15) + "DontStaticallyCoalesceINTEL\0" // IR(17365, 28) + "PrefetchINTEL\0" // IR(17393, 14) + "StallEnableINTEL\0" // IR(17407, 17) + "FuseLoopsInFunctionINTEL\0" // IR(17424, 25) + "MathOpDSPModeINTEL\0" // IR(17449, 19) + "AliasScopeINTEL\0" // IR(17468, 16) + "NoAliasINTEL\0" // IR(17484, 13) + "InitiationIntervalINTEL\0" // IR(17497, 24) + "MaxConcurrencyINTEL\0" // IR(17521, 20) + "PipelineEnableINTEL\0" // IR(17541, 20) + "BufferLocationINTEL\0" // IR(17561, 20) + "IOPipeStorageINTEL\0" // IR(17581, 19) + "SPV_OPERAND_TYPE_FPOPERATION_MODE\0" // IR(17600, 34) + "FunctionFloatingPointModeINTEL\0" // IR(17634, 31) + "SingleElementVectorINTEL\0" // IR(17665, 25) + "VectorComputeCallableFunctionINTEL\0" // IR(17690, 35) + "MediaBlockIOINTEL\0" // IR(17725, 18) + "StallFreeINTEL\0" // IR(17743, 15) + "SPV_OPERAND_TYPE_LITERAL_FLOAT\0" // IR(17758, 31) + "FPMaxErrorDecorationINTEL\0" // IR(17789, 26) + "LatencyControlLabelINTEL\0" // IR(17815, 25) + "LatencyControlConstraintINTEL\0" // IR(17840, 30) + "ConduitKernelArgumentINTEL\0" // IR(17870, 27) + "RegisterMapKernelArgumentINTEL\0" // IR(17897, 31) + "MMHostInterfaceAddressWidthINTEL\0" // IR(17928, 33) + "MMHostInterfaceDataWidthINTEL\0" // IR(17961, 30) + "MMHostInterfaceLatencyINTEL\0" // IR(17991, 28) + "SPV_OPERAND_TYPE_ACCESS_QUALIFIER\0" // IR(18019, 34) + "MMHostInterfaceReadWriteModeINTEL\0" // IR(18053, 34) + "MMHostInterfaceMaxBurstINTEL\0" // IR(18087, 29) + "MMHostInterfaceWaitRequestINTEL\0" // IR(18116, 32) + "StableKernelArgumentINTEL\0" // IR(18148, 26) + "SPV_OPERAND_TYPE_HOST_ACCESS_QUALIFIER\0" // IR(18174, 39) + "HostAccessINTEL\0" // IR(18213, 16) + "SPV_OPERAND_TYPE_INITIALIZATION_MODE_QUALIFIER\0" // IR(18229, 47) + "InitModeINTEL\0" // IR(18276, 14) + "ImplementInRegisterMapINTEL\0" // IR(18290, 28) + "ConditionalINTEL\0" // IR(18318, 17) + "SPV_OPERAND_TYPE_LOAD_CACHE_CONTROL\0" // IR(18335, 36) + "CacheControlLoadINTEL\0" // IR(18371, 22) + "SPV_OPERAND_TYPE_STORE_CACHE_CONTROL\0" // IR(18393, 37) + "CacheControlStoreINTEL\0" // IR(18430, 23) + "1D\0" // IR(18453, 3) + "2D\0" // IR(18456, 3) + "3D\0" // IR(18459, 3) + "Cube\0" // IR(18462, 5) + "Rect\0" // IR(18467, 5) + "Buffer\0" // IR(18472, 7) + "SubpassData\0" // IR(18479, 12) + "TileImageDataEXT\0" // IR(18491, 17) + "Invocations\0" // IR(18508, 12) + "SpacingEqual\0" // IR(18520, 13) + "SpacingFractionalEven\0" // IR(18533, 22) + "SpacingFractionalOdd\0" // IR(18555, 21) + "VertexOrderCw\0" // IR(18576, 14) + "VertexOrderCcw\0" // IR(18590, 15) + "PixelCenterInteger\0" // IR(18605, 19) + "OriginUpperLeft\0" // IR(18624, 16) + "OriginLowerLeft\0" // IR(18640, 16) + "EarlyFragmentTests\0" // IR(18656, 19) + "PointMode\0" // IR(18675, 10) + "Xfb\0" // IR(18685, 4) + "DepthReplacing\0" // IR(18689, 15) + "DepthGreater\0" // IR(18704, 13) + "DepthLess\0" // IR(18717, 10) + "DepthUnchanged\0" // IR(18727, 15) + "LocalSize\0" // IR(18742, 10) + "LocalSizeHint\0" // IR(18752, 14) + "InputPoints\0" // IR(18766, 12) + "InputLines\0" // IR(18778, 11) + "InputLinesAdjacency\0" // IR(18789, 20) + "Triangles\0" // IR(18809, 10) + "InputTrianglesAdjacency\0" // IR(18819, 24) + "Quads\0" // IR(18843, 6) + "Isolines\0" // IR(18849, 9) + "OutputVertices\0" // IR(18858, 15) + "OutputPoints\0" // IR(18873, 13) + "OutputLineStrip\0" // IR(18886, 16) + "OutputTriangleStrip\0" // IR(18902, 20) + "VecTypeHint\0" // IR(18922, 12) + "ContractionOff\0" // IR(18934, 15) + "Initializer\0" // IR(18949, 12) + "Finalizer\0" // IR(18961, 10) + "SubgroupsPerWorkgroup\0" // IR(18971, 22) + "SubgroupsPerWorkgroupId\0" // IR(18993, 24) + "LocalSizeId\0" // IR(19017, 12) + "LocalSizeHintId\0" // IR(19029, 16) + "NonCoherentColorAttachmentReadEXT\0" // IR(19045, 34) + "NonCoherentDepthAttachmentReadEXT\0" // IR(19079, 34) + "NonCoherentStencilAttachmentReadEXT\0" // IR(19113, 36) + "SubgroupUniformControlFlowKHR\0" // IR(19149, 30) + "PostDepthCoverage\0" // IR(19179, 18) + "NonCoherentTileAttachmentReadQCOM\0" // IR(19197, 34) + "TileShadingRateQCOM\0" // IR(19231, 20) + "EarlyAndLateFragmentTestsAMD\0" // IR(19251, 29) + "StencilRefReplacingEXT\0" // IR(19280, 23) + "CoalescingAMDX\0" // IR(19303, 15) + "IsApiEntryAMDX\0" // IR(19318, 15) + "MaxNodeRecursionAMDX\0" // IR(19333, 21) + "StaticNumWorkgroupsAMDX\0" // IR(19354, 24) + "MaxNumWorkgroupsAMDX\0" // IR(19378, 21) + "StencilRefUnchangedFrontAMD\0" // IR(19399, 28) + "StencilRefGreaterFrontAMD\0" // IR(19427, 26) + "StencilRefLessFrontAMD\0" // IR(19453, 23) + "StencilRefUnchangedBackAMD\0" // IR(19476, 27) + "StencilRefGreaterBackAMD\0" // IR(19503, 25) + "StencilRefLessBackAMD\0" // IR(19528, 22) + "QuadDerivativesKHR\0" // IR(19550, 19) + "RequireFullQuadsKHR\0" // IR(19569, 20) + "SharesInputWithAMDX\0" // IR(19589, 20) + "OutputLinesEXT\0" // IR(19609, 15) + "OutputLinesNV\0" // IR(19624, 14) + "OutputPrimitivesEXT\0" // IR(19638, 20) + "OutputPrimitivesNV\0" // IR(19658, 19) + "DerivativeGroupQuadsKHR\0" // IR(19677, 24) + "DerivativeGroupQuadsNV\0" // IR(19701, 23) + "DerivativeGroupLinearKHR\0" // IR(19724, 25) + "DerivativeGroupLinearNV\0" // IR(19749, 24) + "OutputTrianglesEXT\0" // IR(19773, 19) + "OutputTrianglesNV\0" // IR(19792, 18) + "PixelInterlockOrderedEXT\0" // IR(19810, 25) + "PixelInterlockUnorderedEXT\0" // IR(19835, 27) + "SampleInterlockOrderedEXT\0" // IR(19862, 26) + "SampleInterlockUnorderedEXT\0" // IR(19888, 28) + "ShadingRateInterlockOrderedEXT\0" // IR(19916, 31) + "ShadingRateInterlockUnorderedEXT\0" // IR(19947, 33) + "SharedLocalMemorySizeINTEL\0" // IR(19980, 27) + "RoundingModeRTPINTEL\0" // IR(20007, 21) + "RoundingModeRTNINTEL\0" // IR(20028, 21) + "FloatingPointModeALTINTEL\0" // IR(20049, 26) + "FloatingPointModeIEEEINTEL\0" // IR(20075, 27) + "MaxWorkgroupSizeINTEL\0" // IR(20102, 22) + "MaxWorkDimINTEL\0" // IR(20124, 16) + "NoGlobalOffsetINTEL\0" // IR(20140, 20) + "NumSIMDWorkitemsINTEL\0" // IR(20160, 22) + "SchedulerTargetFmaxMhzINTEL\0" // IR(20182, 28) + "MaximallyReconvergesKHR\0" // IR(20210, 24) + "FPFastMathDefault\0" // IR(20234, 18) + "StreamingInterfaceINTEL\0" // IR(20252, 24) + "RegisterMapInterfaceINTEL\0" // IR(20276, 26) + "NamedBarrierCountINTEL\0" // IR(20302, 23) + "MaximumRegistersINTEL\0" // IR(20325, 22) + "MaximumRegistersIdINTEL\0" // IR(20347, 24) + "SPV_OPERAND_TYPE_NAMED_MAXIMUM_NUMBER_OF_REGISTERS\0" // IR(20371, 51) + "NamedMaximumRegistersINTEL\0" // IR(20422, 27) + "Vertex\0" // IR(20449, 7) + "TessellationControl\0" // IR(20456, 20) + "TessellationEvaluation\0" // IR(20476, 23) + "GLCompute\0" // IR(20499, 10) + "TaskNV\0" // IR(20509, 7) + "MeshNV\0" // IR(20516, 7) + "RayGenerationKHR\0" // IR(20523, 17) + "RayGenerationNV\0" // IR(20540, 16) + "IntersectionKHR\0" // IR(20556, 16) + "IntersectionNV\0" // IR(20572, 15) + "AnyHitKHR\0" // IR(20587, 10) + "AnyHitNV\0" // IR(20597, 9) + "ClosestHitKHR\0" // IR(20606, 14) + "ClosestHitNV\0" // IR(20620, 13) + "MissKHR\0" // IR(20633, 8) + "MissNV\0" // IR(20641, 7) + "CallableKHR\0" // IR(20648, 12) + "CallableNV\0" // IR(20660, 11) + "TaskEXT\0" // IR(20671, 8) + "MeshEXT\0" // IR(20679, 8) + "Preserve\0" // IR(20687, 9) + "FlushToZero\0" // IR(20696, 12) + "BFloat16KHR\0" // IR(20708, 12) + "Float8E4M3EXT\0" // IR(20720, 14) + "Float8E5M2EXT\0" // IR(20734, 14) + "IEEE\0" // IR(20748, 5) + "ALT\0" // IR(20753, 4) + "NotNaN\0" // IR(20757, 7) + "NotInf\0" // IR(20764, 7) + "NSZ\0" // IR(20771, 4) + "AllowRecip\0" // IR(20775, 11) + "Fast\0" // IR(20786, 5) + "AllowContract\0" // IR(20791, 14) + "AllowContractFastINTEL\0" // IR(20805, 23) + "AllowReassoc\0" // IR(20828, 13) + "AllowReassocINTEL\0" // IR(20841, 18) + "AllowTransform\0" // IR(20859, 15) + "RTE\0" // IR(20874, 4) + "RTZ\0" // IR(20878, 4) + "RTP\0" // IR(20882, 4) + "RTN\0" // IR(20886, 4) + "Vertical2Pixels\0" // IR(20890, 16) + "Vertical4Pixels\0" // IR(20906, 16) + "Horizontal2Pixels\0" // IR(20922, 18) + "Horizontal4Pixels\0" // IR(20940, 18) + "Inline\0" // IR(20958, 7) + "DontInline\0" // IR(20965, 11) + "Pure\0" // IR(20976, 5) + "Const\0" // IR(20981, 6) + "Zext\0" // IR(20987, 5) + "Sext\0" // IR(20992, 5) + "ByVal\0" // IR(20997, 6) + "Sret\0" // IR(21003, 5) + "NoAlias\0" // IR(21008, 8) + "NoCapture\0" // IR(21016, 10) + "NoWrite\0" // IR(21026, 8) + "NoReadWrite\0" // IR(21034, 12) + "RuntimeAlignedINTEL\0" // IR(21046, 20) + "Reduce\0" // IR(21066, 7) + "InclusiveScan\0" // IR(21073, 14) + "ExclusiveScan\0" // IR(21087, 14) + "ClusteredReduce\0" // IR(21101, 16) + "PartitionedReduceNV\0" // IR(21117, 20) + "PartitionedInclusiveScanNV\0" // IR(21137, 27) + "PartitionedExclusiveScanNV\0" // IR(21164, 27) + "NoneINTEL\0" // IR(21191, 10) + "ReadINTEL\0" // IR(21201, 10) + "WriteINTEL\0" // IR(21211, 11) + "ReadWriteINTEL\0" // IR(21222, 15) + "Bias\0" // IR(21237, 5) + "Lod\0" // IR(21242, 4) + "Grad\0" // IR(21246, 5) + "ConstOffset\0" // IR(21251, 12) + "ConstOffsets\0" // IR(21263, 13) + "MakeTexelAvailable\0" // IR(21276, 19) + "MakeTexelAvailableKHR\0" // IR(21295, 22) + "MakeTexelVisible\0" // IR(21317, 17) + "MakeTexelVisibleKHR\0" // IR(21334, 20) + "NonPrivateTexel\0" // IR(21354, 16) + "NonPrivateTexelKHR\0" // IR(21370, 19) + "VolatileTexel\0" // IR(21389, 14) + "VolatileTexelKHR\0" // IR(21403, 17) + "SignExtend\0" // IR(21420, 11) + "ZeroExtend\0" // IR(21431, 11) + "Nontemporal\0" // IR(21442, 12) + "Offsets\0" // IR(21454, 8) + "SnormInt8\0" // IR(21462, 10) + "SnormInt16\0" // IR(21472, 11) + "UnormInt8\0" // IR(21483, 10) + "UnormInt16\0" // IR(21493, 11) + "UnormShort565\0" // IR(21504, 14) + "UnormShort555\0" // IR(21518, 14) + "UnormInt101010\0" // IR(21532, 15) + "SignedInt8\0" // IR(21547, 11) + "SignedInt16\0" // IR(21558, 12) + "SignedInt32\0" // IR(21570, 12) + "UnsignedInt8\0" // IR(21582, 13) + "UnsignedInt16\0" // IR(21595, 14) + "UnsignedInt32\0" // IR(21609, 14) + "HalfFloat\0" // IR(21623, 10) + "UnormInt24\0" // IR(21633, 11) + "UnormInt101010_2\0" // IR(21644, 17) + "UnormInt10X6EXT\0" // IR(21661, 16) + "UnsignedIntRaw10EXT\0" // IR(21677, 20) + "UnsignedIntRaw12EXT\0" // IR(21697, 20) + "UnormInt2_101010EXT\0" // IR(21717, 20) + "UnsignedInt10X6EXT\0" // IR(21737, 19) + "UnsignedInt12X4EXT\0" // IR(21756, 19) + "UnsignedInt14X2EXT\0" // IR(21775, 19) + "UnormInt12X4EXT\0" // IR(21794, 16) + "UnormInt14X2EXT\0" // IR(21810, 16) + "R\0" // IR(21826, 2) + "A\0" // IR(21828, 2) + "RG\0" // IR(21830, 3) + "RA\0" // IR(21833, 3) + "RGB\0" // IR(21836, 4) + "RGBA\0" // IR(21840, 5) + "BGRA\0" // IR(21845, 5) + "ARGB\0" // IR(21850, 5) + "Intensity\0" // IR(21855, 10) + "Luminance\0" // IR(21865, 10) + "Rx\0" // IR(21875, 3) + "RGx\0" // IR(21878, 4) + "RGBx\0" // IR(21882, 5) + "Depth\0" // IR(21887, 6) + "DepthStencil\0" // IR(21893, 13) + "sRGB\0" // IR(21906, 5) + "sRGBx\0" // IR(21911, 6) + "sRGBA\0" // IR(21917, 6) + "sBGRA\0" // IR(21923, 6) + "ABGR\0" // IR(21929, 5) + "InitOnDeviceReprogramINTEL\0" // IR(21934, 27) + "InitOnDeviceResetINTEL\0" // IR(21961, 23) + "NoWait\0" // IR(21984, 7) + "WaitKernel\0" // IR(21991, 11) + "WaitWorkGroup\0" // IR(22002, 14) + "CmdExecTime\0" // IR(22016, 12) + "MayUsePrintf\0" // IR(22028, 13) + "Export\0" // IR(22041, 7) + "Import\0" // IR(22048, 7) + "LinkOnceODR\0" // IR(22055, 12) + "UncachedINTEL\0" // IR(22067, 14) + "CachedINTEL\0" // IR(22081, 12) + "StreamingINTEL\0" // IR(22093, 15) + "InvalidateAfterReadINTEL\0" // IR(22108, 25) + "ConstCachedINTEL\0" // IR(22133, 17) + "Unroll\0" // IR(22150, 7) + "DontUnroll\0" // IR(22157, 11) + "DependencyInfinite\0" // IR(22168, 19) + "DependencyLength\0" // IR(22187, 17) + "MinIterations\0" // IR(22204, 14) + "MaxIterations\0" // IR(22218, 14) + "IterationMultiple\0" // IR(22232, 18) + "PeelCount\0" // IR(22250, 10) + "PartialCount\0" // IR(22260, 13) + "DependencyArrayINTEL\0" // IR(22273, 21) + "LoopCoalesceINTEL\0" // IR(22294, 18) + "MaxInterleavingINTEL\0" // IR(22312, 21) + "SpeculatedIterationsINTEL\0" // IR(22333, 26) + "NoFusionINTEL\0" // IR(22359, 14) + "LoopCountINTEL\0" // IR(22373, 15) + "MaxReinvocationDelayINTEL\0" // IR(22388, 26) + "MatrixASignedComponentsINTEL\0" // IR(22414, 29) + "MatrixBSignedComponentsINTEL\0" // IR(22443, 29) + "MatrixCBFloat16INTEL\0" // IR(22472, 21) + "MatrixResultBFloat16INTEL\0" // IR(22493, 26) + "MatrixAPackedInt8INTEL\0" // IR(22519, 23) + "MatrixBPackedInt8INTEL\0" // IR(22542, 23) + "MatrixAPackedInt4INTEL\0" // IR(22565, 23) + "MatrixBPackedInt4INTEL\0" // IR(22588, 23) + "MatrixATF32INTEL\0" // IR(22611, 17) + "MatrixBTF32INTEL\0" // IR(22628, 17) + "MatrixAPackedFloat16INTEL\0" // IR(22645, 26) + "MatrixBPackedFloat16INTEL\0" // IR(22671, 26) + "MatrixAPackedBFloat16INTEL\0" // IR(22697, 27) + "MatrixBPackedBFloat16INTEL\0" // IR(22724, 27) + "Aligned\0" // IR(22751, 8) + "MakePointerAvailable\0" // IR(22759, 21) + "MakePointerAvailableKHR\0" // IR(22780, 24) + "MakePointerVisible\0" // IR(22804, 19) + "MakePointerVisibleKHR\0" // IR(22823, 22) + "NonPrivatePointer\0" // IR(22845, 18) + "NonPrivatePointerKHR\0" // IR(22863, 21) + "AliasScopeINTELMask\0" // IR(22884, 20) + "NoAliasINTELMask\0" // IR(22904, 17) + "Simple\0" // IR(22921, 7) + "GLSL450\0" // IR(22928, 8) + "OpenCL\0" // IR(22936, 7) + "Vulkan\0" // IR(22943, 7) + "VulkanKHR\0" // IR(22950, 10) + "Relaxed\0" // IR(22960, 8) + "Acquire\0" // IR(22968, 8) + "Release\0" // IR(22976, 8) + "AcquireRelease\0" // IR(22984, 15) + "SequentiallyConsistent\0" // IR(22999, 23) + "UniformMemory\0" // IR(23022, 14) + "SubgroupMemory\0" // IR(23036, 15) + "WorkgroupMemory\0" // IR(23051, 16) + "CrossWorkgroupMemory\0" // IR(23067, 21) + "AtomicCounterMemory\0" // IR(23088, 20) + "ImageMemory\0" // IR(23108, 12) + "OutputMemory\0" // IR(23120, 13) + "OutputMemoryKHR\0" // IR(23133, 16) + "MakeAvailable\0" // IR(23149, 14) + "MakeAvailableKHR\0" // IR(23163, 17) + "MakeVisible\0" // IR(23180, 12) + "MakeVisibleKHR\0" // IR(23192, 15) + "AutoINTEL\0" // IR(23207, 10) + "WRAP\0" // IR(23217, 5) + "SAT\0" // IR(23222, 4) + "SAT_ZERO\0" // IR(23226, 9) + "SAT_SYM\0" // IR(23235, 8) + "PackedVectorFormat4x8Bit\0" // IR(23243, 25) + "PackedVectorFormat4x8BitKHR\0" // IR(23268, 28) + "TRN\0" // IR(23296, 4) + "TRN_ZERO\0" // IR(23300, 9) + "RND\0" // IR(23309, 4) + "RND_ZERO\0" // IR(23313, 9) + "RND_INF\0" // IR(23322, 8) + "RND_MIN_INF\0" // IR(23330, 12) + "RND_CONV\0" // IR(23342, 9) + "RND_CONV_ODD\0" // IR(23351, 13) + "RobustnessPerComponentNV\0" // IR(23364, 25) + "RobustnessPerElementNV\0" // IR(23389, 23) + "OpaqueKHR\0" // IR(23412, 10) + "NoOpaqueKHR\0" // IR(23422, 12) + "TerminateOnFirstHitKHR\0" // IR(23434, 23) + "SkipClosestHitShaderKHR\0" // IR(23457, 24) + "CullBackFacingTrianglesKHR\0" // IR(23481, 27) + "CullFrontFacingTrianglesKHR\0" // IR(23508, 28) + "CullOpaqueKHR\0" // IR(23536, 14) + "CullNoOpaqueKHR\0" // IR(23550, 16) + "SkipTrianglesKHR\0" // IR(23566, 17) + "SkipBuiltinPrimitivesNV\0" // IR(23583, 24) + "SkipAABBsKHR\0" // IR(23607, 13) + "ForceOpacityMicromap2StateEXT\0" // IR(23620, 30) + "RayQueryCandidateIntersectionTriangleKHR\0" // IR(23650, 41) + "RayQueryCandidateIntersectionAABBKHR\0" // IR(23691, 37) + "RayQueryCommittedIntersectionNoneKHR\0" // IR(23728, 37) + "RayQueryCommittedIntersectionTriangleKHR\0" // IR(23765, 41) + "RayQueryCommittedIntersectionGeneratedKHR\0" // IR(23806, 42) + "RayQueryCandidateIntersectionKHR\0" // IR(23848, 33) + "RayQueryCommittedIntersectionKHR\0" // IR(23881, 33) + "ClampToEdge\0" // IR(23914, 12) + "Clamp\0" // IR(23926, 6) + "Repeat\0" // IR(23932, 7) + "RepeatMirrored\0" // IR(23939, 15) + "Nearest\0" // IR(23954, 8) + "Linear\0" // IR(23962, 7) + "Unknown\0" // IR(23969, 8) + "Rgba32f\0" // IR(23977, 8) + "Rgba16f\0" // IR(23985, 8) + "R32f\0" // IR(23993, 5) + "Rgba8\0" // IR(23998, 6) + "Rgba8Snorm\0" // IR(24004, 11) + "Rg32f\0" // IR(24015, 6) + "Rg16f\0" // IR(24021, 6) + "R11fG11fB10f\0" // IR(24027, 13) + "R16f\0" // IR(24040, 5) + "Rgba16\0" // IR(24045, 7) + "Rgb10A2\0" // IR(24052, 8) + "Rg16\0" // IR(24060, 5) + "Rg8\0" // IR(24065, 4) + "R16\0" // IR(24069, 4) + "R8\0" // IR(24073, 3) + "Rgba16Snorm\0" // IR(24076, 12) + "Rg16Snorm\0" // IR(24088, 10) + "Rg8Snorm\0" // IR(24098, 9) + "R16Snorm\0" // IR(24107, 9) + "R8Snorm\0" // IR(24116, 8) + "Rgba32i\0" // IR(24124, 8) + "Rgba16i\0" // IR(24132, 8) + "Rgba8i\0" // IR(24140, 7) + "R32i\0" // IR(24147, 5) + "Rg32i\0" // IR(24152, 6) + "Rg16i\0" // IR(24158, 6) + "Rg8i\0" // IR(24164, 5) + "R16i\0" // IR(24169, 5) + "R8i\0" // IR(24174, 4) + "Rgba32ui\0" // IR(24178, 9) + "Rgba16ui\0" // IR(24187, 9) + "Rgba8ui\0" // IR(24196, 8) + "R32ui\0" // IR(24204, 6) + "Rgb10a2ui\0" // IR(24210, 10) + "Rg32ui\0" // IR(24220, 7) + "Rg16ui\0" // IR(24227, 7) + "Rg8ui\0" // IR(24234, 6) + "R16ui\0" // IR(24240, 6) + "R8ui\0" // IR(24246, 5) + "R64ui\0" // IR(24251, 6) + "R64i\0" // IR(24257, 5) + "CrossDevice\0" // IR(24262, 12) + "Device\0" // IR(24274, 7) + "Workgroup\0" // IR(24281, 10) + "Subgroup\0" // IR(24291, 9) + "Invocation\0" // IR(24300, 11) + "QueueFamily\0" // IR(24311, 12) + "QueueFamilyKHR\0" // IR(24323, 15) + "ShaderCallKHR\0" // IR(24338, 14) + "Flatten\0" // IR(24352, 8) + "DontFlatten\0" // IR(24360, 12) + "IdentifierPossibleDuplicates\0" // IR(24372, 29) + "FlagUnknownPhysicalLayout\0" // IR(24401, 26) + "ESSL\0" // IR(24427, 5) + "GLSL\0" // IR(24432, 5) + "OpenCL_C\0" // IR(24437, 9) + "OpenCL_CPP\0" // IR(24446, 11) + "HLSL\0" // IR(24457, 5) + "CPP_for_OpenCL\0" // IR(24462, 15) + "SYCL\0" // IR(24477, 5) + "HERO_C\0" // IR(24482, 7) + "NZSL\0" // IR(24489, 5) + "WGSL\0" // IR(24494, 5) + "Slang\0" // IR(24499, 6) + "Zig\0" // IR(24505, 4) + "Rust\0" // IR(24509, 5) + "UniformConstant\0" // IR(24514, 16) + "Input\0" // IR(24530, 6) + "Output\0" // IR(24536, 7) + "CrossWorkgroup\0" // IR(24543, 15) + "Private\0" // IR(24558, 8) + "Function\0" // IR(24566, 9) + "Generic\0" // IR(24575, 8) + "PushConstant\0" // IR(24583, 13) + "AtomicCounter\0" // IR(24596, 14) + "Image\0" // IR(24610, 6) + "StorageBuffer\0" // IR(24616, 14) + "TileImageEXT\0" // IR(24630, 13) + "TileAttachmentQCOM\0" // IR(24643, 19) + "NodePayloadAMDX\0" // IR(24662, 16) + "CallableDataKHR\0" // IR(24678, 16) + "CallableDataNV\0" // IR(24694, 15) + "IncomingCallableDataKHR\0" // IR(24709, 24) + "IncomingCallableDataNV\0" // IR(24733, 23) + "RayPayloadKHR\0" // IR(24756, 14) + "RayPayloadNV\0" // IR(24770, 13) + "HitAttributeKHR\0" // IR(24783, 16) + "HitAttributeNV\0" // IR(24799, 15) + "IncomingRayPayloadKHR\0" // IR(24814, 22) + "IncomingRayPayloadNV\0" // IR(24836, 21) + "ShaderRecordBufferKHR\0" // IR(24857, 22) + "ShaderRecordBufferNV\0" // IR(24879, 21) + "PhysicalStorageBuffer\0" // IR(24900, 22) + "PhysicalStorageBufferEXT\0" // IR(24922, 25) + "HitObjectAttributeNV\0" // IR(24947, 21) + "TaskPayloadWorkgroupEXT\0" // IR(24968, 24) + "CodeSectionINTEL\0" // IR(24992, 17) + "DeviceOnlyINTEL\0" // IR(25009, 16) + "HostOnlyINTEL\0" // IR(25025, 14) + "WriteThroughINTEL\0" // IR(25039, 18) + "WriteBackINTEL\0" // IR(25057, 15) + "TensorView\0" // IR(25072, 11) + "DecodeFunc\0" // IR(25083, 11) + "Undefined\0" // IR(25094, 10) + "NoneARM\0" // IR(25104, 8) + "NontemporalARM\0" // IR(25112, 15) + "OutOfBoundsValueARM\0" // IR(25127, 20) + "MakeElementAvailableARM\0" // IR(25147, 24) + "MakeElementVisibleARM\0" // IR(25171, 22) + "NonPrivateElementARM\0" // IR(25193, 21) + "Nop\0" // IR(25214, 4) + "SPV_OPERAND_TYPE_TYPE_ID\0" // IR(25218, 25) + "SPV_OPERAND_TYPE_RESULT_ID\0" // IR(25243, 27) + "Undef\0" // IR(25270, 6) + "SourceContinued\0" // IR(25276, 16) + "SPV_OPERAND_TYPE_SOURCE_LANGUAGE\0" // IR(25292, 33) + "SPV_OPERAND_TYPE_OPTIONAL_ID\0" // IR(25325, 29) + "SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING\0" // IR(25354, 41) + "Source\0" // IR(25395, 7) + "SourceExtension\0" // IR(25402, 16) + "Name\0" // IR(25418, 5) + "MemberName\0" // IR(25423, 11) + "String\0" // IR(25434, 7) + "Line\0" // IR(25441, 5) + "Extension\0" // IR(25446, 10) + "ExtInstImport\0" // IR(25456, 14) + "SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER\0" // IR(25470, 46) + "ExtInst\0" // IR(25516, 8) + "SPV_OPERAND_TYPE_ADDRESSING_MODEL\0" // IR(25524, 34) + "SPV_OPERAND_TYPE_MEMORY_MODEL\0" // IR(25558, 30) + "MemoryModel\0" // IR(25588, 12) + "SPV_OPERAND_TYPE_EXECUTION_MODEL\0" // IR(25600, 33) + "SPV_OPERAND_TYPE_VARIABLE_ID\0" // IR(25633, 29) + "EntryPoint\0" // IR(25662, 11) + "SPV_OPERAND_TYPE_EXECUTION_MODE\0" // IR(25673, 32) + "ExecutionMode\0" // IR(25705, 14) + "SPV_OPERAND_TYPE_CAPABILITY\0" // IR(25719, 28) + "Capability\0" // IR(25747, 11) + "TypeVoid\0" // IR(25758, 9) + "TypeBool\0" // IR(25767, 9) + "TypeInt\0" // IR(25776, 8) + "SPV_OPERAND_TYPE_OPTIONAL_FPENCODING\0" // IR(25784, 37) + "TypeFloat\0" // IR(25821, 10) + "TypeVector\0" // IR(25831, 11) + "TypeMatrix\0" // IR(25842, 11) + "SPV_OPERAND_TYPE_DIMENSIONALITY\0" // IR(25853, 32) + "SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT\0" // IR(25885, 38) + "SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER\0" // IR(25923, 43) + "TypeImage\0" // IR(25966, 10) + "TypeSampler\0" // IR(25976, 12) + "TypeSampledImage\0" // IR(25988, 17) + "TypeArray\0" // IR(26005, 10) + "TypeRuntimeArray\0" // IR(26015, 17) + "TypeStruct\0" // IR(26032, 11) + "TypeOpaque\0" // IR(26043, 11) + "SPV_OPERAND_TYPE_STORAGE_CLASS\0" // IR(26054, 31) + "TypePointer\0" // IR(26085, 12) + "TypeFunction\0" // IR(26097, 13) + "TypeEvent\0" // IR(26110, 10) + "TypeDeviceEvent\0" // IR(26120, 16) + "TypeReserveId\0" // IR(26136, 14) + "TypeQueue\0" // IR(26150, 10) + "TypePipe\0" // IR(26160, 9) + "TypeForwardPointer\0" // IR(26169, 19) + "ConstantTrue\0" // IR(26188, 13) + "ConstantFalse\0" // IR(26201, 14) + "SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER\0" // IR(26215, 38) + "ConstantComposite\0" // IR(26253, 18) + "SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE\0" // IR(26271, 41) + "SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE\0" // IR(26312, 37) + "ConstantSampler\0" // IR(26349, 16) + "ConstantNull\0" // IR(26365, 13) + "SpecConstantTrue\0" // IR(26378, 17) + "SpecConstantFalse\0" // IR(26395, 18) + "SpecConstant\0" // IR(26413, 13) + "SpecConstantComposite\0" // IR(26426, 22) + "SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER\0" // IR(26448, 41) + "SpecConstantOp\0" // IR(26489, 15) + "SPV_OPERAND_TYPE_FUNCTION_CONTROL\0" // IR(26504, 34) + "FunctionParameter\0" // IR(26538, 18) + "FunctionEnd\0" // IR(26556, 12) + "FunctionCall\0" // IR(26568, 13) + "Variable\0" // IR(26581, 9) + "ImageTexelPointer\0" // IR(26590, 18) + "SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS\0" // IR(26608, 40) + "Load\0" // IR(26648, 5) + "Store\0" // IR(26653, 6) + "CopyMemory\0" // IR(26659, 11) + "CopyMemorySized\0" // IR(26670, 16) + "AccessChain\0" // IR(26686, 12) + "InBoundsAccessChain\0" // IR(26698, 20) + "PtrAccessChain\0" // IR(26718, 15) + "ArrayLength\0" // IR(26733, 12) + "GenericPtrMemSemantics\0" // IR(26745, 23) + "InBoundsPtrAccessChain\0" // IR(26768, 23) + "SPV_OPERAND_TYPE_DECORATION\0" // IR(26791, 28) + "Decorate\0" // IR(26819, 9) + "MemberDecorate\0" // IR(26828, 15) + "DecorationGroup\0" // IR(26843, 16) + "GroupDecorate\0" // IR(26859, 14) + "SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER\0" // IR(26873, 45) + "GroupMemberDecorate\0" // IR(26918, 20) + "VectorExtractDynamic\0" // IR(26938, 21) + "VectorInsertDynamic\0" // IR(26959, 20) + "VectorShuffle\0" // IR(26979, 14) + "CompositeConstruct\0" // IR(26993, 19) + "CompositeExtract\0" // IR(27012, 17) + "CompositeInsert\0" // IR(27029, 16) + "CopyObject\0" // IR(27045, 11) + "Transpose\0" // IR(27056, 10) + "SampledImage\0" // IR(27066, 13) + "SPV_OPERAND_TYPE_OPTIONAL_IMAGE\0" // IR(27079, 32) + "ImageSampleImplicitLod\0" // IR(27111, 23) + "SPV_OPERAND_TYPE_IMAGE\0" // IR(27134, 23) + "ImageSampleExplicitLod\0" // IR(27157, 23) + "ImageSampleDrefImplicitLod\0" // IR(27180, 27) + "ImageSampleDrefExplicitLod\0" // IR(27207, 27) + "ImageSampleProjImplicitLod\0" // IR(27234, 27) + "ImageSampleProjExplicitLod\0" // IR(27261, 27) + "ImageSampleProjDrefImplicitLod\0" // IR(27288, 31) + "ImageSampleProjDrefExplicitLod\0" // IR(27319, 31) + "ImageFetch\0" // IR(27350, 11) + "ImageGather\0" // IR(27361, 12) + "ImageDrefGather\0" // IR(27373, 16) + "ImageRead\0" // IR(27389, 10) + "ImageWrite\0" // IR(27399, 11) + "ImageQueryFormat\0" // IR(27410, 17) + "ImageQueryOrder\0" // IR(27427, 16) + "ImageQuerySizeLod\0" // IR(27443, 18) + "ImageQuerySize\0" // IR(27461, 15) + "ImageQueryLod\0" // IR(27476, 14) + "ImageQueryLevels\0" // IR(27490, 17) + "ImageQuerySamples\0" // IR(27507, 18) + "ConvertFToU\0" // IR(27525, 12) + "ConvertFToS\0" // IR(27537, 12) + "ConvertSToF\0" // IR(27549, 12) + "ConvertUToF\0" // IR(27561, 12) + "UConvert\0" // IR(27573, 9) + "SConvert\0" // IR(27582, 9) + "FConvert\0" // IR(27591, 9) + "QuantizeToF16\0" // IR(27600, 14) + "ConvertPtrToU\0" // IR(27614, 14) + "SatConvertSToU\0" // IR(27628, 15) + "SatConvertUToS\0" // IR(27643, 15) + "ConvertUToPtr\0" // IR(27658, 14) + "PtrCastToGeneric\0" // IR(27672, 17) + "GenericCastToPtr\0" // IR(27689, 17) + "GenericCastToPtrExplicit\0" // IR(27706, 25) + "Bitcast\0" // IR(27731, 8) + "SNegate\0" // IR(27739, 8) + "FNegate\0" // IR(27747, 8) + "IAdd\0" // IR(27755, 5) + "FAdd\0" // IR(27760, 5) + "ISub\0" // IR(27765, 5) + "FSub\0" // IR(27770, 5) + "IMul\0" // IR(27775, 5) + "FMul\0" // IR(27780, 5) + "UDiv\0" // IR(27785, 5) + "SDiv\0" // IR(27790, 5) + "FDiv\0" // IR(27795, 5) + "UMod\0" // IR(27800, 5) + "SRem\0" // IR(27805, 5) + "SMod\0" // IR(27810, 5) + "FRem\0" // IR(27815, 5) + "FMod\0" // IR(27820, 5) + "VectorTimesScalar\0" // IR(27825, 18) + "MatrixTimesScalar\0" // IR(27843, 18) + "VectorTimesMatrix\0" // IR(27861, 18) + "MatrixTimesVector\0" // IR(27879, 18) + "MatrixTimesMatrix\0" // IR(27897, 18) + "OuterProduct\0" // IR(27915, 13) + "Dot\0" // IR(27928, 4) + "IAddCarry\0" // IR(27932, 10) + "ISubBorrow\0" // IR(27942, 11) + "UMulExtended\0" // IR(27953, 13) + "SMulExtended\0" // IR(27966, 13) + "Any\0" // IR(27979, 4) + "All\0" // IR(27983, 4) + "IsNan\0" // IR(27987, 6) + "IsInf\0" // IR(27993, 6) + "IsFinite\0" // IR(27999, 9) + "IsNormal\0" // IR(28008, 9) + "SignBitSet\0" // IR(28017, 11) + "LessOrGreater\0" // IR(28028, 14) + "Ordered\0" // IR(28042, 8) + "Unordered\0" // IR(28050, 10) + "LogicalEqual\0" // IR(28060, 13) + "LogicalNotEqual\0" // IR(28073, 16) + "LogicalOr\0" // IR(28089, 10) + "LogicalAnd\0" // IR(28099, 11) + "LogicalNot\0" // IR(28110, 11) + "Select\0" // IR(28121, 7) + "IEqual\0" // IR(28128, 7) + "INotEqual\0" // IR(28135, 10) + "UGreaterThan\0" // IR(28145, 13) + "SGreaterThan\0" // IR(28158, 13) + "UGreaterThanEqual\0" // IR(28171, 18) + "SGreaterThanEqual\0" // IR(28189, 18) + "ULessThan\0" // IR(28207, 10) + "SLessThan\0" // IR(28217, 10) + "ULessThanEqual\0" // IR(28227, 15) + "SLessThanEqual\0" // IR(28242, 15) + "FOrdEqual\0" // IR(28257, 10) + "FUnordEqual\0" // IR(28267, 12) + "FOrdNotEqual\0" // IR(28279, 13) + "FUnordNotEqual\0" // IR(28292, 15) + "FOrdLessThan\0" // IR(28307, 13) + "FUnordLessThan\0" // IR(28320, 15) + "FOrdGreaterThan\0" // IR(28335, 16) + "FUnordGreaterThan\0" // IR(28351, 18) + "FOrdLessThanEqual\0" // IR(28369, 18) + "FUnordLessThanEqual\0" // IR(28387, 20) + "FOrdGreaterThanEqual\0" // IR(28407, 21) + "FUnordGreaterThanEqual\0" // IR(28428, 23) + "ShiftRightLogical\0" // IR(28451, 18) + "ShiftRightArithmetic\0" // IR(28469, 21) + "ShiftLeftLogical\0" // IR(28490, 17) + "BitwiseOr\0" // IR(28507, 10) + "BitwiseXor\0" // IR(28517, 11) + "BitwiseAnd\0" // IR(28528, 11) + "Not\0" // IR(28539, 4) + "BitFieldInsert\0" // IR(28543, 15) + "BitFieldSExtract\0" // IR(28558, 17) + "BitFieldUExtract\0" // IR(28575, 17) + "BitReverse\0" // IR(28592, 11) + "BitCount\0" // IR(28603, 9) + "DPdx\0" // IR(28612, 5) + "DPdy\0" // IR(28617, 5) + "Fwidth\0" // IR(28622, 7) + "DPdxFine\0" // IR(28629, 9) + "DPdyFine\0" // IR(28638, 9) + "FwidthFine\0" // IR(28647, 11) + "DPdxCoarse\0" // IR(28658, 11) + "DPdyCoarse\0" // IR(28669, 11) + "FwidthCoarse\0" // IR(28680, 13) + "EmitVertex\0" // IR(28693, 11) + "EndPrimitive\0" // IR(28704, 13) + "EmitStreamVertex\0" // IR(28717, 17) + "EndStreamPrimitive\0" // IR(28734, 19) + "SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID\0" // IR(28753, 37) + "ControlBarrier\0" // IR(28790, 15) + "MemoryBarrier\0" // IR(28805, 14) + "AtomicLoad\0" // IR(28819, 11) + "AtomicStore\0" // IR(28830, 12) + "AtomicExchange\0" // IR(28842, 15) + "AtomicCompareExchange\0" // IR(28857, 22) + "AtomicCompareExchangeWeak\0" // IR(28879, 26) + "AtomicIIncrement\0" // IR(28905, 17) + "AtomicIDecrement\0" // IR(28922, 17) + "AtomicIAdd\0" // IR(28939, 11) + "AtomicISub\0" // IR(28950, 11) + "AtomicSMin\0" // IR(28961, 11) + "AtomicUMin\0" // IR(28972, 11) + "AtomicSMax\0" // IR(28983, 11) + "AtomicUMax\0" // IR(28994, 11) + "AtomicAnd\0" // IR(29005, 10) + "AtomicOr\0" // IR(29015, 9) + "AtomicXor\0" // IR(29024, 10) + "Phi\0" // IR(29034, 4) + "SPV_OPERAND_TYPE_LOOP_CONTROL\0" // IR(29038, 30) + "LoopMerge\0" // IR(29068, 10) + "SPV_OPERAND_TYPE_SELECTION_CONTROL\0" // IR(29078, 35) + "SelectionMerge\0" // IR(29113, 15) + "Label\0" // IR(29128, 6) + "Branch\0" // IR(29134, 7) + "BranchConditional\0" // IR(29141, 18) + "SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER_ID\0" // IR(29159, 45) + "Switch\0" // IR(29204, 7) + "Kill\0" // IR(29211, 5) + "Return\0" // IR(29216, 7) + "ReturnValue\0" // IR(29223, 12) + "Unreachable\0" // IR(29235, 12) + "LifetimeStart\0" // IR(29247, 14) + "LifetimeStop\0" // IR(29261, 13) + "GroupAsyncCopy\0" // IR(29274, 15) + "GroupWaitEvents\0" // IR(29289, 16) + "GroupAll\0" // IR(29305, 9) + "GroupAny\0" // IR(29314, 9) + "GroupBroadcast\0" // IR(29323, 15) + "SPV_OPERAND_TYPE_GROUP_OPERATION\0" // IR(29338, 33) + "GroupIAdd\0" // IR(29371, 10) + "GroupFAdd\0" // IR(29381, 10) + "GroupFMin\0" // IR(29391, 10) + "GroupUMin\0" // IR(29401, 10) + "GroupSMin\0" // IR(29411, 10) + "GroupFMax\0" // IR(29421, 10) + "GroupUMax\0" // IR(29431, 10) + "GroupSMax\0" // IR(29441, 10) + "ReadPipe\0" // IR(29451, 9) + "WritePipe\0" // IR(29460, 10) + "ReservedReadPipe\0" // IR(29470, 17) + "ReservedWritePipe\0" // IR(29487, 18) + "ReserveReadPipePackets\0" // IR(29505, 23) + "ReserveWritePipePackets\0" // IR(29528, 24) + "CommitReadPipe\0" // IR(29552, 15) + "CommitWritePipe\0" // IR(29567, 16) + "IsValidReserveId\0" // IR(29583, 17) + "GetNumPipePackets\0" // IR(29600, 18) + "GetMaxPipePackets\0" // IR(29618, 18) + "GroupReserveReadPipePackets\0" // IR(29636, 28) + "GroupReserveWritePipePackets\0" // IR(29664, 29) + "GroupCommitReadPipe\0" // IR(29693, 20) + "GroupCommitWritePipe\0" // IR(29713, 21) + "EnqueueMarker\0" // IR(29734, 14) + "EnqueueKernel\0" // IR(29748, 14) + "GetKernelNDrangeSubGroupCount\0" // IR(29762, 30) + "GetKernelNDrangeMaxSubGroupSize\0" // IR(29792, 32) + "GetKernelWorkGroupSize\0" // IR(29824, 23) + "GetKernelPreferredWorkGroupSizeMultiple\0" // IR(29847, 40) + "RetainEvent\0" // IR(29887, 12) + "ReleaseEvent\0" // IR(29899, 13) + "CreateUserEvent\0" // IR(29912, 16) + "IsValidEvent\0" // IR(29928, 13) + "SetUserEventStatus\0" // IR(29941, 19) + "CaptureEventProfilingInfo\0" // IR(29960, 26) + "GetDefaultQueue\0" // IR(29986, 16) + "BuildNDRange\0" // IR(30002, 13) + "ImageSparseSampleImplicitLod\0" // IR(30015, 29) + "ImageSparseSampleExplicitLod\0" // IR(30044, 29) + "ImageSparseSampleDrefImplicitLod\0" // IR(30073, 33) + "ImageSparseSampleDrefExplicitLod\0" // IR(30106, 33) + "ImageSparseSampleProjImplicitLod\0" // IR(30139, 33) + "ImageSparseSampleProjExplicitLod\0" // IR(30172, 33) + "ImageSparseSampleProjDrefImplicitLod\0" // IR(30205, 37) + "ImageSparseSampleProjDrefExplicitLod\0" // IR(30242, 37) + "ImageSparseFetch\0" // IR(30279, 17) + "ImageSparseGather\0" // IR(30296, 18) + "ImageSparseDrefGather\0" // IR(30314, 22) + "ImageSparseTexelsResident\0" // IR(30336, 26) + "NoLine\0" // IR(30362, 7) + "AtomicFlagTestAndSet\0" // IR(30369, 21) + "AtomicFlagClear\0" // IR(30390, 16) + "ImageSparseRead\0" // IR(30406, 16) + "SizeOf\0" // IR(30422, 7) + "TypePipeStorage\0" // IR(30429, 16) + "ConstantPipeStorage\0" // IR(30445, 20) + "CreatePipeFromPipeStorage\0" // IR(30465, 26) + "GetKernelLocalSizeForSubgroupCount\0" // IR(30491, 35) + "GetKernelMaxNumSubgroups\0" // IR(30526, 25) + "TypeNamedBarrier\0" // IR(30551, 17) + "NamedBarrierInitialize\0" // IR(30568, 23) + "MemoryNamedBarrier\0" // IR(30591, 19) + "ModuleProcessed\0" // IR(30610, 16) + "ExecutionModeId\0" // IR(30626, 16) + "DecorateId\0" // IR(30642, 11) + "GroupNonUniformElect\0" // IR(30653, 21) + "GroupNonUniformAll\0" // IR(30674, 19) + "GroupNonUniformAny\0" // IR(30693, 19) + "GroupNonUniformAllEqual\0" // IR(30712, 24) + "GroupNonUniformBroadcast\0" // IR(30736, 25) + "GroupNonUniformBroadcastFirst\0" // IR(30761, 30) + "GroupNonUniformInverseBallot\0" // IR(30791, 29) + "GroupNonUniformBallotBitExtract\0" // IR(30820, 32) + "GroupNonUniformBallotBitCount\0" // IR(30852, 30) + "GroupNonUniformBallotFindLSB\0" // IR(30882, 29) + "GroupNonUniformBallotFindMSB\0" // IR(30911, 29) + "GroupNonUniformShuffleXor\0" // IR(30940, 26) + "GroupNonUniformShuffleUp\0" // IR(30966, 25) + "GroupNonUniformShuffleDown\0" // IR(30991, 27) + "GroupNonUniformIAdd\0" // IR(31018, 20) + "GroupNonUniformFAdd\0" // IR(31038, 20) + "GroupNonUniformIMul\0" // IR(31058, 20) + "GroupNonUniformFMul\0" // IR(31078, 20) + "GroupNonUniformSMin\0" // IR(31098, 20) + "GroupNonUniformUMin\0" // IR(31118, 20) + "GroupNonUniformFMin\0" // IR(31138, 20) + "GroupNonUniformSMax\0" // IR(31158, 20) + "GroupNonUniformUMax\0" // IR(31178, 20) + "GroupNonUniformFMax\0" // IR(31198, 20) + "GroupNonUniformBitwiseAnd\0" // IR(31218, 26) + "GroupNonUniformBitwiseOr\0" // IR(31244, 25) + "GroupNonUniformBitwiseXor\0" // IR(31269, 26) + "GroupNonUniformLogicalAnd\0" // IR(31295, 26) + "GroupNonUniformLogicalOr\0" // IR(31321, 25) + "GroupNonUniformLogicalXor\0" // IR(31346, 26) + "GroupNonUniformQuadBroadcast\0" // IR(31372, 29) + "GroupNonUniformQuadSwap\0" // IR(31401, 24) + "CopyLogical\0" // IR(31425, 12) + "PtrEqual\0" // IR(31437, 9) + "PtrNotEqual\0" // IR(31446, 12) + "PtrDiff\0" // IR(31458, 8) + "ColorAttachmentReadEXT\0" // IR(31466, 23) + "DepthAttachmentReadEXT\0" // IR(31489, 23) + "StencilAttachmentReadEXT\0" // IR(31512, 25) + "TypeTensorARM\0" // IR(31537, 14) + "SPV_OPERAND_TYPE_OPTIONAL_TENSOR_OPERANDS\0" // IR(31551, 42) + "TensorReadARM\0" // IR(31593, 14) + "TensorWriteARM\0" // IR(31607, 15) + "TensorQuerySizeARM\0" // IR(31622, 19) + "GraphConstantARM\0" // IR(31641, 17) + "GraphEntryPointARM\0" // IR(31658, 19) + "GraphInputARM\0" // IR(31677, 14) + "GraphSetOutputARM\0" // IR(31691, 18) + "GraphEndARM\0" // IR(31709, 12) + "TypeGraphARM\0" // IR(31721, 13) + "TerminateInvocation\0" // IR(31734, 20) + "TypeUntypedPointerKHR\0" // IR(31754, 22) + "UntypedVariableKHR\0" // IR(31776, 19) + "UntypedAccessChainKHR\0" // IR(31795, 22) + "UntypedInBoundsAccessChainKHR\0" // IR(31817, 30) + "SubgroupFirstInvocationKHR\0" // IR(31847, 27) + "UntypedPtrAccessChainKHR\0" // IR(31874, 25) + "UntypedInBoundsPtrAccessChainKHR\0" // IR(31899, 33) + "UntypedArrayLengthKHR\0" // IR(31932, 22) + "UntypedPrefetchKHR\0" // IR(31954, 19) + "FmaKHR\0" // IR(31973, 7) + "SubgroupAllKHR\0" // IR(31980, 15) + "SubgroupAnyKHR\0" // IR(31995, 15) + "SubgroupAllEqualKHR\0" // IR(32010, 20) + "SubgroupReadInvocationKHR\0" // IR(32030, 26) + "ExtInstWithForwardRefsKHR\0" // IR(32056, 26) + "UntypedGroupAsyncCopyKHR\0" // IR(32082, 25) + "TraceRayKHR\0" // IR(32107, 12) + "ExecuteCallableKHR\0" // IR(32119, 19) + "ConvertUToAccelerationStructureKHR\0" // IR(32138, 35) + "IgnoreIntersectionKHR\0" // IR(32173, 22) + "TerminateRayKHR\0" // IR(32195, 16) + "SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT\0" // IR(32211, 47) + "SDot\0" // IR(32258, 5) + "SDotKHR\0" // IR(32263, 8) + "UDot\0" // IR(32271, 5) + "UDotKHR\0" // IR(32276, 8) + "SUDot\0" // IR(32284, 6) + "SUDotKHR\0" // IR(32290, 9) + "SDotAccSat\0" // IR(32299, 11) + "SDotAccSatKHR\0" // IR(32310, 14) + "UDotAccSat\0" // IR(32324, 11) + "UDotAccSatKHR\0" // IR(32335, 14) + "SUDotAccSat\0" // IR(32349, 12) + "SUDotAccSatKHR\0" // IR(32361, 15) + "TypeCooperativeMatrixKHR\0" // IR(32376, 25) + "CooperativeMatrixLoadKHR\0" // IR(32401, 25) + "CooperativeMatrixStoreKHR\0" // IR(32426, 26) + "SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS\0" // IR(32452, 54) + "CooperativeMatrixMulAddKHR\0" // IR(32506, 27) + "CooperativeMatrixLengthKHR\0" // IR(32533, 27) + "ConstantCompositeReplicateEXT\0" // IR(32560, 30) + "SpecConstantCompositeReplicateEXT\0" // IR(32590, 34) + "CompositeConstructReplicateEXT\0" // IR(32624, 31) + "TypeRayQueryKHR\0" // IR(32655, 16) + "RayQueryInitializeKHR\0" // IR(32671, 22) + "RayQueryTerminateKHR\0" // IR(32693, 21) + "RayQueryGenerateIntersectionKHR\0" // IR(32714, 32) + "RayQueryConfirmIntersectionKHR\0" // IR(32746, 31) + "RayQueryProceedKHR\0" // IR(32777, 19) + "RayQueryGetIntersectionTypeKHR\0" // IR(32796, 31) + "ImageSampleWeightedQCOM\0" // IR(32827, 24) + "ImageBoxFilterQCOM\0" // IR(32851, 19) + "ImageBlockMatchSSDQCOM\0" // IR(32870, 23) + "ImageBlockMatchSADQCOM\0" // IR(32893, 23) + "BitCastArrayQCOM\0" // IR(32916, 17) + "ImageBlockMatchWindowSSDQCOM\0" // IR(32933, 29) + "ImageBlockMatchWindowSADQCOM\0" // IR(32962, 29) + "ImageBlockMatchGatherSSDQCOM\0" // IR(32991, 29) + "ImageBlockMatchGatherSADQCOM\0" // IR(33020, 29) + "CompositeConstructCoopMatQCOM\0" // IR(33049, 30) + "CompositeExtractCoopMatQCOM\0" // IR(33079, 28) + "ExtractSubArrayQCOM\0" // IR(33107, 20) + "GroupIAddNonUniformAMD\0" // IR(33127, 23) + "GroupFAddNonUniformAMD\0" // IR(33150, 23) + "GroupFMinNonUniformAMD\0" // IR(33173, 23) + "GroupUMinNonUniformAMD\0" // IR(33196, 23) + "GroupSMinNonUniformAMD\0" // IR(33219, 23) + "GroupFMaxNonUniformAMD\0" // IR(33242, 23) + "GroupUMaxNonUniformAMD\0" // IR(33265, 23) + "GroupSMaxNonUniformAMD\0" // IR(33288, 23) + "FragmentMaskFetchAMD\0" // IR(33311, 21) + "FragmentFetchAMD\0" // IR(33332, 17) + "ReadClockKHR\0" // IR(33349, 13) + "AllocateNodePayloadsAMDX\0" // IR(33362, 25) + "EnqueueNodePayloadsAMDX\0" // IR(33387, 24) + "TypeNodePayloadArrayAMDX\0" // IR(33411, 25) + "FinishWritingNodePayloadAMDX\0" // IR(33436, 29) + "NodePayloadArrayLengthAMDX\0" // IR(33465, 27) + "IsNodePayloadValidAMDX\0" // IR(33492, 23) + "ConstantStringAMDX\0" // IR(33515, 19) + "SpecConstantStringAMDX\0" // IR(33534, 23) + "GroupNonUniformQuadAllKHR\0" // IR(33557, 26) + "GroupNonUniformQuadAnyKHR\0" // IR(33583, 26) + "HitObjectRecordHitMotionNV\0" // IR(33609, 27) + "HitObjectRecordHitWithIndexMotionNV\0" // IR(33636, 36) + "HitObjectRecordMissMotionNV\0" // IR(33672, 28) + "HitObjectGetWorldToObjectNV\0" // IR(33700, 28) + "HitObjectGetObjectToWorldNV\0" // IR(33728, 28) + "HitObjectGetObjectRayDirectionNV\0" // IR(33756, 33) + "HitObjectGetObjectRayOriginNV\0" // IR(33789, 30) + "HitObjectTraceRayMotionNV\0" // IR(33819, 26) + "HitObjectGetShaderRecordBufferHandleNV\0" // IR(33845, 39) + "HitObjectGetShaderBindingTableRecordIndexNV\0" // IR(33884, 44) + "HitObjectRecordEmptyNV\0" // IR(33928, 23) + "HitObjectTraceRayNV\0" // IR(33951, 20) + "HitObjectRecordHitNV\0" // IR(33971, 21) + "HitObjectRecordHitWithIndexNV\0" // IR(33992, 30) + "HitObjectRecordMissNV\0" // IR(34022, 22) + "HitObjectExecuteShaderNV\0" // IR(34044, 25) + "HitObjectGetCurrentTimeNV\0" // IR(34069, 26) + "HitObjectGetAttributesNV\0" // IR(34095, 25) + "HitObjectGetHitKindNV\0" // IR(34120, 22) + "HitObjectGetPrimitiveIndexNV\0" // IR(34142, 29) + "HitObjectGetGeometryIndexNV\0" // IR(34171, 28) + "HitObjectGetInstanceIdNV\0" // IR(34199, 25) + "HitObjectGetInstanceCustomIndexNV\0" // IR(34224, 34) + "HitObjectGetWorldRayDirectionNV\0" // IR(34258, 32) + "HitObjectGetWorldRayOriginNV\0" // IR(34290, 29) + "HitObjectGetRayTMaxNV\0" // IR(34319, 22) + "HitObjectGetRayTMinNV\0" // IR(34341, 22) + "HitObjectIsEmptyNV\0" // IR(34363, 19) + "HitObjectIsHitNV\0" // IR(34382, 17) + "HitObjectIsMissNV\0" // IR(34399, 18) + "ReorderThreadWithHitObjectNV\0" // IR(34417, 29) + "ReorderThreadWithHintNV\0" // IR(34446, 24) + "TypeHitObjectNV\0" // IR(34470, 16) + "ImageSampleFootprintNV\0" // IR(34486, 23) + "TypeCooperativeVectorNV\0" // IR(34509, 24) + "CooperativeVectorMatrixMulNV\0" // IR(34533, 29) + "CooperativeVectorOuterProductAccumulateNV\0" // IR(34562, 42) + "CooperativeVectorReduceSumAccumulateNV\0" // IR(34604, 39) + "CooperativeVectorMatrixMulAddNV\0" // IR(34643, 32) + "CooperativeMatrixConvertNV\0" // IR(34675, 27) + "EmitMeshTasksEXT\0" // IR(34702, 17) + "SetMeshOutputsEXT\0" // IR(34719, 18) + "GroupNonUniformPartitionNV\0" // IR(34737, 27) + "WritePackedPrimitiveIndices4x8NV\0" // IR(34764, 33) + "FetchMicroTriangleVertexPositionNV\0" // IR(34797, 35) + "FetchMicroTriangleVertexBarycentricNV\0" // IR(34832, 38) + "CooperativeVectorLoadNV\0" // IR(34870, 24) + "CooperativeVectorStoreNV\0" // IR(34894, 25) + "ReportIntersectionKHR\0" // IR(34919, 22) + "ReportIntersectionNV\0" // IR(34941, 21) + "IgnoreIntersectionNV\0" // IR(34962, 21) + "TerminateRayNV\0" // IR(34983, 15) + "TraceNV\0" // IR(34998, 8) + "TraceMotionNV\0" // IR(35006, 14) + "TraceRayMotionNV\0" // IR(35020, 17) + "RayQueryGetIntersectionTriangleVertexPositionsKHR\0" // IR(35037, 50) + "TypeAccelerationStructureKHR\0" // IR(35087, 29) + "TypeAccelerationStructureNV\0" // IR(35116, 28) + "ExecuteCallableNV\0" // IR(35144, 18) + "RayQueryGetIntersectionClusterIdNV\0" // IR(35162, 35) + "RayQueryGetClusterIdNV\0" // IR(35197, 23) + "HitObjectGetClusterIdNV\0" // IR(35220, 24) + "TypeCooperativeMatrixNV\0" // IR(35244, 24) + "CooperativeMatrixLoadNV\0" // IR(35268, 24) + "CooperativeMatrixStoreNV\0" // IR(35292, 25) + "CooperativeMatrixMulAddNV\0" // IR(35317, 26) + "CooperativeMatrixLengthNV\0" // IR(35343, 26) + "BeginInvocationInterlockEXT\0" // IR(35369, 28) + "EndInvocationInterlockEXT\0" // IR(35397, 26) + "SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE\0" // IR(35423, 43) + "CooperativeMatrixReduceNV\0" // IR(35466, 26) + "SPV_OPERAND_TYPE_MEMORY_ACCESS\0" // IR(35492, 31) + "SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS\0" // IR(35523, 44) + "CooperativeMatrixLoadTensorNV\0" // IR(35567, 30) + "CooperativeMatrixStoreTensorNV\0" // IR(35597, 31) + "CooperativeMatrixPerElementOpNV\0" // IR(35628, 32) + "TypeTensorLayoutNV\0" // IR(35660, 19) + "TypeTensorViewNV\0" // IR(35679, 17) + "CreateTensorLayoutNV\0" // IR(35696, 21) + "TensorLayoutSetDimensionNV\0" // IR(35717, 27) + "TensorLayoutSetStrideNV\0" // IR(35744, 24) + "TensorLayoutSliceNV\0" // IR(35768, 20) + "TensorLayoutSetClampValueNV\0" // IR(35788, 28) + "CreateTensorViewNV\0" // IR(35816, 19) + "TensorViewSetDimensionNV\0" // IR(35835, 25) + "TensorViewSetStrideNV\0" // IR(35860, 22) + "IsHelperInvocationEXT\0" // IR(35882, 22) + "TensorViewSetClipNV\0" // IR(35904, 20) + "TensorLayoutSetBlockSizeNV\0" // IR(35924, 27) + "CooperativeMatrixTransposeNV\0" // IR(35951, 29) + "ConvertUToImageNV\0" // IR(35980, 18) + "ConvertUToSamplerNV\0" // IR(35998, 20) + "ConvertImageToUNV\0" // IR(36018, 18) + "ConvertSamplerToUNV\0" // IR(36036, 20) + "ConvertUToSampledImageNV\0" // IR(36056, 25) + "ConvertSampledImageToUNV\0" // IR(36081, 25) + "SamplerImageAddressingModeNV\0" // IR(36106, 29) + "SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS\0" // IR(36135, 52) + "RawAccessChainNV\0" // IR(36187, 17) + "RayQueryGetIntersectionSpherePositionNV\0" // IR(36204, 40) + "RayQueryGetIntersectionSphereRadiusNV\0" // IR(36244, 38) + "RayQueryGetIntersectionLSSPositionsNV\0" // IR(36282, 38) + "RayQueryGetIntersectionLSSRadiiNV\0" // IR(36320, 34) + "RayQueryGetIntersectionLSSHitValueNV\0" // IR(36354, 37) + "HitObjectGetSpherePositionNV\0" // IR(36391, 29) + "HitObjectGetSphereRadiusNV\0" // IR(36420, 27) + "HitObjectGetLSSPositionsNV\0" // IR(36447, 27) + "HitObjectGetLSSRadiiNV\0" // IR(36474, 23) + "HitObjectIsSphereHitNV\0" // IR(36497, 23) + "HitObjectIsLSSHitNV\0" // IR(36520, 20) + "RayQueryIsSphereHitNV\0" // IR(36540, 22) + "RayQueryIsLSSHitNV\0" // IR(36562, 19) + "SubgroupShuffleDownINTEL\0" // IR(36581, 25) + "SubgroupShuffleUpINTEL\0" // IR(36606, 23) + "SubgroupShuffleXorINTEL\0" // IR(36629, 24) + "SubgroupBlockReadINTEL\0" // IR(36653, 23) + "SubgroupBlockWriteINTEL\0" // IR(36676, 24) + "SubgroupImageBlockReadINTEL\0" // IR(36700, 28) + "SubgroupImageBlockWriteINTEL\0" // IR(36728, 29) + "SubgroupImageMediaBlockReadINTEL\0" // IR(36757, 33) + "SubgroupImageMediaBlockWriteINTEL\0" // IR(36790, 34) + "UCountLeadingZerosINTEL\0" // IR(36824, 24) + "UCountTrailingZerosINTEL\0" // IR(36848, 25) + "AbsISubINTEL\0" // IR(36873, 13) + "AbsUSubINTEL\0" // IR(36886, 13) + "IAddSatINTEL\0" // IR(36899, 13) + "UAddSatINTEL\0" // IR(36912, 13) + "IAverageINTEL\0" // IR(36925, 14) + "UAverageINTEL\0" // IR(36939, 14) + "IAverageRoundedINTEL\0" // IR(36953, 21) + "UAverageRoundedINTEL\0" // IR(36974, 21) + "ISubSatINTEL\0" // IR(36995, 13) + "USubSatINTEL\0" // IR(37008, 13) + "IMul32x16INTEL\0" // IR(37021, 15) + "UMul32x16INTEL\0" // IR(37036, 15) + "ConstantFunctionPointerINTEL\0" // IR(37051, 29) + "FunctionPointerCallINTEL\0" // IR(37080, 25) + "AsmTargetINTEL\0" // IR(37105, 15) + "AsmCallINTEL\0" // IR(37120, 13) + "AtomicFMinEXT\0" // IR(37133, 14) + "AtomicFMaxEXT\0" // IR(37147, 14) + "AssumeTrueKHR\0" // IR(37161, 14) + "ExpectKHR\0" // IR(37175, 10) + "DecorateString\0" // IR(37185, 15) + "DecorateStringGOOGLE\0" // IR(37200, 21) + "MemberDecorateString\0" // IR(37221, 21) + "MemberDecorateStringGOOGLE\0" // IR(37242, 27) + "VmeImageINTEL\0" // IR(37269, 14) + "TypeVmeImageINTEL\0" // IR(37283, 18) + "TypeAvcImePayloadINTEL\0" // IR(37301, 23) + "TypeAvcRefPayloadINTEL\0" // IR(37324, 23) + "TypeAvcSicPayloadINTEL\0" // IR(37347, 23) + "TypeAvcMcePayloadINTEL\0" // IR(37370, 23) + "TypeAvcMceResultINTEL\0" // IR(37393, 22) + "TypeAvcImeResultINTEL\0" // IR(37415, 22) + "TypeAvcImeResultSingleReferenceStreamoutINTEL\0" // IR(37437, 46) + "TypeAvcImeResultDualReferenceStreamoutINTEL\0" // IR(37483, 44) + "TypeAvcImeSingleReferenceStreaminINTEL\0" // IR(37527, 39) + "TypeAvcImeDualReferenceStreaminINTEL\0" // IR(37566, 37) + "TypeAvcRefResultINTEL\0" // IR(37603, 22) + "TypeAvcSicResultINTEL\0" // IR(37625, 22) + "SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL\0" // IR(37647, 60) + "SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL\0" // IR(37707, 53) + "SubgroupAvcMceGetDefaultInterShapePenaltyINTEL\0" // IR(37760, 47) + "SubgroupAvcMceSetInterShapePenaltyINTEL\0" // IR(37807, 40) + "SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL\0" // IR(37847, 51) + "SubgroupAvcMceSetInterDirectionPenaltyINTEL\0" // IR(37898, 44) + "SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL\0" // IR(37942, 51) + "SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL\0" // IR(37993, 56) + "SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL\0" // IR(38049, 50) + "SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL\0" // IR(38099, 52) + "SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL\0" // IR(38151, 49) + "SubgroupAvcMceSetMotionVectorCostFunctionINTEL\0" // IR(38200, 47) + "SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL\0" // IR(38247, 50) + "SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL\0" // IR(38297, 51) + "SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL\0" // IR(38348, 56) + "SubgroupAvcMceSetAcOnlyHaarINTEL\0" // IR(38404, 33) + "SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL\0" // IR(38437, 52) + "SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL\0" // IR(38489, 61) + "SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL\0" // IR(38550, 61) + "SubgroupAvcMceConvertToImePayloadINTEL\0" // IR(38611, 39) + "SubgroupAvcMceConvertToImeResultINTEL\0" // IR(38650, 38) + "SubgroupAvcMceConvertToRefPayloadINTEL\0" // IR(38688, 39) + "SubgroupAvcMceConvertToRefResultINTEL\0" // IR(38727, 38) + "SubgroupAvcMceConvertToSicPayloadINTEL\0" // IR(38765, 39) + "SubgroupAvcMceConvertToSicResultINTEL\0" // IR(38804, 38) + "SubgroupAvcMceGetMotionVectorsINTEL\0" // IR(38842, 36) + "SubgroupAvcMceGetInterDistortionsINTEL\0" // IR(38878, 39) + "SubgroupAvcMceGetBestInterDistortionsINTEL\0" // IR(38917, 43) + "SubgroupAvcMceGetInterMajorShapeINTEL\0" // IR(38960, 38) + "SubgroupAvcMceGetInterMinorShapeINTEL\0" // IR(38998, 38) + "SubgroupAvcMceGetInterDirectionsINTEL\0" // IR(39036, 38) + "SubgroupAvcMceGetInterMotionVectorCountINTEL\0" // IR(39074, 45) + "SubgroupAvcMceGetInterReferenceIdsINTEL\0" // IR(39119, 40) + "SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL\0" // IR(39159, 62) + "SubgroupAvcImeInitializeINTEL\0" // IR(39221, 30) + "SubgroupAvcImeSetSingleReferenceINTEL\0" // IR(39251, 38) + "SubgroupAvcImeSetDualReferenceINTEL\0" // IR(39289, 36) + "SubgroupAvcImeRefWindowSizeINTEL\0" // IR(39325, 33) + "SubgroupAvcImeAdjustRefOffsetINTEL\0" // IR(39358, 35) + "SubgroupAvcImeConvertToMcePayloadINTEL\0" // IR(39393, 39) + "SubgroupAvcImeSetMaxMotionVectorCountINTEL\0" // IR(39432, 43) + "SubgroupAvcImeSetUnidirectionalMixDisableINTEL\0" // IR(39475, 47) + "SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL\0" // IR(39522, 54) + "SubgroupAvcImeSetWeightedSadINTEL\0" // IR(39576, 34) + "SubgroupAvcImeEvaluateWithSingleReferenceINTEL\0" // IR(39610, 47) + "SubgroupAvcImeEvaluateWithDualReferenceINTEL\0" // IR(39657, 45) + "SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL\0" // IR(39702, 55) + "SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL\0" // IR(39757, 53) + "SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL\0" // IR(39810, 56) + "SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL\0" // IR(39866, 54) + "SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL\0" // IR(39920, 58) + "SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL\0" // IR(39978, 56) + "SubgroupAvcImeConvertToMceResultINTEL\0" // IR(40034, 38) + "SubgroupAvcImeGetSingleReferenceStreaminINTEL\0" // IR(40072, 46) + "SubgroupAvcImeGetDualReferenceStreaminINTEL\0" // IR(40118, 44) + "SubgroupAvcImeStripSingleReferenceStreamoutINTEL\0" // IR(40162, 49) + "SubgroupAvcImeStripDualReferenceStreamoutINTEL\0" // IR(40211, 47) + "SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL\0" // IR(40258, 70) + "SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL\0" // IR(40328, 68) + "SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL\0" // IR(40396, 69) + "SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL\0" // IR(40465, 68) + "SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL\0" // IR(40533, 66) + "SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL\0" // IR(40599, 67) + "SubgroupAvcImeGetBorderReachedINTEL\0" // IR(40666, 36) + "SubgroupAvcImeGetTruncatedSearchIndicationINTEL\0" // IR(40702, 48) + "SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL\0" // IR(40750, 59) + "SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL\0" // IR(40809, 58) + "SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL\0" // IR(40867, 56) + "SubgroupAvcFmeInitializeINTEL\0" // IR(40923, 30) + "SubgroupAvcBmeInitializeINTEL\0" // IR(40953, 30) + "SubgroupAvcRefConvertToMcePayloadINTEL\0" // IR(40983, 39) + "SubgroupAvcRefSetBidirectionalMixDisableINTEL\0" // IR(41022, 46) + "SubgroupAvcRefSetBilinearFilterEnableINTEL\0" // IR(41068, 43) + "SubgroupAvcRefEvaluateWithSingleReferenceINTEL\0" // IR(41111, 47) + "SubgroupAvcRefEvaluateWithDualReferenceINTEL\0" // IR(41158, 45) + "SubgroupAvcRefEvaluateWithMultiReferenceINTEL\0" // IR(41203, 46) + "SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL\0" // IR(41249, 56) + "SubgroupAvcRefConvertToMceResultINTEL\0" // IR(41305, 38) + "SubgroupAvcSicInitializeINTEL\0" // IR(41343, 30) + "SubgroupAvcSicConfigureSkcINTEL\0" // IR(41373, 32) + "SubgroupAvcSicConfigureIpeLumaINTEL\0" // IR(41405, 36) + "SubgroupAvcSicConfigureIpeLumaChromaINTEL\0" // IR(41441, 42) + "SubgroupAvcSicGetMotionVectorMaskINTEL\0" // IR(41483, 39) + "SubgroupAvcSicConvertToMcePayloadINTEL\0" // IR(41522, 39) + "SubgroupAvcSicSetIntraLumaShapePenaltyINTEL\0" // IR(41561, 44) + "SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL\0" // IR(41605, 48) + "SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL\0" // IR(41653, 50) + "SubgroupAvcSicSetBilinearFilterEnableINTEL\0" // IR(41703, 43) + "SubgroupAvcSicSetSkcForwardTransformEnableINTEL\0" // IR(41746, 48) + "SubgroupAvcSicSetBlockBasedRawSkipSadINTEL\0" // IR(41794, 43) + "SubgroupAvcSicEvaluateIpeINTEL\0" // IR(41837, 31) + "SubgroupAvcSicEvaluateWithSingleReferenceINTEL\0" // IR(41868, 47) + "SubgroupAvcSicEvaluateWithDualReferenceINTEL\0" // IR(41915, 45) + "SubgroupAvcSicEvaluateWithMultiReferenceINTEL\0" // IR(41960, 46) + "SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL\0" // IR(42006, 56) + "SubgroupAvcSicConvertToMceResultINTEL\0" // IR(42062, 38) + "SubgroupAvcSicGetIpeLumaShapeINTEL\0" // IR(42100, 35) + "SubgroupAvcSicGetBestIpeLumaDistortionINTEL\0" // IR(42135, 44) + "SubgroupAvcSicGetBestIpeChromaDistortionINTEL\0" // IR(42179, 46) + "SubgroupAvcSicGetPackedIpeLumaModesINTEL\0" // IR(42225, 41) + "SubgroupAvcSicGetIpeChromaModeINTEL\0" // IR(42266, 36) + "SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL\0" // IR(42302, 50) + "SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL\0" // IR(42352, 48) + "SubgroupAvcSicGetInterRawSadsINTEL\0" // IR(42400, 35) + "SaveMemoryINTEL\0" // IR(42435, 16) + "RestoreMemoryINTEL\0" // IR(42451, 19) + "ArbitraryFloatSinCosPiINTEL\0" // IR(42470, 28) + "ArbitraryFloatCastINTEL\0" // IR(42498, 24) + "ArbitraryFloatCastFromIntINTEL\0" // IR(42522, 31) + "ArbitraryFloatCastToIntINTEL\0" // IR(42553, 29) + "ArbitraryFloatAddINTEL\0" // IR(42582, 23) + "ArbitraryFloatSubINTEL\0" // IR(42605, 23) + "ArbitraryFloatMulINTEL\0" // IR(42628, 23) + "ArbitraryFloatDivINTEL\0" // IR(42651, 23) + "ArbitraryFloatGTINTEL\0" // IR(42674, 22) + "ArbitraryFloatGEINTEL\0" // IR(42696, 22) + "ArbitraryFloatLTINTEL\0" // IR(42718, 22) + "ArbitraryFloatLEINTEL\0" // IR(42740, 22) + "ArbitraryFloatEQINTEL\0" // IR(42762, 22) + "ArbitraryFloatRecipINTEL\0" // IR(42784, 25) + "ArbitraryFloatRSqrtINTEL\0" // IR(42809, 25) + "ArbitraryFloatCbrtINTEL\0" // IR(42834, 24) + "ArbitraryFloatHypotINTEL\0" // IR(42858, 25) + "ArbitraryFloatSqrtINTEL\0" // IR(42883, 24) + "ArbitraryFloatLogINTEL\0" // IR(42907, 23) + "ArbitraryFloatLog2INTEL\0" // IR(42930, 24) + "ArbitraryFloatLog10INTEL\0" // IR(42954, 25) + "ArbitraryFloatLog1pINTEL\0" // IR(42979, 25) + "ArbitraryFloatExpINTEL\0" // IR(43004, 23) + "ArbitraryFloatExp2INTEL\0" // IR(43027, 24) + "ArbitraryFloatExp10INTEL\0" // IR(43051, 25) + "ArbitraryFloatExpm1INTEL\0" // IR(43076, 25) + "ArbitraryFloatSinINTEL\0" // IR(43101, 23) + "ArbitraryFloatCosINTEL\0" // IR(43124, 23) + "ArbitraryFloatSinCosINTEL\0" // IR(43147, 26) + "ArbitraryFloatSinPiINTEL\0" // IR(43173, 25) + "ArbitraryFloatCosPiINTEL\0" // IR(43198, 25) + "ArbitraryFloatASinINTEL\0" // IR(43223, 24) + "ArbitraryFloatASinPiINTEL\0" // IR(43247, 26) + "ArbitraryFloatACosINTEL\0" // IR(43273, 24) + "ArbitraryFloatACosPiINTEL\0" // IR(43297, 26) + "ArbitraryFloatATanINTEL\0" // IR(43323, 24) + "ArbitraryFloatATanPiINTEL\0" // IR(43347, 26) + "ArbitraryFloatATan2INTEL\0" // IR(43373, 25) + "ArbitraryFloatPowINTEL\0" // IR(43398, 23) + "ArbitraryFloatPowRINTEL\0" // IR(43421, 24) + "ArbitraryFloatPowNINTEL\0" // IR(43445, 24) + "LoopControlINTEL\0" // IR(43469, 17) + "AliasDomainDeclINTEL\0" // IR(43486, 21) + "AliasScopeDeclINTEL\0" // IR(43507, 20) + "AliasScopeListDeclINTEL\0" // IR(43527, 24) + "FixedSqrtINTEL\0" // IR(43551, 15) + "FixedRecipINTEL\0" // IR(43566, 16) + "FixedRsqrtINTEL\0" // IR(43582, 16) + "FixedSinINTEL\0" // IR(43598, 14) + "FixedCosINTEL\0" // IR(43612, 14) + "FixedSinCosINTEL\0" // IR(43626, 17) + "FixedSinPiINTEL\0" // IR(43643, 16) + "FixedCosPiINTEL\0" // IR(43659, 16) + "FixedSinCosPiINTEL\0" // IR(43675, 19) + "FixedLogINTEL\0" // IR(43694, 14) + "FixedExpINTEL\0" // IR(43708, 14) + "PtrCastToCrossWorkgroupINTEL\0" // IR(43722, 29) + "CrossWorkgroupCastToPtrINTEL\0" // IR(43751, 29) + "ReadPipeBlockingINTEL\0" // IR(43780, 22) + "WritePipeBlockingINTEL\0" // IR(43802, 23) + "RayQueryGetRayTMinKHR\0" // IR(43825, 22) + "RayQueryGetRayFlagsKHR\0" // IR(43847, 23) + "RayQueryGetIntersectionTKHR\0" // IR(43870, 28) + "RayQueryGetIntersectionInstanceCustomIndexKHR\0" // IR(43898, 46) + "RayQueryGetIntersectionInstanceIdKHR\0" // IR(43944, 37) + "RayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR\0" // IR(43981, 65) + "RayQueryGetIntersectionGeometryIndexKHR\0" // IR(44046, 40) + "RayQueryGetIntersectionPrimitiveIndexKHR\0" // IR(44086, 41) + "RayQueryGetIntersectionBarycentricsKHR\0" // IR(44127, 39) + "RayQueryGetIntersectionFrontFaceKHR\0" // IR(44166, 36) + "RayQueryGetIntersectionCandidateAABBOpaqueKHR\0" // IR(44202, 46) + "RayQueryGetIntersectionObjectRayDirectionKHR\0" // IR(44248, 45) + "RayQueryGetIntersectionObjectRayOriginKHR\0" // IR(44293, 42) + "RayQueryGetWorldRayDirectionKHR\0" // IR(44335, 32) + "RayQueryGetWorldRayOriginKHR\0" // IR(44367, 29) + "RayQueryGetIntersectionObjectToWorldKHR\0" // IR(44396, 40) + "RayQueryGetIntersectionWorldToObjectKHR\0" // IR(44436, 40) + "AtomicFAddEXT\0" // IR(44476, 14) + "TypeBufferSurfaceINTEL\0" // IR(44490, 23) + "TypeStructContinuedINTEL\0" // IR(44513, 25) + "ConstantCompositeContinuedINTEL\0" // IR(44538, 32) + "SpecConstantCompositeContinuedINTEL\0" // IR(44570, 36) + "CompositeConstructContinuedINTEL\0" // IR(44606, 33) + "ConvertFToBF16INTEL\0" // IR(44639, 20) + "ConvertBF16ToFINTEL\0" // IR(44659, 20) + "ControlBarrierArriveINTEL\0" // IR(44679, 26) + "ControlBarrierWaitINTEL\0" // IR(44705, 24) + "TaskSequenceCreateINTEL\0" // IR(44729, 24) + "TaskSequenceAsyncINTEL\0" // IR(44753, 23) + "TaskSequenceGetINTEL\0" // IR(44776, 21) + "TaskSequenceReleaseINTEL\0" // IR(44797, 25) + "TypeTaskSequenceINTEL\0" // IR(44822, 22) + "SubgroupBlockPrefetchINTEL\0" // IR(44844, 27) + "Subgroup2DBlockLoadINTEL\0" // IR(44871, 25) + "Subgroup2DBlockLoadTransformINTEL\0" // IR(44896, 34) + "Subgroup2DBlockLoadTransposeINTEL\0" // IR(44930, 34) + "Subgroup2DBlockPrefetchINTEL\0" // IR(44964, 29) + "Subgroup2DBlockStoreINTEL\0" // IR(44993, 26) + "SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS\0" // IR(45019, 62) + "BitwiseFunctionINTEL\0" // IR(45081, 21) + "ConditionalExtensionINTEL\0" // IR(45102, 26) + "ConditionalEntryPointINTEL\0" // IR(45128, 27) + "ConditionalCapabilityINTEL\0" // IR(45155, 27) + "SpecConstantTargetINTEL\0" // IR(45182, 24) + "SpecConstantArchitectureINTEL\0" // IR(45206, 30) + "SPV_OPERAND_TYPE_VARIABLE_CAPABILITY\0" // IR(45236, 37) + "SpecConstantCapabilitiesINTEL\0" // IR(45273, 30) + "ConditionalCopyObjectINTEL\0" // IR(45303, 27) + "GroupIMulKHR\0" // IR(45330, 13) + "GroupFMulKHR\0" // IR(45343, 13) + "GroupBitwiseAndKHR\0" // IR(45356, 19) + "GroupBitwiseOrKHR\0" // IR(45375, 18) + "GroupBitwiseXorKHR\0" // IR(45393, 19) + "GroupLogicalAndKHR\0" // IR(45412, 19) + "GroupLogicalOrKHR\0" // IR(45431, 18) + "GroupLogicalXorKHR\0" // IR(45449, 19) + "RoundFToTF32INTEL\0" // IR(45468, 18) + "MaskedGatherINTEL\0" // IR(45486, 18) + "MaskedScatterINTEL\0" // IR(45504, 19) + "ConvertHandleToImageINTEL\0" // IR(45523, 26) + "ConvertHandleToSamplerINTEL\0" // IR(45549, 28) + "ConvertHandleToSampledImageINTEL\0" // IR(45577, 33) + "DebugInfoNone\0" // IR(45610, 14) + "DebugCompilationUnit\0" // IR(45624, 21) + "SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING\0" // IR(45645, 52) + "DebugTypeBasic\0" // IR(45697, 15) + "SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS\0" // IR(45712, 34) + "DebugTypePointer\0" // IR(45746, 17) + "SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER\0" // IR(45763, 38) + "DebugTypeQualifier\0" // IR(45801, 19) + "DebugTypeArray\0" // IR(45820, 15) + "DebugTypeVector\0" // IR(45835, 16) + "DebugTypedef\0" // IR(45851, 13) + "DebugTypeFunction\0" // IR(45864, 18) + "DebugTypeEnum\0" // IR(45882, 14) + "SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE\0" // IR(45896, 38) + "DebugTypeComposite\0" // IR(45934, 19) + "DebugTypeMember\0" // IR(45953, 16) + "DebugTypeInheritance\0" // IR(45969, 21) + "DebugTypePtrToMember\0" // IR(45990, 21) + "DebugTypeTemplate\0" // IR(46011, 18) + "DebugTypeTemplateParameter\0" // IR(46029, 27) + "DebugTypeTemplateTemplateParameter\0" // IR(46056, 35) + "DebugTypeTemplateParameterPack\0" // IR(46091, 31) + "DebugGlobalVariable\0" // IR(46122, 20) + "DebugFunctionDeclaration\0" // IR(46142, 25) + "DebugFunction\0" // IR(46167, 14) + "DebugLexicalBlock\0" // IR(46181, 18) + "DebugLexicalBlockDiscriminator\0" // IR(46199, 31) + "DebugScope\0" // IR(46230, 11) + "DebugNoScope\0" // IR(46241, 13) + "DebugInlinedAt\0" // IR(46254, 15) + "SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER\0" // IR(46269, 42) + "DebugLocalVariable\0" // IR(46311, 19) + "DebugInlinedVariable\0" // IR(46330, 21) + "DebugDeclare\0" // IR(46351, 13) + "DebugValue\0" // IR(46364, 11) + "SPV_OPERAND_TYPE_DEBUG_OPERATION\0" // IR(46375, 33) + "DebugOperation\0" // IR(46408, 15) + "DebugExpression\0" // IR(46423, 16) + "DebugMacroDef\0" // IR(46439, 14) + "DebugMacroUndef\0" // IR(46453, 16) + "Round\0" // IR(46469, 6) + "RoundEven\0" // IR(46475, 10) + "Trunc\0" // IR(46485, 6) + "FAbs\0" // IR(46491, 5) + "SAbs\0" // IR(46496, 5) + "FSign\0" // IR(46501, 6) + "SSign\0" // IR(46507, 6) + "Floor\0" // IR(46513, 6) + "Ceil\0" // IR(46519, 5) + "Fract\0" // IR(46524, 6) + "Radians\0" // IR(46530, 8) + "Degrees\0" // IR(46538, 8) + "Sin\0" // IR(46546, 4) + "Cos\0" // IR(46550, 4) + "Tan\0" // IR(46554, 4) + "Asin\0" // IR(46558, 5) + "Acos\0" // IR(46563, 5) + "Atan\0" // IR(46568, 5) + "Sinh\0" // IR(46573, 5) + "Cosh\0" // IR(46578, 5) + "Tanh\0" // IR(46583, 5) + "Asinh\0" // IR(46588, 6) + "Acosh\0" // IR(46594, 6) + "Atanh\0" // IR(46600, 6) + "Atan2\0" // IR(46606, 6) + "Pow\0" // IR(46612, 4) + "Exp\0" // IR(46616, 4) + "Log\0" // IR(46620, 4) + "Exp2\0" // IR(46624, 5) + "Log2\0" // IR(46629, 5) + "Sqrt\0" // IR(46634, 5) + "InverseSqrt\0" // IR(46639, 12) + "Determinant\0" // IR(46651, 12) + "MatrixInverse\0" // IR(46663, 14) + "Modf\0" // IR(46677, 5) + "ModfStruct\0" // IR(46682, 11) + "FMin\0" // IR(46693, 5) + "UMin\0" // IR(46698, 5) + "SMin\0" // IR(46703, 5) + "FMax\0" // IR(46708, 5) + "UMax\0" // IR(46713, 5) + "SMax\0" // IR(46718, 5) + "FClamp\0" // IR(46723, 7) + "UClamp\0" // IR(46730, 7) + "SClamp\0" // IR(46737, 7) + "FMix\0" // IR(46744, 5) + "IMix\0" // IR(46749, 5) + "Step\0" // IR(46754, 5) + "SmoothStep\0" // IR(46759, 11) + "Fma\0" // IR(46770, 4) + "Frexp\0" // IR(46774, 6) + "FrexpStruct\0" // IR(46780, 12) + "Ldexp\0" // IR(46792, 6) + "PackSnorm4x8\0" // IR(46798, 13) + "PackUnorm4x8\0" // IR(46811, 13) + "PackSnorm2x16\0" // IR(46824, 14) + "PackUnorm2x16\0" // IR(46838, 14) + "PackHalf2x16\0" // IR(46852, 13) + "PackDouble2x32\0" // IR(46865, 15) + "UnpackSnorm2x16\0" // IR(46880, 16) + "UnpackUnorm2x16\0" // IR(46896, 16) + "UnpackHalf2x16\0" // IR(46912, 15) + "UnpackSnorm4x8\0" // IR(46927, 15) + "UnpackUnorm4x8\0" // IR(46942, 15) + "UnpackDouble2x32\0" // IR(46957, 17) + "Length\0" // IR(46974, 7) + "Distance\0" // IR(46981, 9) + "Cross\0" // IR(46990, 6) + "Normalize\0" // IR(46996, 10) + "FaceForward\0" // IR(47006, 12) + "Reflect\0" // IR(47018, 8) + "Refract\0" // IR(47026, 8) + "FindILsb\0" // IR(47034, 9) + "FindSMsb\0" // IR(47043, 9) + "FindUMsb\0" // IR(47052, 9) + "InterpolateAtCentroid\0" // IR(47061, 22) + "InterpolateAtSample\0" // IR(47083, 20) + "InterpolateAtOffset\0" // IR(47103, 20) + "NMin\0" // IR(47123, 5) + "NMax\0" // IR(47128, 5) + "NClamp\0" // IR(47133, 7) + "ArgumentInfo\0" // IR(47140, 13) + "ArgumentStorageBuffer\0" // IR(47153, 22) + "ArgumentUniform\0" // IR(47175, 16) + "ArgumentPodStorageBuffer\0" // IR(47191, 25) + "ArgumentPodUniform\0" // IR(47216, 19) + "ArgumentPodPushConstant\0" // IR(47235, 24) + "ArgumentSampledImage\0" // IR(47259, 21) + "ArgumentStorageImage\0" // IR(47280, 21) + "ArgumentSampler\0" // IR(47301, 16) + "ArgumentWorkgroup\0" // IR(47317, 18) + "SpecConstantWorkgroupSize\0" // IR(47335, 26) + "SpecConstantGlobalOffset\0" // IR(47361, 25) + "SpecConstantWorkDim\0" // IR(47386, 20) + "PushConstantGlobalOffset\0" // IR(47406, 25) + "PushConstantEnqueuedLocalSize\0" // IR(47431, 30) + "PushConstantGlobalSize\0" // IR(47461, 23) + "PushConstantRegionOffset\0" // IR(47484, 25) + "PushConstantNumWorkgroups\0" // IR(47509, 26) + "PushConstantRegionGroupOffset\0" // IR(47535, 30) + "ConstantDataStorageBuffer\0" // IR(47565, 26) + "ConstantDataUniform\0" // IR(47591, 20) + "PropertyRequiredWorkgroupSize\0" // IR(47611, 30) + "SpecConstantSubgroupMaxSize\0" // IR(47641, 28) + "ArgumentPointerPushConstant\0" // IR(47669, 28) + "ArgumentPointerUniform\0" // IR(47697, 23) + "ProgramScopeVariablesStorageBuffer\0" // IR(47720, 35) + "ProgramScopeVariablePointerRelocation\0" // IR(47755, 38) + "ImageArgumentInfoChannelOrderPushConstant\0" // IR(47793, 42) + "ImageArgumentInfoChannelDataTypePushConstant\0" // IR(47835, 45) + "ImageArgumentInfoChannelOrderUniform\0" // IR(47880, 37) + "ImageArgumentInfoChannelDataTypeUniform\0" // IR(47917, 40) + "ArgumentStorageTexelBuffer\0" // IR(47957, 27) + "ArgumentUniformTexelBuffer\0" // IR(47984, 27) + "ConstantDataPointerPushConstant\0" // IR(48011, 32) + "ProgramScopeVariablePointerPushConstant\0" // IR(48043, 40) + "PrintfInfo\0" // IR(48083, 11) + "PrintfBufferStorageBuffer\0" // IR(48094, 26) + "PrintfBufferPointerPushConstant\0" // IR(48120, 32) + "NormalizedSamplerMaskPushConstant\0" // IR(48152, 34) + "WorkgroupVariableSize\0" // IR(48186, 22) + "DebugImportedEntity\0" // IR(48208, 20) + "DebugSource\0" // IR(48228, 12) + "DebugFunctionDefinition\0" // IR(48240, 24) + "DebugSourceContinued\0" // IR(48264, 21) + "DebugLine\0" // IR(48285, 10) + "DebugNoLine\0" // IR(48295, 12) + "DebugBuildIdentifier\0" // IR(48307, 21) + "DebugStoragePath\0" // IR(48328, 17) + "DebugEntryPoint\0" // IR(48345, 16) + "DebugTypeMatrix\0" // IR(48361, 16) + "Configuration\0" // IR(48377, 14) + "StartCounter\0" // IR(48391, 13) + "StopCounter\0" // IR(48404, 12) + "PushConstants\0" // IR(48416, 14) + "SpecializationMapEntry\0" // IR(48430, 23) + "DescriptorSetBuffer\0" // IR(48453, 20) + "DescriptorSetImage\0" // IR(48473, 19) + "DescriptorSetSampler\0" // IR(48492, 21) + "SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING\0" // IR(48513, 63) + "SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS\0" // IR(48576, 45) + "SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER\0" // IR(48621, 49) + "SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE\0" // IR(48670, 49) + "SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION\0" // IR(48719, 44) + "SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY\0" // IR(48763, 50) + "DebugModuleINTEL\0" // IR(48813, 17) + "acos\0" // IR(48830, 5) + "acosh\0" // IR(48835, 6) + "acospi\0" // IR(48841, 7) + "asin\0" // IR(48848, 5) + "asinh\0" // IR(48853, 6) + "asinpi\0" // IR(48859, 7) + "atan\0" // IR(48866, 5) + "atan2\0" // IR(48871, 6) + "atanh\0" // IR(48877, 6) + "atanpi\0" // IR(48883, 7) + "atan2pi\0" // IR(48890, 8) + "cbrt\0" // IR(48898, 5) + "ceil\0" // IR(48903, 5) + "copysign\0" // IR(48908, 9) + "cos\0" // IR(48917, 4) + "cosh\0" // IR(48921, 5) + "cospi\0" // IR(48926, 6) + "erfc\0" // IR(48932, 5) + "erf\0" // IR(48937, 4) + "exp\0" // IR(48941, 4) + "exp2\0" // IR(48945, 5) + "exp10\0" // IR(48950, 6) + "expm1\0" // IR(48956, 6) + "fabs\0" // IR(48962, 5) + "fdim\0" // IR(48967, 5) + "floor\0" // IR(48972, 6) + "fma\0" // IR(48978, 4) + "fmax\0" // IR(48982, 5) + "fmin\0" // IR(48987, 5) + "fmod\0" // IR(48992, 5) + "fract\0" // IR(48997, 6) + "frexp\0" // IR(49003, 6) + "hypot\0" // IR(49009, 6) + "ilogb\0" // IR(49015, 6) + "ldexp\0" // IR(49021, 6) + "lgamma\0" // IR(49027, 7) + "lgamma_r\0" // IR(49034, 9) + "log\0" // IR(49043, 4) + "log2\0" // IR(49047, 5) + "log10\0" // IR(49052, 6) + "log1p\0" // IR(49058, 6) + "logb\0" // IR(49064, 5) + "mad\0" // IR(49069, 4) + "maxmag\0" // IR(49073, 7) + "minmag\0" // IR(49080, 7) + "modf\0" // IR(49087, 5) + "nan\0" // IR(49092, 4) + "nextafter\0" // IR(49096, 10) + "pow\0" // IR(49106, 4) + "pown\0" // IR(49110, 5) + "powr\0" // IR(49115, 5) + "remainder\0" // IR(49120, 10) + "remquo\0" // IR(49130, 7) + "rint\0" // IR(49137, 5) + "rootn\0" // IR(49142, 6) + "round\0" // IR(49148, 6) + "rsqrt\0" // IR(49154, 6) + "sin\0" // IR(49160, 4) + "sincos\0" // IR(49164, 7) + "sinh\0" // IR(49171, 5) + "sinpi\0" // IR(49176, 6) + "sqrt\0" // IR(49182, 5) + "tan\0" // IR(49187, 4) + "tanh\0" // IR(49191, 5) + "tanpi\0" // IR(49196, 6) + "tgamma\0" // IR(49202, 7) + "trunc\0" // IR(49209, 6) + "half_cos\0" // IR(49215, 9) + "half_divide\0" // IR(49224, 12) + "half_exp\0" // IR(49236, 9) + "half_exp2\0" // IR(49245, 10) + "half_exp10\0" // IR(49255, 11) + "half_log\0" // IR(49266, 9) + "half_log2\0" // IR(49275, 10) + "half_log10\0" // IR(49285, 11) + "half_powr\0" // IR(49296, 10) + "half_recip\0" // IR(49306, 11) + "half_rsqrt\0" // IR(49317, 11) + "half_sin\0" // IR(49328, 9) + "half_sqrt\0" // IR(49337, 10) + "half_tan\0" // IR(49347, 9) + "native_cos\0" // IR(49356, 11) + "native_divide\0" // IR(49367, 14) + "native_exp\0" // IR(49381, 11) + "native_exp2\0" // IR(49392, 12) + "native_exp10\0" // IR(49404, 13) + "native_log\0" // IR(49417, 11) + "native_log2\0" // IR(49428, 12) + "native_log10\0" // IR(49440, 13) + "native_powr\0" // IR(49453, 12) + "native_recip\0" // IR(49465, 13) + "native_rsqrt\0" // IR(49478, 13) + "native_sin\0" // IR(49491, 11) + "native_sqrt\0" // IR(49502, 12) + "native_tan\0" // IR(49514, 11) + "fclamp\0" // IR(49525, 7) + "degrees\0" // IR(49532, 8) + "fmax_common\0" // IR(49540, 12) + "fmin_common\0" // IR(49552, 12) + "mix\0" // IR(49564, 4) + "radians\0" // IR(49568, 8) + "step\0" // IR(49576, 5) + "smoothstep\0" // IR(49581, 11) + "sign\0" // IR(49592, 5) + "cross\0" // IR(49597, 6) + "distance\0" // IR(49603, 9) + "length\0" // IR(49612, 7) + "normalize\0" // IR(49619, 10) + "fast_distance\0" // IR(49629, 14) + "fast_length\0" // IR(49643, 12) + "fast_normalize\0" // IR(49655, 15) + "s_abs\0" // IR(49670, 6) + "s_abs_diff\0" // IR(49676, 11) + "s_add_sat\0" // IR(49687, 10) + "u_add_sat\0" // IR(49697, 10) + "s_hadd\0" // IR(49707, 7) + "u_hadd\0" // IR(49714, 7) + "s_rhadd\0" // IR(49721, 8) + "u_rhadd\0" // IR(49729, 8) + "s_clamp\0" // IR(49737, 8) + "u_clamp\0" // IR(49745, 8) + "clz\0" // IR(49753, 4) + "ctz\0" // IR(49757, 4) + "s_mad_hi\0" // IR(49761, 9) + "u_mad_sat\0" // IR(49770, 10) + "s_mad_sat\0" // IR(49780, 10) + "s_max\0" // IR(49790, 6) + "u_max\0" // IR(49796, 6) + "s_min\0" // IR(49802, 6) + "u_min\0" // IR(49808, 6) + "s_mul_hi\0" // IR(49814, 9) + "rotate\0" // IR(49823, 7) + "s_sub_sat\0" // IR(49830, 10) + "u_sub_sat\0" // IR(49840, 10) + "u_upsample\0" // IR(49850, 11) + "s_upsample\0" // IR(49861, 11) + "popcount\0" // IR(49872, 9) + "s_mad24\0" // IR(49881, 8) + "u_mad24\0" // IR(49889, 8) + "s_mul24\0" // IR(49897, 8) + "u_mul24\0" // IR(49905, 8) + "vloadn\0" // IR(49913, 7) + "vstoren\0" // IR(49920, 8) + "vload_half\0" // IR(49928, 11) + "vload_halfn\0" // IR(49939, 12) + "vstore_half\0" // IR(49951, 12) + "vstore_half_r\0" // IR(49963, 14) + "vstore_halfn\0" // IR(49977, 13) + "vstore_halfn_r\0" // IR(49990, 15) + "vloada_halfn\0" // IR(50005, 13) + "vstorea_halfn\0" // IR(50018, 14) + "vstorea_halfn_r\0" // IR(50032, 16) + "shuffle\0" // IR(50048, 8) + "shuffle2\0" // IR(50056, 9) + "printf\0" // IR(50065, 7) + "prefetch\0" // IR(50072, 9) + "bitselect\0" // IR(50081, 10) + "select\0" // IR(50091, 7) + "u_abs\0" // IR(50098, 6) + "u_abs_diff\0" // IR(50104, 11) + "u_mul_hi\0" // IR(50115, 9) + "u_mad_hi\0" // IR(50124, 9) + "CubeFaceIndexAMD\0" // IR(50133, 17) + "CubeFaceCoordAMD\0" // IR(50150, 17) + "TimeAMD\0" // IR(50167, 8) + "SwizzleInvocationsAMD\0" // IR(50175, 22) + "SwizzleInvocationsMaskedAMD\0" // IR(50197, 28) + "WriteInvocationAMD\0" // IR(50225, 19) + "MbcntAMD\0" // IR(50244, 9) + "InterpolateAtVertexAMD\0" // IR(50253, 23) + "FMin3AMD\0" // IR(50276, 9) + "UMin3AMD\0" // IR(50285, 9) + "SMin3AMD\0" // IR(50294, 9) + "FMax3AMD\0" // IR(50303, 9) + "UMax3AMD\0" // IR(50312, 9) + "SMax3AMD\0" // IR(50321, 9) + "FMid3AMD\0" // IR(50330, 9) + "UMid3AMD\0" // IR(50339, 9) + "SMid3AMD\0" // IR(50348, 9) ; // Array of IndexRanges, where each represents a string by referencing @@ -8064,109 +8163,110 @@ static const char kStrings[] = // This table is referenced by an IndexRange elsewhere, i.e. by the 'aliases' // field of an instruction or operand description. static const IndexRange kAliasSpans[] = { - IR(4640, 27), // 0 PhysicalStorageBuffer64EXT - IR(5551, 18), // 1 SubgroupEqMaskKHR - IR(5606, 18), // 2 SubgroupGeMaskKHR - IR(5639, 18), // 3 SubgroupGtMaskKHR - IR(5672, 18), // 4 SubgroupLeMaskKHR - IR(5705, 18), // 5 SubgroupLtMaskKHR - IR(6563, 12), // 6 BaryCoordNV - IR(6618, 19), // 7 BaryCoordNoPerspNV - IR(6649, 15), // 8 FragmentSizeNV - IR(6706, 22), // 9 InvocationsPerPixelNV - IR(6834, 11), // 10 LaunchIdNV - IR(6859, 13), // 11 LaunchSizeNV - IR(6890, 17), // 12 WorldRayOriginNV - IR(6928, 20), // 13 WorldRayDirectionNV - IR(6967, 18), // 14 ObjectRayOriginNV - IR(7007, 21), // 15 ObjectRayDirectionNV - IR(7039, 10), // 16 RayTminNV - IR(7060, 10), // 17 RayTmaxNV - IR(7093, 22), // 18 InstanceCustomIndexNV - IR(7132, 16), // 19 ObjectToWorldNV - IR(7165, 16), // 20 WorldToObjectNV - IR(7199, 10), // 21 HitKindNV - IR(7430, 19), // 22 IncomingRayFlagsNV - IR(9176, 28), // 23 StorageUniformBufferBlock16 - IR(9239, 17), // 24 StorageUniform16 - IR(10043, 27), // 25 ShaderViewportIndexLayerNV - IR(10087, 22), // 26 FragmentBarycentricNV - IR(10140, 30), // 27 ComputeDerivativeGroupQuadsNV - IR(10170, 14), // 28 ShadingRateNV - IR(10230, 20), // 29 ShaderNonUniformEXT - IR(10273, 26), // 30 RuntimeDescriptorArrayEXT - IR(10335, 39), // 31 InputAttachmentArrayDynamicIndexingEXT - IR(10413, 42), // 32 UniformTexelBufferArrayDynamicIndexingEXT - IR(10494, 42), // 33 StorageTexelBufferArrayDynamicIndexingEXT - IR(10573, 40), // 34 UniformBufferArrayNonUniformIndexingEXT - IR(10649, 39), // 35 SampledImageArrayNonUniformIndexingEXT - IR(10725, 40), // 36 StorageBufferArrayNonUniformIndexingEXT - IR(10801, 39), // 37 StorageImageArrayNonUniformIndexingEXT - IR(10879, 42), // 38 InputAttachmentArrayNonUniformIndexingEXT - IR(10963, 45), // 39 UniformTexelBufferArrayNonUniformIndexingEXT - IR(11050, 45), // 40 StorageTexelBufferArrayNonUniformIndexingEXT - IR(11113, 21), // 41 VulkanMemoryModelKHR - IR(11163, 32), // 42 VulkanMemoryModelDeviceScopeKHR - IR(11195, 34), // 43 PhysicalStorageBufferAddressesEXT - IR(11261, 31), // 44 ComputeDerivativeGroupLinearNV - IR(11465, 28), // 45 DemoteToHelperInvocationEXT - IR(12935, 22), // 46 DotProductInputAllKHR - IR(12979, 25), // 47 DotProductInput4x8BitKHR - IR(13032, 31), // 48 DotProductInput4x8BitPackedKHR - IR(13074, 14), // 49 DotProductKHR - IR(13239, 13), // 50 OptNoneINTEL - IR(16235, 15), // 51 PerPrimitiveNV - IR(16283, 12), // 52 PerVertexNV - IR(16306, 14), // 53 NonUniformEXT - IR(16336, 19), // 54 RestrictPointerEXT - IR(16370, 18), // 55 AliasedPointerEXT - IR(16680, 24), // 56 HlslCounterBufferGOOGLE - IR(16717, 19), // 57 HlslSemanticGOOGLE - IR(19391, 14), // 58 OutputLinesNV - IR(19425, 19), // 59 OutputPrimitivesNV - IR(19468, 23), // 60 DerivativeGroupQuadsNV - IR(19516, 24), // 61 DerivativeGroupLinearNV - IR(19559, 18), // 62 OutputTrianglesNV - IR(20307, 16), // 63 RayGenerationNV - IR(20339, 15), // 64 IntersectionNV - IR(20364, 9), // 65 AnyHitNV - IR(20387, 13), // 66 ClosestHitNV - IR(20408, 7), // 67 MissNV - IR(20427, 11), // 68 CallableNV - IR(20572, 23), // 69 AllowContractFastINTEL - IR(20608, 18), // 70 AllowReassocINTEL - IR(21062, 22), // 71 MakeTexelAvailableKHR - IR(21101, 20), // 72 MakeTexelVisibleKHR - IR(21137, 19), // 73 NonPrivateTexelKHR - IR(21170, 17), // 74 VolatileTexelKHR - IR(22547, 24), // 75 MakePointerAvailableKHR - IR(22590, 22), // 76 MakePointerVisibleKHR - IR(22630, 21), // 77 NonPrivatePointerKHR - IR(22717, 10), // 78 VulkanKHR - IR(14007, 5), // 79 None - IR(22900, 16), // 80 OutputMemoryKHR - IR(22930, 17), // 81 MakeAvailableKHR - IR(22959, 15), // 82 MakeVisibleKHR - IR(23035, 28), // 83 PackedVectorFormat4x8BitKHR - IR(23350, 24), // 84 SkipBuiltinPrimitivesNV - IR(24090, 15), // 85 QueueFamilyKHR - IR(24461, 15), // 86 CallableDataNV - IR(24500, 23), // 87 IncomingCallableDataNV - IR(24537, 13), // 88 RayPayloadNV - IR(24566, 15), // 89 HitAttributeNV - IR(24603, 21), // 90 IncomingRayPayloadNV - IR(24646, 21), // 91 ShaderRecordBufferNV - IR(24689, 25), // 92 PhysicalStorageBufferEXT - IR(31905, 8), // 93 SDotKHR - IR(31918, 8), // 94 UDotKHR - IR(31932, 9), // 95 SUDotKHR - IR(31952, 14), // 96 SDotAccSatKHR - IR(31977, 14), // 97 UDotAccSatKHR - IR(32003, 15), // 98 SUDotAccSatKHR - IR(34488, 21), // 99 ReportIntersectionNV - IR(34663, 28), // 100 TypeAccelerationStructureNV - IR(36712, 21), // 101 DecorateStringGOOGLE - IR(36754, 27), // 102 MemberDecorateStringGOOGLE + IR(4733, 27), // 0 PhysicalStorageBuffer64EXT + IR(5644, 18), // 1 SubgroupEqMaskKHR + IR(5699, 18), // 2 SubgroupGeMaskKHR + IR(5732, 18), // 3 SubgroupGtMaskKHR + IR(5765, 18), // 4 SubgroupLeMaskKHR + IR(5798, 18), // 5 SubgroupLtMaskKHR + IR(6656, 12), // 6 BaryCoordNV + IR(6711, 19), // 7 BaryCoordNoPerspNV + IR(6742, 15), // 8 FragmentSizeNV + IR(6799, 22), // 9 InvocationsPerPixelNV + IR(6927, 11), // 10 LaunchIdNV + IR(6952, 13), // 11 LaunchSizeNV + IR(6983, 17), // 12 WorldRayOriginNV + IR(7021, 20), // 13 WorldRayDirectionNV + IR(7060, 18), // 14 ObjectRayOriginNV + IR(7100, 21), // 15 ObjectRayDirectionNV + IR(7132, 10), // 16 RayTminNV + IR(7153, 10), // 17 RayTmaxNV + IR(7186, 22), // 18 InstanceCustomIndexNV + IR(7225, 16), // 19 ObjectToWorldNV + IR(7258, 16), // 20 WorldToObjectNV + IR(7292, 10), // 21 HitKindNV + IR(7523, 19), // 22 IncomingRayFlagsNV + IR(9299, 28), // 23 StorageUniformBufferBlock16 + IR(9362, 17), // 24 StorageUniform16 + IR(10177, 27), // 25 ShaderViewportIndexLayerNV + IR(10221, 22), // 26 FragmentBarycentricNV + IR(10274, 30), // 27 ComputeDerivativeGroupQuadsNV + IR(10304, 14), // 28 ShadingRateNV + IR(10364, 20), // 29 ShaderNonUniformEXT + IR(10407, 26), // 30 RuntimeDescriptorArrayEXT + IR(10469, 39), // 31 InputAttachmentArrayDynamicIndexingEXT + IR(10547, 42), // 32 UniformTexelBufferArrayDynamicIndexingEXT + IR(10628, 42), // 33 StorageTexelBufferArrayDynamicIndexingEXT + IR(10707, 40), // 34 UniformBufferArrayNonUniformIndexingEXT + IR(10783, 39), // 35 SampledImageArrayNonUniformIndexingEXT + IR(10859, 40), // 36 StorageBufferArrayNonUniformIndexingEXT + IR(10935, 39), // 37 StorageImageArrayNonUniformIndexingEXT + IR(11013, 42), // 38 InputAttachmentArrayNonUniformIndexingEXT + IR(11097, 45), // 39 UniformTexelBufferArrayNonUniformIndexingEXT + IR(11184, 45), // 40 StorageTexelBufferArrayNonUniformIndexingEXT + IR(11247, 21), // 41 VulkanMemoryModelKHR + IR(11297, 32), // 42 VulkanMemoryModelDeviceScopeKHR + IR(11329, 34), // 43 PhysicalStorageBufferAddressesEXT + IR(11395, 31), // 44 ComputeDerivativeGroupLinearNV + IR(11599, 28), // 45 DemoteToHelperInvocationEXT + IR(13069, 22), // 46 DotProductInputAllKHR + IR(13113, 25), // 47 DotProductInput4x8BitKHR + IR(13166, 31), // 48 DotProductInput4x8BitPackedKHR + IR(13208, 14), // 49 DotProductKHR + IR(13380, 13), // 50 OptNoneINTEL + IR(16451, 15), // 51 PerPrimitiveNV + IR(16499, 12), // 52 PerVertexNV + IR(16522, 14), // 53 NonUniformEXT + IR(16552, 19), // 54 RestrictPointerEXT + IR(16586, 18), // 55 AliasedPointerEXT + IR(16896, 24), // 56 HlslCounterBufferGOOGLE + IR(16933, 19), // 57 HlslSemanticGOOGLE + IR(19624, 14), // 58 OutputLinesNV + IR(19658, 19), // 59 OutputPrimitivesNV + IR(19701, 23), // 60 DerivativeGroupQuadsNV + IR(19749, 24), // 61 DerivativeGroupLinearNV + IR(19792, 18), // 62 OutputTrianglesNV + IR(20540, 16), // 63 RayGenerationNV + IR(20572, 15), // 64 IntersectionNV + IR(20597, 9), // 65 AnyHitNV + IR(20620, 13), // 66 ClosestHitNV + IR(20641, 7), // 67 MissNV + IR(20660, 11), // 68 CallableNV + IR(20805, 23), // 69 AllowContractFastINTEL + IR(20841, 18), // 70 AllowReassocINTEL + IR(21295, 22), // 71 MakeTexelAvailableKHR + IR(21334, 20), // 72 MakeTexelVisibleKHR + IR(21370, 19), // 73 NonPrivateTexelKHR + IR(21403, 17), // 74 VolatileTexelKHR + IR(22780, 24), // 75 MakePointerAvailableKHR + IR(22823, 22), // 76 MakePointerVisibleKHR + IR(22863, 21), // 77 NonPrivatePointerKHR + IR(22950, 10), // 78 VulkanKHR + IR(14223, 5), // 79 None + IR(23133, 16), // 80 OutputMemoryKHR + IR(23163, 17), // 81 MakeAvailableKHR + IR(23192, 15), // 82 MakeVisibleKHR + IR(23268, 28), // 83 PackedVectorFormat4x8BitKHR + IR(23583, 24), // 84 SkipBuiltinPrimitivesNV + IR(24323, 15), // 85 QueueFamilyKHR + IR(24694, 15), // 86 CallableDataNV + IR(24733, 23), // 87 IncomingCallableDataNV + IR(24770, 13), // 88 RayPayloadNV + IR(24799, 15), // 89 HitAttributeNV + IR(24836, 21), // 90 IncomingRayPayloadNV + IR(24879, 21), // 91 ShaderRecordBufferNV + IR(24922, 25), // 92 PhysicalStorageBufferEXT + IR(32263, 8), // 93 SDotKHR + IR(32276, 8), // 94 UDotKHR + IR(32290, 9), // 95 SUDotKHR + IR(32310, 14), // 96 SDotAccSatKHR + IR(32335, 14), // 97 UDotAccSatKHR + IR(32361, 15), // 98 SUDotAccSatKHR + IR(34941, 21), // 99 ReportIntersectionNV + IR(35116, 28), // 100 TypeAccelerationStructureNV + IR(35197, 23), // 101 RayQueryGetClusterIdNV + IR(37200, 21), // 102 DecorateStringGOOGLE + IR(37242, 27), // 103 MemberDecorateStringGOOGLE }; // Array of capabilities, referenced by IndexRanges elsewhere. @@ -8249,233 +8349,241 @@ static const spv::Capability kCapabilitySpans[] = { spv::Capability::DeviceEnqueue, // 74 spv::Capability::Pipes, // 75 spv::Capability::GroupNonUniform, // 76 - spv::Capability::WorkgroupMemoryExplicitLayoutKHR, // 77 - spv::Capability::StorageBuffer16BitAccess, // 78 - spv::Capability::VariablePointersStorageBuffer, // 79 - spv::Capability::AtomicStorage, // 80 - spv::Capability::StorageBuffer8BitAccess, // 81 - spv::Capability::RayQueryKHR, // 82 - spv::Capability::RayTracingKHR, // 83 - spv::Capability::Int4TypeINTEL, // 84 - spv::Capability::CooperativeMatrixKHR, // 85 - spv::Capability::BFloat16TypeKHR, // 86 - spv::Capability::BFloat16TypeKHR, // 87 + spv::Capability::Float8EXT, // 77 + spv::Capability::CooperativeMatrixKHR, // 78 + spv::Capability::WorkgroupMemoryExplicitLayoutKHR, // 79 + spv::Capability::StorageBuffer16BitAccess, // 80 + spv::Capability::VariablePointersStorageBuffer, // 81 + spv::Capability::AtomicStorage, // 82 + spv::Capability::StorageBuffer8BitAccess, // 83 + spv::Capability::RayQueryKHR, // 84 + spv::Capability::RayTracingKHR, // 85 + spv::Capability::CooperativeMatrixKHR, // 86 + spv::Capability::Int4TypeINTEL, // 87 spv::Capability::CooperativeMatrixKHR, // 88 - spv::Capability::MultiViewport, // 89 - spv::Capability::ShaderViewportIndexLayerEXT, // 90 - spv::Capability::ShaderViewportMaskNV, // 91 - spv::Capability::InputAttachment, // 92 - spv::Capability::ImageBuffer, // 93 - spv::Capability::ShaderNonUniform, // 94 + spv::Capability::BFloat16TypeKHR, // 89 + spv::Capability::BFloat16TypeKHR, // 90 + spv::Capability::CooperativeMatrixKHR, // 91 + spv::Capability::MultiViewport, // 92 + spv::Capability::ShaderViewportIndexLayerEXT, // 93 + spv::Capability::ShaderViewportMaskNV, // 94 spv::Capability::InputAttachment, // 95 - spv::Capability::ShaderNonUniform, // 96 - spv::Capability::SampledBuffer, // 97 - spv::Capability::ShaderNonUniform, // 98 - spv::Capability::ImageBuffer, // 99 - spv::Capability::ShaderNonUniform, // 100 - spv::Capability::VectorAnyINTEL, // 101 - spv::Capability::Int8, // 102 - spv::Capability::FPGAClusterAttributesINTEL, // 103 - spv::Capability::FPGAKernelAttributesINTEL, // 104 - spv::Capability::Subgroup2DBlockIOINTEL, // 105 - spv::Capability::Shader, // 106 - spv::Capability::Kernel, // 107 - spv::Capability::Shader, // 108 - spv::Capability::UniformDecoration, // 109 - spv::Capability::GeometryStreams, // 110 - spv::Capability::TransformFeedback, // 111 - spv::Capability::Kernel, // 112 - spv::Capability::FloatControls2, // 113 - spv::Capability::Linkage, // 114 - spv::Capability::Float8EXT, // 115 - spv::Capability::SampleMaskOverrideCoverageNV, // 116 - spv::Capability::GeometryShaderPassthroughNV, // 117 - spv::Capability::MeshShadingNV, // 118 - spv::Capability::MeshShadingEXT, // 119 - spv::Capability::ShaderInvocationReorderNV, // 120 - spv::Capability::BindlessTextureNV, // 121 - spv::Capability::VectorComputeINTEL, // 122 - spv::Capability::IndirectReferencesINTEL, // 123 - spv::Capability::AsmINTEL, // 124 - spv::Capability::FunctionFloatControlINTEL, // 125 - spv::Capability::FPGAMemoryAttributesINTEL, // 126 - spv::Capability::FPGAMemoryAccessesINTEL, // 127 - spv::Capability::LoopFuseINTEL, // 128 - spv::Capability::FPGADSPControlINTEL, // 129 - spv::Capability::MemoryAccessAliasingINTEL, // 130 - spv::Capability::FPGAInvocationPipeliningAttributesINTEL, // 131 - spv::Capability::FPGABufferLocationINTEL, // 132 - spv::Capability::IOPipesINTEL, // 133 - spv::Capability::FPGAClusterAttributesV2INTEL, // 134 - spv::Capability::FPMaxErrorINTEL, // 135 - spv::Capability::FPGALatencyControlINTEL, // 136 - spv::Capability::FPGAArgumentInterfacesINTEL, // 137 - spv::Capability::GlobalVariableHostAccessINTEL, // 138 - spv::Capability::GlobalVariableFPGADecorationsINTEL, // 139 - spv::Capability::CacheControlsINTEL, // 140 - spv::Capability::TileImageColorReadAccessEXT, // 141 - spv::Capability::Geometry, // 142 - spv::Capability::Tessellation, // 143 - spv::Capability::MeshShadingNV, // 144 - spv::Capability::MeshShadingEXT, // 145 - spv::Capability::Geometry, // 146 - spv::Capability::MeshShadingNV, // 147 - spv::Capability::MeshShadingEXT, // 148 - spv::Capability::SubgroupDispatch, // 149 - spv::Capability::TileImageDepthReadAccessEXT, // 150 - spv::Capability::TileImageStencilReadAccessEXT, // 151 - spv::Capability::SampleMaskPostDepthCoverage, // 152 - spv::Capability::DenormPreserve, // 153 - spv::Capability::DenormFlushToZero, // 154 - spv::Capability::SignedZeroInfNanPreserve, // 155 - spv::Capability::RoundingModeRTE, // 156 - spv::Capability::RoundingModeRTZ, // 157 - spv::Capability::QuadControlKHR, // 158 - spv::Capability::ComputeDerivativeGroupQuadsNV, // 159 - spv::Capability::ComputeDerivativeGroupQuadsKHR, // 160 - spv::Capability::ComputeDerivativeGroupLinearNV, // 161 - spv::Capability::ComputeDerivativeGroupLinearKHR, // 162 - spv::Capability::FragmentShaderPixelInterlockEXT, // 163 - spv::Capability::FragmentShaderSampleInterlockEXT, // 164 - spv::Capability::FragmentShaderShadingRateInterlockEXT, // 165 - spv::Capability::RoundToInfinityINTEL, // 166 - spv::Capability::KernelAttributesINTEL, // 167 - spv::Capability::FloatControls2, // 168 - spv::Capability::FPGAKernelAttributesv2INTEL, // 169 - spv::Capability::RegisterLimitsINTEL, // 170 - spv::Capability::FloatControls2, // 171 - spv::Capability::FPFastMathModeINTEL, // 172 - spv::Capability::OptNoneEXT, // 173 - spv::Capability::RuntimeAlignedAttributeINTEL, // 174 - spv::Capability::Kernel, // 175 - spv::Capability::GroupNonUniformArithmetic, // 176 - spv::Capability::GroupNonUniformBallot, // 177 - spv::Capability::GroupNonUniformClustered, // 178 - spv::Capability::GroupNonUniformPartitionedNV, // 179 - spv::Capability::ImageGatherExtended, // 180 - spv::Capability::MinLod, // 181 - spv::Capability::VulkanMemoryModel, // 182 - spv::Capability::FPGALoopControlsINTEL, // 183 - spv::Capability::ArbitraryPrecisionFixedPointINTEL, // 184 - spv::Capability::RawAccessChainsNV, // 185 - spv::Capability::RayTraversalPrimitiveCullingKHR, // 186 - spv::Capability::RayTracingOpacityMicromapEXT, // 187 - spv::Capability::RayQueryKHR, // 188 - spv::Capability::StorageImageExtendedFormats, // 189 - spv::Capability::Int64ImageEXT, // 190 - spv::Capability::Shader, // 191 - spv::Capability::VectorComputeINTEL, // 192 - spv::Capability::GenericPointer, // 193 - spv::Capability::FunctionPointersINTEL, // 194 - spv::Capability::USMStorageClassesINTEL, // 195 - spv::Capability::CooperativeMatrixTensorAddressingNV, // 196 - spv::Capability::CooperativeMatrixBlockLoadsNV, // 197 - spv::Capability::TensorsARM, // 198 - spv::Capability::Addresses, // 199 - spv::Capability::PhysicalStorageBufferAddresses, // 200 - spv::Capability::LiteralSampler, // 201 - spv::Capability::Addresses, // 202 - spv::Capability::UntypedPointersKHR, // 203 - spv::Capability::Addresses, // 204 - spv::Capability::VariablePointers, // 205 - spv::Capability::VariablePointersStorageBuffer, // 206 - spv::Capability::PhysicalStorageBufferAddresses, // 207 - spv::Capability::Kernel, // 208 - spv::Capability::ImageQuery, // 209 - spv::Capability::ImageQuery, // 210 - spv::Capability::Shader, // 211 - spv::Capability::BitInstructions, // 212 - spv::Capability::DerivativeControl, // 213 - spv::Capability::Groups, // 214 - spv::Capability::SparseResidency, // 215 - spv::Capability::PipeStorage, // 216 - spv::Capability::NamedBarrier, // 217 - spv::Capability::GroupNonUniformVote, // 218 - spv::Capability::GroupNonUniformBallot, // 219 - spv::Capability::GroupNonUniformShuffle, // 220 - spv::Capability::GroupNonUniformShuffleRelative, // 221 - spv::Capability::GroupNonUniformArithmetic, // 222 - spv::Capability::GroupNonUniformClustered, // 223 - spv::Capability::GroupNonUniformPartitionedNV, // 224 - spv::Capability::GroupNonUniformQuad, // 225 - spv::Capability::Addresses, // 226 - spv::Capability::VariablePointers, // 227 - spv::Capability::VariablePointersStorageBuffer, // 228 - spv::Capability::UntypedPointersKHR, // 229 - spv::Capability::SubgroupBallotKHR, // 230 - spv::Capability::SubgroupVoteKHR, // 231 - spv::Capability::GroupNonUniformRotateKHR, // 232 - spv::Capability::RayTracingKHR, // 233 - spv::Capability::RayQueryKHR, // 234 - spv::Capability::DotProduct, // 235 - spv::Capability::CooperativeMatrixKHR, // 236 - spv::Capability::ReplicatedCompositesEXT, // 237 - spv::Capability::TextureSampleWeightedQCOM, // 238 - spv::Capability::TextureBoxFilterQCOM, // 239 - spv::Capability::TextureBlockMatchQCOM, // 240 - spv::Capability::TextureBlockMatch2QCOM, // 241 - spv::Capability::FragmentMaskAMD, // 242 - spv::Capability::ShaderClockKHR, // 243 - spv::Capability::ShaderInvocationReorderNV, // 244 - spv::Capability::RayTracingMotionBlurNV, // 245 - spv::Capability::ImageFootprintNV, // 246 - spv::Capability::CooperativeVectorNV, // 247 - spv::Capability::CooperativeVectorTrainingNV, // 248 - spv::Capability::CooperativeMatrixConversionsNV, // 249 - spv::Capability::DisplacementMicromapNV, // 250 - spv::Capability::RayQueryPositionFetchKHR, // 251 - spv::Capability::RayTracingNV, // 252 - spv::Capability::RayTracingKHR, // 253 - spv::Capability::RayQueryKHR, // 254 - spv::Capability::DisplacementMicromapNV, // 255 - spv::Capability::CooperativeMatrixNV, // 256 - spv::Capability::FragmentShaderSampleInterlockEXT, // 257 - spv::Capability::FragmentShaderPixelInterlockEXT, // 258 - spv::Capability::FragmentShaderShadingRateInterlockEXT, // 259 - spv::Capability::CooperativeMatrixReductionsNV, // 260 - spv::Capability::CooperativeMatrixPerElementOperationsNV, // 261 - spv::Capability::TensorAddressingNV, // 262 - spv::Capability::DemoteToHelperInvocation, // 263 - spv::Capability::SubgroupShuffleINTEL, // 264 - spv::Capability::SubgroupBufferBlockIOINTEL, // 265 - spv::Capability::SubgroupImageBlockIOINTEL, // 266 - spv::Capability::SubgroupImageMediaBlockIOINTEL, // 267 - spv::Capability::IntegerFunctions2INTEL, // 268 - spv::Capability::AtomicFloat16MinMaxEXT, // 269 - spv::Capability::AtomicFloat32MinMaxEXT, // 270 - spv::Capability::AtomicFloat64MinMaxEXT, // 271 - spv::Capability::AtomicFloat16VectorNV, // 272 - spv::Capability::ExpectAssumeKHR, // 273 - spv::Capability::SubgroupAvcMotionEstimationINTEL, // 274 - spv::Capability::SubgroupAvcMotionEstimationINTEL, // 275 - spv::Capability::SubgroupAvcMotionEstimationIntraINTEL, // 276 - spv::Capability::SubgroupAvcMotionEstimationINTEL, // 277 - spv::Capability::SubgroupAvcMotionEstimationChromaINTEL, // 278 - spv::Capability::VariableLengthArrayINTEL, // 279 - spv::Capability::ArbitraryPrecisionFloatingPointINTEL, // 280 - spv::Capability::UnstructuredLoopControlsINTEL, // 281 - spv::Capability::BlockingPipesINTEL, // 282 - spv::Capability::FPGARegINTEL, // 283 - spv::Capability::AtomicFloat16AddEXT, // 284 - spv::Capability::AtomicFloat32AddEXT, // 285 - spv::Capability::AtomicFloat64AddEXT, // 286 - spv::Capability::AtomicFloat16VectorNV, // 287 - spv::Capability::LongCompositesINTEL, // 288 - spv::Capability::BFloat16ConversionINTEL, // 289 - spv::Capability::SplitBarrierINTEL, // 290 - spv::Capability::ArithmeticFenceEXT, // 291 - spv::Capability::TaskSequenceINTEL, // 292 - spv::Capability::SubgroupBufferPrefetchINTEL, // 293 - spv::Capability::Subgroup2DBlockTransformINTEL, // 294 - spv::Capability::Subgroup2DBlockTransposeINTEL, // 295 - spv::Capability::SubgroupMatrixMultiplyAccumulateINTEL, // 296 - spv::Capability::TernaryBitwiseFunctionINTEL, // 297 - spv::Capability::GroupUniformArithmeticKHR, // 298 - spv::Capability::TensorFloat32RoundingINTEL, // 299 - spv::Capability::MaskedGatherScatterINTEL, // 300 - spv::Capability::BindlessImagesINTEL, // 301 - spv::Capability::Float64, // 302 - spv::Capability::InterpolationFunction, // 303 + spv::Capability::ImageBuffer, // 96 + spv::Capability::ShaderNonUniform, // 97 + spv::Capability::InputAttachment, // 98 + spv::Capability::ShaderNonUniform, // 99 + spv::Capability::SampledBuffer, // 100 + spv::Capability::ShaderNonUniform, // 101 + spv::Capability::ImageBuffer, // 102 + spv::Capability::ShaderNonUniform, // 103 + spv::Capability::VectorAnyINTEL, // 104 + spv::Capability::Int8, // 105 + spv::Capability::FPGAClusterAttributesINTEL, // 106 + spv::Capability::FPGAKernelAttributesINTEL, // 107 + spv::Capability::Subgroup2DBlockIOINTEL, // 108 + spv::Capability::VariableLengthArrayINTEL, // 109 + spv::Capability::UntypedPointersKHR, // 110 + spv::Capability::SpecConditionalINTEL, // 111 + spv::Capability::Shader, // 112 + spv::Capability::Kernel, // 113 + spv::Capability::Shader, // 114 + spv::Capability::UniformDecoration, // 115 + spv::Capability::GeometryStreams, // 116 + spv::Capability::TransformFeedback, // 117 + spv::Capability::Kernel, // 118 + spv::Capability::FloatControls2, // 119 + spv::Capability::Linkage, // 120 + spv::Capability::Float8EXT, // 121 + spv::Capability::SampleMaskOverrideCoverageNV, // 122 + spv::Capability::GeometryShaderPassthroughNV, // 123 + spv::Capability::MeshShadingNV, // 124 + spv::Capability::MeshShadingEXT, // 125 + spv::Capability::ShaderInvocationReorderNV, // 126 + spv::Capability::BindlessTextureNV, // 127 + spv::Capability::VectorComputeINTEL, // 128 + spv::Capability::IndirectReferencesINTEL, // 129 + spv::Capability::AsmINTEL, // 130 + spv::Capability::FunctionFloatControlINTEL, // 131 + spv::Capability::FPGAMemoryAttributesINTEL, // 132 + spv::Capability::FPGAMemoryAccessesINTEL, // 133 + spv::Capability::LoopFuseINTEL, // 134 + spv::Capability::FPGADSPControlINTEL, // 135 + spv::Capability::MemoryAccessAliasingINTEL, // 136 + spv::Capability::FPGAInvocationPipeliningAttributesINTEL, // 137 + spv::Capability::FPGABufferLocationINTEL, // 138 + spv::Capability::IOPipesINTEL, // 139 + spv::Capability::FPGAClusterAttributesV2INTEL, // 140 + spv::Capability::FPMaxErrorINTEL, // 141 + spv::Capability::FPGALatencyControlINTEL, // 142 + spv::Capability::FPGAArgumentInterfacesINTEL, // 143 + spv::Capability::GlobalVariableHostAccessINTEL, // 144 + spv::Capability::GlobalVariableFPGADecorationsINTEL, // 145 + spv::Capability::CacheControlsINTEL, // 146 + spv::Capability::TileImageColorReadAccessEXT, // 147 + spv::Capability::Geometry, // 148 + spv::Capability::Tessellation, // 149 + spv::Capability::MeshShadingNV, // 150 + spv::Capability::MeshShadingEXT, // 151 + spv::Capability::Geometry, // 152 + spv::Capability::MeshShadingNV, // 153 + spv::Capability::MeshShadingEXT, // 154 + spv::Capability::SubgroupDispatch, // 155 + spv::Capability::TileImageDepthReadAccessEXT, // 156 + spv::Capability::TileImageStencilReadAccessEXT, // 157 + spv::Capability::SampleMaskPostDepthCoverage, // 158 + spv::Capability::DenormPreserve, // 159 + spv::Capability::DenormFlushToZero, // 160 + spv::Capability::SignedZeroInfNanPreserve, // 161 + spv::Capability::RoundingModeRTE, // 162 + spv::Capability::RoundingModeRTZ, // 163 + spv::Capability::QuadControlKHR, // 164 + spv::Capability::ComputeDerivativeGroupQuadsKHR, // 165 + spv::Capability::ComputeDerivativeGroupLinearKHR, // 166 + spv::Capability::FragmentShaderPixelInterlockEXT, // 167 + spv::Capability::FragmentShaderSampleInterlockEXT, // 168 + spv::Capability::FragmentShaderShadingRateInterlockEXT, // 169 + spv::Capability::RoundToInfinityINTEL, // 170 + spv::Capability::KernelAttributesINTEL, // 171 + spv::Capability::FloatControls2, // 172 + spv::Capability::FPGAKernelAttributesv2INTEL, // 173 + spv::Capability::RegisterLimitsINTEL, // 174 + spv::Capability::FloatControls2, // 175 + spv::Capability::FPFastMathModeINTEL, // 176 + spv::Capability::OptNoneEXT, // 177 + spv::Capability::RuntimeAlignedAttributeINTEL, // 178 + spv::Capability::Kernel, // 179 + spv::Capability::GroupNonUniformArithmetic, // 180 + spv::Capability::GroupNonUniformBallot, // 181 + spv::Capability::GroupNonUniformClustered, // 182 + spv::Capability::GroupNonUniformPartitionedNV, // 183 + spv::Capability::ImageGatherExtended, // 184 + spv::Capability::MinLod, // 185 + spv::Capability::VulkanMemoryModel, // 186 + spv::Capability::FPGALoopControlsINTEL, // 187 + spv::Capability::ArbitraryPrecisionFixedPointINTEL, // 188 + spv::Capability::RawAccessChainsNV, // 189 + spv::Capability::RayTraversalPrimitiveCullingKHR, // 190 + spv::Capability::RayTracingOpacityMicromapEXT, // 191 + spv::Capability::RayQueryKHR, // 192 + spv::Capability::StorageImageExtendedFormats, // 193 + spv::Capability::Int64ImageEXT, // 194 + spv::Capability::Shader, // 195 + spv::Capability::VectorComputeINTEL, // 196 + spv::Capability::GenericPointer, // 197 + spv::Capability::FunctionPointersINTEL, // 198 + spv::Capability::USMStorageClassesINTEL, // 199 + spv::Capability::CooperativeMatrixTensorAddressingNV, // 200 + spv::Capability::CooperativeMatrixBlockLoadsNV, // 201 + spv::Capability::TensorsARM, // 202 + spv::Capability::Addresses, // 203 + spv::Capability::PhysicalStorageBufferAddresses, // 204 + spv::Capability::LiteralSampler, // 205 + spv::Capability::Addresses, // 206 + spv::Capability::UntypedPointersKHR, // 207 + spv::Capability::Addresses, // 208 + spv::Capability::VariablePointers, // 209 + spv::Capability::VariablePointersStorageBuffer, // 210 + spv::Capability::PhysicalStorageBufferAddresses, // 211 + spv::Capability::Kernel, // 212 + spv::Capability::ImageQuery, // 213 + spv::Capability::ImageQuery, // 214 + spv::Capability::Shader, // 215 + spv::Capability::BitInstructions, // 216 + spv::Capability::DerivativeControl, // 217 + spv::Capability::Groups, // 218 + spv::Capability::SparseResidency, // 219 + spv::Capability::PipeStorage, // 220 + spv::Capability::NamedBarrier, // 221 + spv::Capability::GroupNonUniformVote, // 222 + spv::Capability::GroupNonUniformBallot, // 223 + spv::Capability::GroupNonUniformShuffle, // 224 + spv::Capability::GroupNonUniformShuffleRelative, // 225 + spv::Capability::GroupNonUniformArithmetic, // 226 + spv::Capability::GroupNonUniformClustered, // 227 + spv::Capability::GroupNonUniformPartitionedNV, // 228 + spv::Capability::GroupNonUniformQuad, // 229 + spv::Capability::Addresses, // 230 + spv::Capability::VariablePointers, // 231 + spv::Capability::VariablePointersStorageBuffer, // 232 + spv::Capability::GraphARM, // 233 + spv::Capability::UntypedPointersKHR, // 234 + spv::Capability::SubgroupBallotKHR, // 235 + spv::Capability::FMAKHR, // 236 + spv::Capability::SubgroupVoteKHR, // 237 + spv::Capability::GroupNonUniformRotateKHR, // 238 + spv::Capability::RayTracingKHR, // 239 + spv::Capability::RayQueryKHR, // 240 + spv::Capability::DotProduct, // 241 + spv::Capability::ReplicatedCompositesEXT, // 242 + spv::Capability::TextureSampleWeightedQCOM, // 243 + spv::Capability::TextureBoxFilterQCOM, // 244 + spv::Capability::TextureBlockMatchQCOM, // 245 + spv::Capability::CooperativeMatrixConversionQCOM, // 246 + spv::Capability::TextureBlockMatch2QCOM, // 247 + spv::Capability::FragmentMaskAMD, // 248 + spv::Capability::ShaderClockKHR, // 249 + spv::Capability::ShaderInvocationReorderNV, // 250 + spv::Capability::RayTracingMotionBlurNV, // 251 + spv::Capability::ImageFootprintNV, // 252 + spv::Capability::CooperativeVectorNV, // 253 + spv::Capability::CooperativeVectorTrainingNV, // 254 + spv::Capability::CooperativeMatrixConversionsNV, // 255 + spv::Capability::DisplacementMicromapNV, // 256 + spv::Capability::RayQueryPositionFetchKHR, // 257 + spv::Capability::RayTracingNV, // 258 + spv::Capability::RayTracingKHR, // 259 + spv::Capability::RayQueryKHR, // 260 + spv::Capability::DisplacementMicromapNV, // 261 + spv::Capability::CooperativeMatrixNV, // 262 + spv::Capability::FragmentShaderSampleInterlockEXT, // 263 + spv::Capability::FragmentShaderPixelInterlockEXT, // 264 + spv::Capability::FragmentShaderShadingRateInterlockEXT, // 265 + spv::Capability::CooperativeMatrixReductionsNV, // 266 + spv::Capability::CooperativeMatrixPerElementOperationsNV, // 267 + spv::Capability::TensorAddressingNV, // 268 + spv::Capability::DemoteToHelperInvocation, // 269 + spv::Capability::SubgroupShuffleINTEL, // 270 + spv::Capability::SubgroupBufferBlockIOINTEL, // 271 + spv::Capability::SubgroupImageBlockIOINTEL, // 272 + spv::Capability::SubgroupImageMediaBlockIOINTEL, // 273 + spv::Capability::IntegerFunctions2INTEL, // 274 + spv::Capability::AtomicFloat16MinMaxEXT, // 275 + spv::Capability::AtomicFloat32MinMaxEXT, // 276 + spv::Capability::AtomicFloat64MinMaxEXT, // 277 + spv::Capability::AtomicFloat16VectorNV, // 278 + spv::Capability::ExpectAssumeKHR, // 279 + spv::Capability::SubgroupAvcMotionEstimationINTEL, // 280 + spv::Capability::SubgroupAvcMotionEstimationINTEL, // 281 + spv::Capability::SubgroupAvcMotionEstimationIntraINTEL, // 282 + spv::Capability::SubgroupAvcMotionEstimationINTEL, // 283 + spv::Capability::SubgroupAvcMotionEstimationChromaINTEL, // 284 + spv::Capability::VariableLengthArrayINTEL, // 285 + spv::Capability::ArbitraryPrecisionFloatingPointINTEL, // 286 + spv::Capability::UnstructuredLoopControlsINTEL, // 287 + spv::Capability::BlockingPipesINTEL, // 288 + spv::Capability::FPGARegINTEL, // 289 + spv::Capability::AtomicFloat16AddEXT, // 290 + spv::Capability::AtomicFloat32AddEXT, // 291 + spv::Capability::AtomicFloat64AddEXT, // 292 + spv::Capability::AtomicFloat16VectorNV, // 293 + spv::Capability::LongCompositesINTEL, // 294 + spv::Capability::BFloat16ConversionINTEL, // 295 + spv::Capability::SplitBarrierINTEL, // 296 + spv::Capability::ArithmeticFenceEXT, // 297 + spv::Capability::TaskSequenceINTEL, // 298 + spv::Capability::SubgroupBufferPrefetchINTEL, // 299 + spv::Capability::Subgroup2DBlockTransformINTEL, // 300 + spv::Capability::Subgroup2DBlockTransposeINTEL, // 301 + spv::Capability::SubgroupMatrixMultiplyAccumulateINTEL, // 302 + spv::Capability::TernaryBitwiseFunctionINTEL, // 303 + spv::Capability::UntypedVariableLengthArrayINTEL, // 304 + spv::Capability::FunctionVariantsINTEL, // 305 + spv::Capability::GroupUniformArithmeticKHR, // 306 + spv::Capability::TensorFloat32RoundingINTEL, // 307 + spv::Capability::MaskedGatherScatterINTEL, // 308 + spv::Capability::BindlessImagesINTEL, // 309 + spv::Capability::Float64, // 310 + spv::Capability::InterpolationFunction, // 311 }; // Array of extensions, referenced by IndexRanges elsewhere. @@ -8518,143 +8626,147 @@ static const spvtools::Extension kExtensionSpans[] = { spvtools::Extension::kSPV_ARM_core_builtins, // 34 spvtools::Extension::kSPV_EXT_shader_tile_image, // 35 spvtools::Extension::kSPV_ARM_tensors, // 36 - spvtools::Extension::kSPV_ARM_cooperative_matrix_layouts, // 37 - spvtools::Extension::kSPV_EXT_float8, // 38 - spvtools::Extension::kSPV_KHR_workgroup_memory_explicit_layout, // 39 - spvtools::Extension::kSPV_KHR_subgroup_vote, // 40 - spvtools::Extension::kSPV_KHR_16bit_storage, // 41 - spvtools::Extension::kSPV_KHR_variable_pointers, // 42 - spvtools::Extension::kSPV_KHR_shader_atomic_counter_ops, // 43 - spvtools::Extension::kSPV_KHR_post_depth_coverage, // 44 - spvtools::Extension::kSPV_KHR_8bit_storage, // 45 - spvtools::Extension::kSPV_KHR_float_controls, // 46 - spvtools::Extension::kSPV_KHR_ray_query, // 47 - spvtools::Extension::kSPV_KHR_untyped_pointers, // 48 - spvtools::Extension::kSPV_KHR_ray_query, // 49 - spvtools::Extension::kSPV_KHR_ray_tracing, // 50 - spvtools::Extension::kSPV_QCOM_image_processing, // 51 - spvtools::Extension::kSPV_QCOM_tile_shading, // 52 - spvtools::Extension::kSPV_QCOM_image_processing2, // 53 - spvtools::Extension::kSPV_AMD_gpu_shader_half_float_fetch, // 54 - spvtools::Extension::kSPV_AMD_texture_gather_bias_lod, // 55 - spvtools::Extension::kSPV_AMD_shader_fragment_mask, // 56 - spvtools::Extension::kSPV_AMD_shader_image_load_store_lod, // 57 - spvtools::Extension::kSPV_EXT_shader_image_int64, // 58 - spvtools::Extension::kSPV_KHR_shader_clock, // 59 - spvtools::Extension::kSPV_AMDX_shader_enqueue, // 60 - spvtools::Extension::kSPV_KHR_quad_control, // 61 - spvtools::Extension::kSPV_INTEL_int4, // 62 - spvtools::Extension::kSPV_KHR_bfloat16, // 63 - spvtools::Extension::kSPV_NV_sample_mask_override_coverage, // 64 - spvtools::Extension::kSPV_NV_geometry_shader_passthrough, // 65 - spvtools::Extension::kSPV_EXT_shader_viewport_index_layer, // 66 - spvtools::Extension::kSPV_NV_viewport_array2, // 67 - spvtools::Extension::kSPV_NV_viewport_array2, // 68 - spvtools::Extension::kSPV_NVX_multiview_per_view_attributes, // 69 - spvtools::Extension::kSPV_NV_shader_image_footprint, // 70 - spvtools::Extension::kSPV_NV_compute_shader_derivatives, // 71 - spvtools::Extension::kSPV_KHR_compute_shader_derivatives, // 72 - spvtools::Extension::kSPV_NV_shader_subgroup_partitioned, // 73 - spvtools::Extension::kSPV_EXT_descriptor_indexing, // 74 - spvtools::Extension::kSPV_KHR_ray_tracing_position_fetch, // 75 - spvtools::Extension::kSPV_KHR_vulkan_memory_model, // 76 - spvtools::Extension::kSPV_NV_cooperative_matrix, // 77 - spvtools::Extension::kSPV_EXT_fragment_shader_interlock, // 78 - spvtools::Extension::kSPV_EXT_demote_to_helper_invocation, // 79 - spvtools::Extension::kSPV_NV_displacement_micromap, // 80 - spvtools::Extension::kSPV_EXT_opacity_micromap, // 81 - spvtools::Extension::kSPV_NV_shader_invocation_reorder, // 82 - spvtools::Extension::kSPV_NV_bindless_texture, // 83 - spvtools::Extension::kSPV_NV_cooperative_vector, // 84 - spvtools::Extension::kSPV_NV_shader_atomic_fp16_vector, // 85 - spvtools::Extension::kSPV_NV_raw_access_chains, // 86 - spvtools::Extension::kSPV_NV_cooperative_matrix2, // 87 - spvtools::Extension::kSPV_NV_tensor_addressing, // 88 - spvtools::Extension::kSPV_INTEL_subgroups, // 89 - spvtools::Extension::kSPV_INTEL_media_block_io, // 90 - spvtools::Extension::kSPV_INTEL_float_controls2, // 91 - spvtools::Extension::kSPV_INTEL_shader_integer_functions2, // 92 - spvtools::Extension::kSPV_INTEL_function_pointers, // 93 - spvtools::Extension::kSPV_INTEL_inline_assembly, // 94 - spvtools::Extension::kSPV_EXT_shader_atomic_float_min_max, // 95 - spvtools::Extension::kSPV_INTEL_vector_compute, // 96 - spvtools::Extension::kSPV_KHR_expect_assume, // 97 - spvtools::Extension::kSPV_INTEL_device_side_avc_motion_estimation, // 98 - spvtools::Extension::kSPV_INTEL_variable_length_array, // 99 - spvtools::Extension::kSPV_INTEL_fpga_memory_attributes, // 100 - spvtools::Extension::kSPV_INTEL_fp_fast_math_mode, // 101 - spvtools::Extension::kSPV_INTEL_arbitrary_precision_integers, // 102 - spvtools::Extension::kSPV_INTEL_arbitrary_precision_floating_point, // 103 - spvtools::Extension::kSPV_INTEL_unstructured_loop_controls, // 104 - spvtools::Extension::kSPV_INTEL_fpga_loop_controls, // 105 - spvtools::Extension::kSPV_INTEL_kernel_attributes, // 106 - spvtools::Extension::kSPV_INTEL_fpga_memory_accesses, // 107 - spvtools::Extension::kSPV_INTEL_fpga_cluster_attributes, // 108 - spvtools::Extension::kSPV_INTEL_loop_fuse, // 109 - spvtools::Extension::kSPV_INTEL_fpga_dsp_control, // 110 - spvtools::Extension::kSPV_INTEL_memory_access_aliasing, // 111 - spvtools::Extension::kSPV_INTEL_fpga_invocation_pipelining_attributes, // 112 - spvtools::Extension::kSPV_INTEL_fpga_buffer_location, // 113 - spvtools::Extension::kSPV_INTEL_arbitrary_precision_fixed_point, // 114 - spvtools::Extension::kSPV_INTEL_usm_storage_classes, // 115 - spvtools::Extension::kSPV_INTEL_runtime_aligned, // 116 - spvtools::Extension::kSPV_INTEL_io_pipes, // 117 - spvtools::Extension::kSPV_INTEL_blocking_pipes, // 118 - spvtools::Extension::kSPV_INTEL_fpga_reg, // 119 - spvtools::Extension::kSPV_KHR_integer_dot_product, // 120 - spvtools::Extension::kSPV_KHR_cooperative_matrix, // 121 - spvtools::Extension::kSPV_EXT_replicated_composites, // 122 - spvtools::Extension::kSPV_KHR_bit_instructions, // 123 - spvtools::Extension::kSPV_KHR_subgroup_rotate, // 124 - spvtools::Extension::kSPV_KHR_float_controls2, // 125 - spvtools::Extension::kSPV_EXT_shader_atomic_float_add, // 126 - spvtools::Extension::kSPV_INTEL_long_composites, // 127 - spvtools::Extension::kSPV_EXT_optnone, // 128 - spvtools::Extension::kSPV_INTEL_optnone, // 129 - spvtools::Extension::kSPV_EXT_shader_atomic_float16_add, // 130 - spvtools::Extension::kSPV_INTEL_debug_module, // 131 - spvtools::Extension::kSPV_INTEL_bfloat16_conversion, // 132 - spvtools::Extension::kSPV_INTEL_split_barrier, // 133 - spvtools::Extension::kSPV_EXT_arithmetic_fence, // 134 - spvtools::Extension::kSPV_INTEL_task_sequence, // 135 - spvtools::Extension::kSPV_INTEL_fp_max_error, // 136 - spvtools::Extension::kSPV_INTEL_fpga_latency_control, // 137 - spvtools::Extension::kSPV_INTEL_fpga_argument_interfaces, // 138 - spvtools::Extension::kSPV_INTEL_global_variable_host_access, // 139 - spvtools::Extension::kSPV_INTEL_global_variable_fpga_decorations, // 140 - spvtools::Extension::kSPV_INTEL_subgroup_buffer_prefetch, // 141 - spvtools::Extension::kSPV_INTEL_2d_block_io, // 142 - spvtools::Extension::kSPV_INTEL_subgroup_matrix_multiply_accumulate, // 143 - spvtools::Extension::kSPV_INTEL_ternary_bitwise_function, // 144 - spvtools::Extension::kSPV_KHR_uniform_group_instructions, // 145 - spvtools::Extension::kSPV_INTEL_tensor_float32_conversion, // 146 - spvtools::Extension::kSPV_INTEL_masked_gather_scatter, // 147 - spvtools::Extension::kSPV_INTEL_cache_controls, // 148 - spvtools::Extension::kSPV_INTEL_maximum_registers, // 149 - spvtools::Extension::kSPV_INTEL_bindless_images, // 150 - spvtools::Extension::kSPV_KHR_no_integer_wrap_decoration, // 151 - spvtools::Extension::kSPV_NV_mesh_shader, // 152 - spvtools::Extension::kSPV_EXT_mesh_shader, // 153 - spvtools::Extension::kSPV_GOOGLE_hlsl_functionality1, // 154 - spvtools::Extension::kSPV_GOOGLE_user_type, // 155 - spvtools::Extension::kSPV_KHR_subgroup_uniform_control_flow, // 156 - spvtools::Extension::kSPV_AMD_shader_early_and_late_fragment_tests, // 157 - spvtools::Extension::kSPV_AMD_shader_early_and_late_fragment_tests, // 158 - spvtools::Extension::kSPV_EXT_shader_stencil_export, // 159 - spvtools::Extension::kSPV_KHR_maximal_reconvergence, // 160 - spvtools::Extension::kSPV_KHR_linkonce_odr, // 161 - spvtools::Extension::kSPV_KHR_storage_buffer_storage_class, // 162 - spvtools::Extension::kSPV_KHR_variable_pointers, // 163 - spvtools::Extension::kSPV_KHR_terminate_invocation, // 164 - spvtools::Extension::kSPV_KHR_relaxed_extended_instruction, // 165 - spvtools::Extension::kSPV_KHR_ray_tracing, // 166 - spvtools::Extension::kSPV_KHR_ray_query, // 167 - spvtools::Extension::kSPV_NV_ray_tracing, // 168 - spvtools::Extension::kSPV_KHR_ray_tracing, // 169 - spvtools::Extension::kSPV_KHR_ray_query, // 170 - spvtools::Extension::kSPV_NV_displacement_micromap, // 171 - spvtools::Extension::kSPV_GOOGLE_decorate_string, // 172 - spvtools::Extension::kSPV_GOOGLE_hlsl_functionality1, // 173 + spvtools::Extension::kSPV_ARM_graph, // 37 + spvtools::Extension::kSPV_ARM_cooperative_matrix_layouts, // 38 + spvtools::Extension::kSPV_EXT_float8, // 39 + spvtools::Extension::kSPV_KHR_workgroup_memory_explicit_layout, // 40 + spvtools::Extension::kSPV_KHR_subgroup_vote, // 41 + spvtools::Extension::kSPV_KHR_16bit_storage, // 42 + spvtools::Extension::kSPV_KHR_variable_pointers, // 43 + spvtools::Extension::kSPV_KHR_shader_atomic_counter_ops, // 44 + spvtools::Extension::kSPV_KHR_post_depth_coverage, // 45 + spvtools::Extension::kSPV_KHR_8bit_storage, // 46 + spvtools::Extension::kSPV_KHR_float_controls, // 47 + spvtools::Extension::kSPV_KHR_ray_query, // 48 + spvtools::Extension::kSPV_KHR_untyped_pointers, // 49 + spvtools::Extension::kSPV_KHR_ray_query, // 50 + spvtools::Extension::kSPV_KHR_ray_tracing, // 51 + spvtools::Extension::kSPV_QCOM_image_processing, // 52 + spvtools::Extension::kSPV_QCOM_tile_shading, // 53 + spvtools::Extension::kSPV_QCOM_cooperative_matrix_conversion, // 54 + spvtools::Extension::kSPV_QCOM_image_processing2, // 55 + spvtools::Extension::kSPV_AMD_gpu_shader_half_float_fetch, // 56 + spvtools::Extension::kSPV_AMD_texture_gather_bias_lod, // 57 + spvtools::Extension::kSPV_AMD_shader_fragment_mask, // 58 + spvtools::Extension::kSPV_AMD_shader_image_load_store_lod, // 59 + spvtools::Extension::kSPV_EXT_shader_image_int64, // 60 + spvtools::Extension::kSPV_KHR_shader_clock, // 61 + spvtools::Extension::kSPV_AMDX_shader_enqueue, // 62 + spvtools::Extension::kSPV_KHR_quad_control, // 63 + spvtools::Extension::kSPV_INTEL_int4, // 64 + spvtools::Extension::kSPV_KHR_bfloat16, // 65 + spvtools::Extension::kSPV_NV_sample_mask_override_coverage, // 66 + spvtools::Extension::kSPV_NV_geometry_shader_passthrough, // 67 + spvtools::Extension::kSPV_EXT_shader_viewport_index_layer, // 68 + spvtools::Extension::kSPV_NV_viewport_array2, // 69 + spvtools::Extension::kSPV_NV_viewport_array2, // 70 + spvtools::Extension::kSPV_NVX_multiview_per_view_attributes, // 71 + spvtools::Extension::kSPV_NV_shader_image_footprint, // 72 + spvtools::Extension::kSPV_NV_compute_shader_derivatives, // 73 + spvtools::Extension::kSPV_KHR_compute_shader_derivatives, // 74 + spvtools::Extension::kSPV_NV_shader_subgroup_partitioned, // 75 + spvtools::Extension::kSPV_EXT_descriptor_indexing, // 76 + spvtools::Extension::kSPV_KHR_ray_tracing_position_fetch, // 77 + spvtools::Extension::kSPV_KHR_vulkan_memory_model, // 78 + spvtools::Extension::kSPV_NV_cooperative_matrix, // 79 + spvtools::Extension::kSPV_EXT_fragment_shader_interlock, // 80 + spvtools::Extension::kSPV_EXT_demote_to_helper_invocation, // 81 + spvtools::Extension::kSPV_NV_displacement_micromap, // 82 + spvtools::Extension::kSPV_EXT_opacity_micromap, // 83 + spvtools::Extension::kSPV_NV_shader_invocation_reorder, // 84 + spvtools::Extension::kSPV_NV_bindless_texture, // 85 + spvtools::Extension::kSPV_NV_cooperative_vector, // 86 + spvtools::Extension::kSPV_NV_shader_atomic_fp16_vector, // 87 + spvtools::Extension::kSPV_NV_raw_access_chains, // 88 + spvtools::Extension::kSPV_NV_cooperative_matrix2, // 89 + spvtools::Extension::kSPV_NV_tensor_addressing, // 90 + spvtools::Extension::kSPV_INTEL_subgroups, // 91 + spvtools::Extension::kSPV_INTEL_media_block_io, // 92 + spvtools::Extension::kSPV_INTEL_float_controls2, // 93 + spvtools::Extension::kSPV_INTEL_shader_integer_functions2, // 94 + spvtools::Extension::kSPV_INTEL_function_pointers, // 95 + spvtools::Extension::kSPV_INTEL_inline_assembly, // 96 + spvtools::Extension::kSPV_EXT_shader_atomic_float_min_max, // 97 + spvtools::Extension::kSPV_INTEL_vector_compute, // 98 + spvtools::Extension::kSPV_KHR_expect_assume, // 99 + spvtools::Extension::kSPV_INTEL_device_side_avc_motion_estimation, // 100 + spvtools::Extension::kSPV_INTEL_variable_length_array, // 101 + spvtools::Extension::kSPV_INTEL_fpga_memory_attributes, // 102 + spvtools::Extension::kSPV_INTEL_fp_fast_math_mode, // 103 + spvtools::Extension::kSPV_INTEL_arbitrary_precision_integers, // 104 + spvtools::Extension::kSPV_INTEL_arbitrary_precision_floating_point, // 105 + spvtools::Extension::kSPV_INTEL_unstructured_loop_controls, // 106 + spvtools::Extension::kSPV_INTEL_fpga_loop_controls, // 107 + spvtools::Extension::kSPV_INTEL_kernel_attributes, // 108 + spvtools::Extension::kSPV_INTEL_fpga_memory_accesses, // 109 + spvtools::Extension::kSPV_INTEL_fpga_cluster_attributes, // 110 + spvtools::Extension::kSPV_INTEL_loop_fuse, // 111 + spvtools::Extension::kSPV_INTEL_fpga_dsp_control, // 112 + spvtools::Extension::kSPV_INTEL_memory_access_aliasing, // 113 + spvtools::Extension::kSPV_INTEL_fpga_invocation_pipelining_attributes, // 114 + spvtools::Extension::kSPV_INTEL_fpga_buffer_location, // 115 + spvtools::Extension::kSPV_INTEL_arbitrary_precision_fixed_point, // 116 + spvtools::Extension::kSPV_INTEL_usm_storage_classes, // 117 + spvtools::Extension::kSPV_INTEL_runtime_aligned, // 118 + spvtools::Extension::kSPV_INTEL_io_pipes, // 119 + spvtools::Extension::kSPV_INTEL_blocking_pipes, // 120 + spvtools::Extension::kSPV_INTEL_fpga_reg, // 121 + spvtools::Extension::kSPV_KHR_integer_dot_product, // 122 + spvtools::Extension::kSPV_KHR_cooperative_matrix, // 123 + spvtools::Extension::kSPV_EXT_replicated_composites, // 124 + spvtools::Extension::kSPV_KHR_bit_instructions, // 125 + spvtools::Extension::kSPV_KHR_subgroup_rotate, // 126 + spvtools::Extension::kSPV_KHR_float_controls2, // 127 + spvtools::Extension::kSPV_KHR_fma, // 128 + spvtools::Extension::kSPV_EXT_shader_atomic_float_add, // 129 + spvtools::Extension::kSPV_INTEL_long_composites, // 130 + spvtools::Extension::kSPV_EXT_optnone, // 131 + spvtools::Extension::kSPV_INTEL_optnone, // 132 + spvtools::Extension::kSPV_EXT_shader_atomic_float16_add, // 133 + spvtools::Extension::kSPV_INTEL_debug_module, // 134 + spvtools::Extension::kSPV_INTEL_bfloat16_conversion, // 135 + spvtools::Extension::kSPV_INTEL_split_barrier, // 136 + spvtools::Extension::kSPV_EXT_arithmetic_fence, // 137 + spvtools::Extension::kSPV_INTEL_task_sequence, // 138 + spvtools::Extension::kSPV_INTEL_fp_max_error, // 139 + spvtools::Extension::kSPV_INTEL_fpga_latency_control, // 140 + spvtools::Extension::kSPV_INTEL_fpga_argument_interfaces, // 141 + spvtools::Extension::kSPV_INTEL_global_variable_host_access, // 142 + spvtools::Extension::kSPV_INTEL_global_variable_fpga_decorations, // 143 + spvtools::Extension::kSPV_INTEL_subgroup_buffer_prefetch, // 144 + spvtools::Extension::kSPV_INTEL_2d_block_io, // 145 + spvtools::Extension::kSPV_INTEL_subgroup_matrix_multiply_accumulate, // 146 + spvtools::Extension::kSPV_INTEL_ternary_bitwise_function, // 147 + spvtools::Extension::kSPV_INTEL_function_variants, // 148 + spvtools::Extension::kSPV_KHR_uniform_group_instructions, // 149 + spvtools::Extension::kSPV_INTEL_tensor_float32_conversion, // 150 + spvtools::Extension::kSPV_INTEL_masked_gather_scatter, // 151 + spvtools::Extension::kSPV_INTEL_cache_controls, // 152 + spvtools::Extension::kSPV_INTEL_maximum_registers, // 153 + spvtools::Extension::kSPV_INTEL_bindless_images, // 154 + spvtools::Extension::kSPV_KHR_no_integer_wrap_decoration, // 155 + spvtools::Extension::kSPV_NV_mesh_shader, // 156 + spvtools::Extension::kSPV_EXT_mesh_shader, // 157 + spvtools::Extension::kSPV_GOOGLE_hlsl_functionality1, // 158 + spvtools::Extension::kSPV_GOOGLE_user_type, // 159 + spvtools::Extension::kSPV_KHR_subgroup_uniform_control_flow, // 160 + spvtools::Extension::kSPV_AMD_shader_early_and_late_fragment_tests, // 161 + spvtools::Extension::kSPV_AMD_shader_early_and_late_fragment_tests, // 162 + spvtools::Extension::kSPV_EXT_shader_stencil_export, // 163 + spvtools::Extension::kSPV_KHR_maximal_reconvergence, // 164 + spvtools::Extension::kSPV_KHR_linkonce_odr, // 165 + spvtools::Extension::kSPV_KHR_storage_buffer_storage_class, // 166 + spvtools::Extension::kSPV_KHR_variable_pointers, // 167 + spvtools::Extension::kSPV_KHR_terminate_invocation, // 168 + spvtools::Extension::kSPV_KHR_relaxed_extended_instruction, // 169 + spvtools::Extension::kSPV_KHR_ray_tracing, // 170 + spvtools::Extension::kSPV_KHR_ray_query, // 171 + spvtools::Extension::kSPV_NV_ray_tracing, // 172 + spvtools::Extension::kSPV_KHR_ray_tracing, // 173 + spvtools::Extension::kSPV_KHR_ray_query, // 174 + spvtools::Extension::kSPV_NV_displacement_micromap, // 175 + spvtools::Extension::kSPV_GOOGLE_decorate_string, // 176 + spvtools::Extension::kSPV_GOOGLE_hlsl_functionality1, // 177 }; // Array of operand types, referenced by IndexRanges elsewhere. @@ -9029,108 +9141,108 @@ static const spv_operand_type_t kOperandSpans[] = { SPV_OPERAND_TYPE_ID, // 366 SPV_OPERAND_TYPE_ID, // 367 SPV_OPERAND_TYPE_OPTIONAL_TENSOR_OPERANDS, // 368 - SPV_OPERAND_TYPE_RESULT_ID, // 369 - SPV_OPERAND_TYPE_STORAGE_CLASS, // 370 - SPV_OPERAND_TYPE_TYPE_ID, // 371 - SPV_OPERAND_TYPE_RESULT_ID, // 372 - SPV_OPERAND_TYPE_STORAGE_CLASS, // 373 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 374 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 375 - SPV_OPERAND_TYPE_TYPE_ID, // 376 - SPV_OPERAND_TYPE_RESULT_ID, // 377 - SPV_OPERAND_TYPE_ID, // 378 - SPV_OPERAND_TYPE_ID, // 379 - SPV_OPERAND_TYPE_ID, // 380 - SPV_OPERAND_TYPE_VARIABLE_ID, // 381 - SPV_OPERAND_TYPE_TYPE_ID, // 382 - SPV_OPERAND_TYPE_RESULT_ID, // 383 - SPV_OPERAND_TYPE_ID, // 384 - SPV_OPERAND_TYPE_ID, // 385 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 386 - SPV_OPERAND_TYPE_ID, // 387 - SPV_OPERAND_TYPE_ID, // 388 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 389 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 390 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 391 - SPV_OPERAND_TYPE_TYPE_ID, // 392 - SPV_OPERAND_TYPE_RESULT_ID, // 393 - SPV_OPERAND_TYPE_SCOPE_ID, // 394 - SPV_OPERAND_TYPE_ID, // 395 + SPV_OPERAND_TYPE_TYPE_ID, // 369 + SPV_OPERAND_TYPE_RESULT_ID, // 370 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 371 + SPV_OPERAND_TYPE_ID, // 372 + SPV_OPERAND_TYPE_LITERAL_STRING, // 373 + SPV_OPERAND_TYPE_VARIABLE_ID, // 374 + SPV_OPERAND_TYPE_ID, // 375 + SPV_OPERAND_TYPE_ID, // 376 + SPV_OPERAND_TYPE_VARIABLE_ID, // 377 + SPV_OPERAND_TYPE_RESULT_ID, // 378 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 379 + SPV_OPERAND_TYPE_VARIABLE_ID, // 380 + SPV_OPERAND_TYPE_RESULT_ID, // 381 + SPV_OPERAND_TYPE_STORAGE_CLASS, // 382 + SPV_OPERAND_TYPE_TYPE_ID, // 383 + SPV_OPERAND_TYPE_RESULT_ID, // 384 + SPV_OPERAND_TYPE_STORAGE_CLASS, // 385 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 386 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 387 + SPV_OPERAND_TYPE_TYPE_ID, // 388 + SPV_OPERAND_TYPE_RESULT_ID, // 389 + SPV_OPERAND_TYPE_ID, // 390 + SPV_OPERAND_TYPE_ID, // 391 + SPV_OPERAND_TYPE_ID, // 392 + SPV_OPERAND_TYPE_VARIABLE_ID, // 393 + SPV_OPERAND_TYPE_TYPE_ID, // 394 + SPV_OPERAND_TYPE_RESULT_ID, // 395 SPV_OPERAND_TYPE_ID, // 396 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 397 - SPV_OPERAND_TYPE_TYPE_ID, // 398 - SPV_OPERAND_TYPE_RESULT_ID, // 399 + SPV_OPERAND_TYPE_ID, // 397 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 398 + SPV_OPERAND_TYPE_ID, // 399 SPV_OPERAND_TYPE_ID, // 400 - SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, // 401 - SPV_OPERAND_TYPE_VARIABLE_ID, // 402 - SPV_OPERAND_TYPE_ID, // 403 - SPV_OPERAND_TYPE_ID, // 404 - SPV_OPERAND_TYPE_ID, // 405 - SPV_OPERAND_TYPE_ID, // 406 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 401 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 402 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 403 + SPV_OPERAND_TYPE_TYPE_ID, // 404 + SPV_OPERAND_TYPE_RESULT_ID, // 405 + SPV_OPERAND_TYPE_SCOPE_ID, // 406 SPV_OPERAND_TYPE_ID, // 407 SPV_OPERAND_TYPE_ID, // 408 - SPV_OPERAND_TYPE_ID, // 409 - SPV_OPERAND_TYPE_ID, // 410 - SPV_OPERAND_TYPE_ID, // 411 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 409 + SPV_OPERAND_TYPE_TYPE_ID, // 410 + SPV_OPERAND_TYPE_RESULT_ID, // 411 SPV_OPERAND_TYPE_ID, // 412 - SPV_OPERAND_TYPE_ID, // 413 - SPV_OPERAND_TYPE_TYPE_ID, // 414 - SPV_OPERAND_TYPE_RESULT_ID, // 415 - SPV_OPERAND_TYPE_ID, // 416 + SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER, // 413 + SPV_OPERAND_TYPE_VARIABLE_ID, // 414 + SPV_OPERAND_TYPE_TYPE_ID, // 415 + SPV_OPERAND_TYPE_RESULT_ID, // 416 SPV_OPERAND_TYPE_ID, // 417 - SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT, // 418 - SPV_OPERAND_TYPE_TYPE_ID, // 419 - SPV_OPERAND_TYPE_RESULT_ID, // 420 + SPV_OPERAND_TYPE_ID, // 418 + SPV_OPERAND_TYPE_ID, // 419 + SPV_OPERAND_TYPE_ID, // 420 SPV_OPERAND_TYPE_ID, // 421 SPV_OPERAND_TYPE_ID, // 422 SPV_OPERAND_TYPE_ID, // 423 - SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT, // 424 - SPV_OPERAND_TYPE_RESULT_ID, // 425 + SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 424 + SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 425 SPV_OPERAND_TYPE_ID, // 426 - SPV_OPERAND_TYPE_SCOPE_ID, // 427 + SPV_OPERAND_TYPE_ID, // 427 SPV_OPERAND_TYPE_ID, // 428 SPV_OPERAND_TYPE_ID, // 429 SPV_OPERAND_TYPE_ID, // 430 - SPV_OPERAND_TYPE_TYPE_ID, // 431 - SPV_OPERAND_TYPE_RESULT_ID, // 432 + SPV_OPERAND_TYPE_ID, // 431 + SPV_OPERAND_TYPE_ID, // 432 SPV_OPERAND_TYPE_ID, // 433 SPV_OPERAND_TYPE_ID, // 434 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 435 - SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 436 - SPV_OPERAND_TYPE_ID, // 437 - SPV_OPERAND_TYPE_ID, // 438 + SPV_OPERAND_TYPE_ID, // 435 + SPV_OPERAND_TYPE_ID, // 436 + SPV_OPERAND_TYPE_TYPE_ID, // 437 + SPV_OPERAND_TYPE_RESULT_ID, // 438 SPV_OPERAND_TYPE_ID, // 439 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 440 - SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 441 + SPV_OPERAND_TYPE_ID, // 440 + SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT, // 441 SPV_OPERAND_TYPE_TYPE_ID, // 442 SPV_OPERAND_TYPE_RESULT_ID, // 443 SPV_OPERAND_TYPE_ID, // 444 SPV_OPERAND_TYPE_ID, // 445 SPV_OPERAND_TYPE_ID, // 446 - SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS, // 447 - SPV_OPERAND_TYPE_ID, // 448 + SPV_OPERAND_TYPE_OPTIONAL_PACKED_VECTOR_FORMAT, // 447 + SPV_OPERAND_TYPE_RESULT_ID, // 448 SPV_OPERAND_TYPE_ID, // 449 - SPV_OPERAND_TYPE_ID, // 450 + SPV_OPERAND_TYPE_SCOPE_ID, // 450 SPV_OPERAND_TYPE_ID, // 451 SPV_OPERAND_TYPE_ID, // 452 SPV_OPERAND_TYPE_ID, // 453 - SPV_OPERAND_TYPE_ID, // 454 - SPV_OPERAND_TYPE_ID, // 455 + SPV_OPERAND_TYPE_TYPE_ID, // 454 + SPV_OPERAND_TYPE_RESULT_ID, // 455 SPV_OPERAND_TYPE_ID, // 456 SPV_OPERAND_TYPE_ID, // 457 - SPV_OPERAND_TYPE_ID, // 458 - SPV_OPERAND_TYPE_ID, // 459 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 458 + SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 459 SPV_OPERAND_TYPE_ID, // 460 SPV_OPERAND_TYPE_ID, // 461 SPV_OPERAND_TYPE_ID, // 462 - SPV_OPERAND_TYPE_ID, // 463 - SPV_OPERAND_TYPE_ID, // 464 - SPV_OPERAND_TYPE_ID, // 465 - SPV_OPERAND_TYPE_ID, // 466 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 463 + SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 464 + SPV_OPERAND_TYPE_TYPE_ID, // 465 + SPV_OPERAND_TYPE_RESULT_ID, // 466 SPV_OPERAND_TYPE_ID, // 467 SPV_OPERAND_TYPE_ID, // 468 SPV_OPERAND_TYPE_ID, // 469 - SPV_OPERAND_TYPE_ID, // 470 + SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS, // 470 SPV_OPERAND_TYPE_ID, // 471 SPV_OPERAND_TYPE_ID, // 472 SPV_OPERAND_TYPE_ID, // 473 @@ -9169,17 +9281,17 @@ static const spv_operand_type_t kOperandSpans[] = { SPV_OPERAND_TYPE_ID, // 506 SPV_OPERAND_TYPE_ID, // 507 SPV_OPERAND_TYPE_ID, // 508 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 509 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 510 - SPV_OPERAND_TYPE_TYPE_ID, // 511 - SPV_OPERAND_TYPE_RESULT_ID, // 512 + SPV_OPERAND_TYPE_ID, // 509 + SPV_OPERAND_TYPE_ID, // 510 + SPV_OPERAND_TYPE_ID, // 511 + SPV_OPERAND_TYPE_ID, // 512 SPV_OPERAND_TYPE_ID, // 513 SPV_OPERAND_TYPE_ID, // 514 SPV_OPERAND_TYPE_ID, // 515 SPV_OPERAND_TYPE_ID, // 516 - SPV_OPERAND_TYPE_OPTIONAL_IMAGE, // 517 - SPV_OPERAND_TYPE_TYPE_ID, // 518 - SPV_OPERAND_TYPE_RESULT_ID, // 519 + SPV_OPERAND_TYPE_ID, // 517 + SPV_OPERAND_TYPE_ID, // 518 + SPV_OPERAND_TYPE_ID, // 519 SPV_OPERAND_TYPE_ID, // 520 SPV_OPERAND_TYPE_ID, // 521 SPV_OPERAND_TYPE_ID, // 522 @@ -9189,20 +9301,20 @@ static const spv_operand_type_t kOperandSpans[] = { SPV_OPERAND_TYPE_ID, // 526 SPV_OPERAND_TYPE_ID, // 527 SPV_OPERAND_TYPE_ID, // 528 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 529 - SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS, // 530 + SPV_OPERAND_TYPE_ID, // 529 + SPV_OPERAND_TYPE_ID, // 530 SPV_OPERAND_TYPE_ID, // 531 - SPV_OPERAND_TYPE_ID, // 532 - SPV_OPERAND_TYPE_ID, // 533 - SPV_OPERAND_TYPE_ID, // 534 - SPV_OPERAND_TYPE_ID, // 535 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 532 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 533 + SPV_OPERAND_TYPE_TYPE_ID, // 534 + SPV_OPERAND_TYPE_RESULT_ID, // 535 SPV_OPERAND_TYPE_ID, // 536 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 537 - SPV_OPERAND_TYPE_TYPE_ID, // 538 - SPV_OPERAND_TYPE_RESULT_ID, // 539 - SPV_OPERAND_TYPE_ID, // 540 - SPV_OPERAND_TYPE_ID, // 541 - SPV_OPERAND_TYPE_ID, // 542 + SPV_OPERAND_TYPE_ID, // 537 + SPV_OPERAND_TYPE_ID, // 538 + SPV_OPERAND_TYPE_ID, // 539 + SPV_OPERAND_TYPE_OPTIONAL_IMAGE, // 540 + SPV_OPERAND_TYPE_TYPE_ID, // 541 + SPV_OPERAND_TYPE_RESULT_ID, // 542 SPV_OPERAND_TYPE_ID, // 543 SPV_OPERAND_TYPE_ID, // 544 SPV_OPERAND_TYPE_ID, // 545 @@ -9217,96 +9329,96 @@ static const spv_operand_type_t kOperandSpans[] = { SPV_OPERAND_TYPE_ID, // 554 SPV_OPERAND_TYPE_ID, // 555 SPV_OPERAND_TYPE_ID, // 556 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 557 - SPV_OPERAND_TYPE_TYPE_ID, // 558 - SPV_OPERAND_TYPE_RESULT_ID, // 559 - SPV_OPERAND_TYPE_ID, // 560 - SPV_OPERAND_TYPE_ID, // 561 - SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 562 + SPV_OPERAND_TYPE_ID, // 557 + SPV_OPERAND_TYPE_ID, // 558 + SPV_OPERAND_TYPE_ID, // 559 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 560 + SPV_OPERAND_TYPE_TYPE_ID, // 561 + SPV_OPERAND_TYPE_RESULT_ID, // 562 SPV_OPERAND_TYPE_ID, // 563 SPV_OPERAND_TYPE_ID, // 564 SPV_OPERAND_TYPE_ID, // 565 - SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 566 - SPV_OPERAND_TYPE_RESULT_ID, // 567 + SPV_OPERAND_TYPE_ID, // 566 + SPV_OPERAND_TYPE_ID, // 567 SPV_OPERAND_TYPE_ID, // 568 - SPV_OPERAND_TYPE_SCOPE_ID, // 569 + SPV_OPERAND_TYPE_ID, // 569 SPV_OPERAND_TYPE_ID, // 570 SPV_OPERAND_TYPE_ID, // 571 - SPV_OPERAND_TYPE_TYPE_ID, // 572 - SPV_OPERAND_TYPE_RESULT_ID, // 573 + SPV_OPERAND_TYPE_ID, // 572 + SPV_OPERAND_TYPE_ID, // 573 SPV_OPERAND_TYPE_ID, // 574 - SPV_OPERAND_TYPE_ID, // 575 - SPV_OPERAND_TYPE_ID, // 576 - SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 577 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 575 + SPV_OPERAND_TYPE_OPTIONAL_COOPERATIVE_MATRIX_OPERANDS, // 576 + SPV_OPERAND_TYPE_ID, // 577 SPV_OPERAND_TYPE_ID, // 578 SPV_OPERAND_TYPE_ID, // 579 - SPV_OPERAND_TYPE_ID, // 580 - SPV_OPERAND_TYPE_ID, // 581 - SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 582 - SPV_OPERAND_TYPE_TYPE_ID, // 583 - SPV_OPERAND_TYPE_RESULT_ID, // 584 - SPV_OPERAND_TYPE_ID, // 585 - SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE, // 586 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 580 + SPV_OPERAND_TYPE_TYPE_ID, // 581 + SPV_OPERAND_TYPE_RESULT_ID, // 582 + SPV_OPERAND_TYPE_ID, // 583 + SPV_OPERAND_TYPE_ID, // 584 + SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 585 + SPV_OPERAND_TYPE_ID, // 586 SPV_OPERAND_TYPE_ID, // 587 - SPV_OPERAND_TYPE_TYPE_ID, // 588 - SPV_OPERAND_TYPE_RESULT_ID, // 589 - SPV_OPERAND_TYPE_ID, // 590 + SPV_OPERAND_TYPE_ID, // 588 + SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 589 + SPV_OPERAND_TYPE_RESULT_ID, // 590 SPV_OPERAND_TYPE_ID, // 591 - SPV_OPERAND_TYPE_ID, // 592 - SPV_OPERAND_TYPE_MEMORY_ACCESS, // 593 - SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS, // 594 - SPV_OPERAND_TYPE_ID, // 595 - SPV_OPERAND_TYPE_ID, // 596 + SPV_OPERAND_TYPE_SCOPE_ID, // 592 + SPV_OPERAND_TYPE_ID, // 593 + SPV_OPERAND_TYPE_ID, // 594 + SPV_OPERAND_TYPE_TYPE_ID, // 595 + SPV_OPERAND_TYPE_RESULT_ID, // 596 SPV_OPERAND_TYPE_ID, // 597 - SPV_OPERAND_TYPE_MEMORY_ACCESS, // 598 - SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS, // 599 - SPV_OPERAND_TYPE_RESULT_ID, // 600 + SPV_OPERAND_TYPE_ID, // 598 + SPV_OPERAND_TYPE_ID, // 599 + SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 600 SPV_OPERAND_TYPE_ID, // 601 SPV_OPERAND_TYPE_ID, // 602 - SPV_OPERAND_TYPE_VARIABLE_ID, // 603 - SPV_OPERAND_TYPE_TYPE_ID, // 604 - SPV_OPERAND_TYPE_RESULT_ID, // 605 - SPV_OPERAND_TYPE_ID, // 606 - SPV_OPERAND_TYPE_ID, // 607 + SPV_OPERAND_TYPE_ID, // 603 + SPV_OPERAND_TYPE_ID, // 604 + SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // 605 + SPV_OPERAND_TYPE_TYPE_ID, // 606 + SPV_OPERAND_TYPE_RESULT_ID, // 607 SPV_OPERAND_TYPE_ID, // 608 - SPV_OPERAND_TYPE_ID, // 609 - SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS, // 610 - SPV_OPERAND_TYPE_ID, // 611 - SPV_OPERAND_TYPE_ID, // 612 + SPV_OPERAND_TYPE_COOPERATIVE_MATRIX_REDUCE, // 609 + SPV_OPERAND_TYPE_ID, // 610 + SPV_OPERAND_TYPE_TYPE_ID, // 611 + SPV_OPERAND_TYPE_RESULT_ID, // 612 SPV_OPERAND_TYPE_ID, // 613 SPV_OPERAND_TYPE_ID, // 614 SPV_OPERAND_TYPE_ID, // 615 - SPV_OPERAND_TYPE_TYPE_ID, // 616 - SPV_OPERAND_TYPE_RESULT_ID, // 617 + SPV_OPERAND_TYPE_MEMORY_ACCESS, // 616 + SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS, // 617 SPV_OPERAND_TYPE_ID, // 618 SPV_OPERAND_TYPE_ID, // 619 - SPV_OPERAND_TYPE_LITERAL_STRING, // 620 - SPV_OPERAND_TYPE_LITERAL_STRING, // 621 - SPV_OPERAND_TYPE_TYPE_ID, // 622 + SPV_OPERAND_TYPE_ID, // 620 + SPV_OPERAND_TYPE_MEMORY_ACCESS, // 621 + SPV_OPERAND_TYPE_TENSOR_ADDRESSING_OPERANDS, // 622 SPV_OPERAND_TYPE_RESULT_ID, // 623 SPV_OPERAND_TYPE_ID, // 624 SPV_OPERAND_TYPE_ID, // 625 - SPV_OPERAND_TYPE_ID, // 626 - SPV_OPERAND_TYPE_ID, // 627 - SPV_OPERAND_TYPE_ID, // 628 + SPV_OPERAND_TYPE_VARIABLE_ID, // 626 + SPV_OPERAND_TYPE_TYPE_ID, // 627 + SPV_OPERAND_TYPE_RESULT_ID, // 628 SPV_OPERAND_TYPE_ID, // 629 SPV_OPERAND_TYPE_ID, // 630 - SPV_OPERAND_TYPE_TYPE_ID, // 631 - SPV_OPERAND_TYPE_RESULT_ID, // 632 - SPV_OPERAND_TYPE_ID, // 633 + SPV_OPERAND_TYPE_ID, // 631 + SPV_OPERAND_TYPE_ID, // 632 + SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS, // 633 SPV_OPERAND_TYPE_ID, // 634 SPV_OPERAND_TYPE_ID, // 635 SPV_OPERAND_TYPE_ID, // 636 SPV_OPERAND_TYPE_ID, // 637 SPV_OPERAND_TYPE_ID, // 638 - SPV_OPERAND_TYPE_ID, // 639 - SPV_OPERAND_TYPE_ID, // 640 - SPV_OPERAND_TYPE_TYPE_ID, // 641 - SPV_OPERAND_TYPE_RESULT_ID, // 642 - SPV_OPERAND_TYPE_ID, // 643 - SPV_OPERAND_TYPE_ID, // 644 - SPV_OPERAND_TYPE_ID, // 645 - SPV_OPERAND_TYPE_ID, // 646 + SPV_OPERAND_TYPE_TYPE_ID, // 639 + SPV_OPERAND_TYPE_RESULT_ID, // 640 + SPV_OPERAND_TYPE_ID, // 641 + SPV_OPERAND_TYPE_ID, // 642 + SPV_OPERAND_TYPE_LITERAL_STRING, // 643 + SPV_OPERAND_TYPE_LITERAL_STRING, // 644 + SPV_OPERAND_TYPE_TYPE_ID, // 645 + SPV_OPERAND_TYPE_RESULT_ID, // 646 SPV_OPERAND_TYPE_ID, // 647 SPV_OPERAND_TYPE_ID, // 648 SPV_OPERAND_TYPE_ID, // 649 @@ -9317,256 +9429,256 @@ static const spv_operand_type_t kOperandSpans[] = { SPV_OPERAND_TYPE_TYPE_ID, // 654 SPV_OPERAND_TYPE_RESULT_ID, // 655 SPV_OPERAND_TYPE_ID, // 656 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 657 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 658 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 659 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 660 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 661 - SPV_OPERAND_TYPE_TYPE_ID, // 662 - SPV_OPERAND_TYPE_RESULT_ID, // 663 - SPV_OPERAND_TYPE_ID, // 664 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 665 + SPV_OPERAND_TYPE_ID, // 657 + SPV_OPERAND_TYPE_ID, // 658 + SPV_OPERAND_TYPE_ID, // 659 + SPV_OPERAND_TYPE_ID, // 660 + SPV_OPERAND_TYPE_ID, // 661 + SPV_OPERAND_TYPE_ID, // 662 + SPV_OPERAND_TYPE_ID, // 663 + SPV_OPERAND_TYPE_TYPE_ID, // 664 + SPV_OPERAND_TYPE_RESULT_ID, // 665 SPV_OPERAND_TYPE_ID, // 666 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 667 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 668 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 669 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 670 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 671 - SPV_OPERAND_TYPE_TYPE_ID, // 672 - SPV_OPERAND_TYPE_RESULT_ID, // 673 + SPV_OPERAND_TYPE_ID, // 667 + SPV_OPERAND_TYPE_ID, // 668 + SPV_OPERAND_TYPE_ID, // 669 + SPV_OPERAND_TYPE_ID, // 670 + SPV_OPERAND_TYPE_ID, // 671 + SPV_OPERAND_TYPE_ID, // 672 + SPV_OPERAND_TYPE_ID, // 673 SPV_OPERAND_TYPE_ID, // 674 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 675 + SPV_OPERAND_TYPE_ID, // 675 SPV_OPERAND_TYPE_ID, // 676 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 677 + SPV_OPERAND_TYPE_TYPE_ID, // 677 SPV_OPERAND_TYPE_RESULT_ID, // 678 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 679 - SPV_OPERAND_TYPE_RESULT_ID, // 680 - SPV_OPERAND_TYPE_ID, // 681 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 682 - SPV_OPERAND_TYPE_VARIABLE_ID, // 683 - SPV_OPERAND_TYPE_TYPE_ID, // 684 - SPV_OPERAND_TYPE_RESULT_ID, // 685 - SPV_OPERAND_TYPE_ID, // 686 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 687 + SPV_OPERAND_TYPE_ID, // 679 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 680 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 681 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 682 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 683 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 684 + SPV_OPERAND_TYPE_TYPE_ID, // 685 + SPV_OPERAND_TYPE_RESULT_ID, // 686 + SPV_OPERAND_TYPE_ID, // 687 SPV_OPERAND_TYPE_LITERAL_INTEGER, // 688 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 689 + SPV_OPERAND_TYPE_ID, // 689 SPV_OPERAND_TYPE_LITERAL_INTEGER, // 690 - SPV_OPERAND_TYPE_ID, // 691 - SPV_OPERAND_TYPE_ID, // 692 - SPV_OPERAND_TYPE_ID, // 693 - SPV_OPERAND_TYPE_ID, // 694 - SPV_OPERAND_TYPE_ID, // 695 - SPV_OPERAND_TYPE_ID, // 696 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 691 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 692 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 693 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 694 + SPV_OPERAND_TYPE_TYPE_ID, // 695 + SPV_OPERAND_TYPE_RESULT_ID, // 696 SPV_OPERAND_TYPE_ID, // 697 - SPV_OPERAND_TYPE_ID, // 698 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 698 SPV_OPERAND_TYPE_ID, // 699 - SPV_OPERAND_TYPE_ID, // 700 - SPV_OPERAND_TYPE_ID, // 701 - SPV_OPERAND_TYPE_ID, // 702 - SPV_OPERAND_TYPE_ID, // 703 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 700 + SPV_OPERAND_TYPE_RESULT_ID, // 701 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 702 + SPV_OPERAND_TYPE_RESULT_ID, // 703 SPV_OPERAND_TYPE_ID, // 704 - SPV_OPERAND_TYPE_ID, // 705 - SPV_OPERAND_TYPE_ID, // 706 - SPV_OPERAND_TYPE_ID, // 707 - SPV_OPERAND_TYPE_ID, // 708 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 705 + SPV_OPERAND_TYPE_VARIABLE_ID, // 706 + SPV_OPERAND_TYPE_TYPE_ID, // 707 + SPV_OPERAND_TYPE_RESULT_ID, // 708 SPV_OPERAND_TYPE_ID, // 709 - SPV_OPERAND_TYPE_TYPE_ID, // 710 - SPV_OPERAND_TYPE_RESULT_ID, // 711 - SPV_OPERAND_TYPE_ID, // 712 - SPV_OPERAND_TYPE_ID, // 713 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 710 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 711 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 712 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 713 SPV_OPERAND_TYPE_ID, // 714 SPV_OPERAND_TYPE_ID, // 715 - SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS, // 716 - SPV_OPERAND_TYPE_TYPE_ID, // 717 - SPV_OPERAND_TYPE_RESULT_ID, // 718 + SPV_OPERAND_TYPE_ID, // 716 + SPV_OPERAND_TYPE_ID, // 717 + SPV_OPERAND_TYPE_ID, // 718 SPV_OPERAND_TYPE_ID, // 719 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 720 + SPV_OPERAND_TYPE_ID, // 720 SPV_OPERAND_TYPE_ID, // 721 SPV_OPERAND_TYPE_ID, // 722 SPV_OPERAND_TYPE_ID, // 723 SPV_OPERAND_TYPE_ID, // 724 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 725 + SPV_OPERAND_TYPE_ID, // 725 SPV_OPERAND_TYPE_ID, // 726 SPV_OPERAND_TYPE_ID, // 727 SPV_OPERAND_TYPE_ID, // 728 - SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING, // 729 + SPV_OPERAND_TYPE_ID, // 729 SPV_OPERAND_TYPE_ID, // 730 - SPV_OPERAND_TYPE_STORAGE_CLASS, // 731 - SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 732 - SPV_OPERAND_TYPE_ID, // 733 - SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER, // 734 + SPV_OPERAND_TYPE_ID, // 731 + SPV_OPERAND_TYPE_ID, // 732 + SPV_OPERAND_TYPE_TYPE_ID, // 733 + SPV_OPERAND_TYPE_RESULT_ID, // 734 SPV_OPERAND_TYPE_ID, // 735 SPV_OPERAND_TYPE_ID, // 736 SPV_OPERAND_TYPE_ID, // 737 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 738 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 739 + SPV_OPERAND_TYPE_ID, // 738 + SPV_OPERAND_TYPE_OPTIONAL_MATRIX_MULTIPLY_ACCUMULATE_OPERANDS, // 739 SPV_OPERAND_TYPE_ID, // 740 - SPV_OPERAND_TYPE_ID, // 741 + SPV_OPERAND_TYPE_EXECUTION_MODEL, // 741 SPV_OPERAND_TYPE_ID, // 742 - SPV_OPERAND_TYPE_ID, // 743 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 744 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 745 - SPV_OPERAND_TYPE_ID, // 746 - SPV_OPERAND_TYPE_ID, // 747 - SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 748 - SPV_OPERAND_TYPE_VARIABLE_ID, // 749 - SPV_OPERAND_TYPE_ID, // 750 - SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE, // 751 - SPV_OPERAND_TYPE_ID, // 752 + SPV_OPERAND_TYPE_LITERAL_STRING, // 743 + SPV_OPERAND_TYPE_VARIABLE_ID, // 744 + SPV_OPERAND_TYPE_ID, // 745 + SPV_OPERAND_TYPE_CAPABILITY, // 746 + SPV_OPERAND_TYPE_TYPE_ID, // 747 + SPV_OPERAND_TYPE_RESULT_ID, // 748 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 749 + SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER, // 750 + SPV_OPERAND_TYPE_TYPE_ID, // 751 + SPV_OPERAND_TYPE_RESULT_ID, // 752 SPV_OPERAND_TYPE_LITERAL_INTEGER, // 753 SPV_OPERAND_TYPE_LITERAL_INTEGER, // 754 - SPV_OPERAND_TYPE_ID, // 755 - SPV_OPERAND_TYPE_ID, // 756 - SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 757 - SPV_OPERAND_TYPE_VARIABLE_ID, // 758 - SPV_OPERAND_TYPE_ID, // 759 - SPV_OPERAND_TYPE_ID, // 760 - SPV_OPERAND_TYPE_ID, // 761 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 762 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 755 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 756 + SPV_OPERAND_TYPE_TYPE_ID, // 757 + SPV_OPERAND_TYPE_RESULT_ID, // 758 + SPV_OPERAND_TYPE_VARIABLE_CAPABILITY, // 759 + SPV_OPERAND_TYPE_TYPE_ID, // 760 + SPV_OPERAND_TYPE_RESULT_ID, // 761 + SPV_OPERAND_TYPE_ID, // 762 SPV_OPERAND_TYPE_LITERAL_INTEGER, // 763 SPV_OPERAND_TYPE_ID, // 764 SPV_OPERAND_TYPE_ID, // 765 SPV_OPERAND_TYPE_ID, // 766 - SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 767 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 768 + SPV_OPERAND_TYPE_ID, // 767 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 768 SPV_OPERAND_TYPE_ID, // 769 SPV_OPERAND_TYPE_ID, // 770 SPV_OPERAND_TYPE_ID, // 771 - SPV_OPERAND_TYPE_ID, // 772 - SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 773 - SPV_OPERAND_TYPE_ID, // 774 - SPV_OPERAND_TYPE_ID, // 775 + SPV_OPERAND_TYPE_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING, // 772 + SPV_OPERAND_TYPE_ID, // 773 + SPV_OPERAND_TYPE_STORAGE_CLASS, // 774 + SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 775 SPV_OPERAND_TYPE_ID, // 776 - SPV_OPERAND_TYPE_ID, // 777 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 778 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 779 + SPV_OPERAND_TYPE_DEBUG_TYPE_QUALIFIER, // 777 + SPV_OPERAND_TYPE_ID, // 778 + SPV_OPERAND_TYPE_ID, // 779 SPV_OPERAND_TYPE_ID, // 780 - SPV_OPERAND_TYPE_ID, // 781 - SPV_OPERAND_TYPE_ID, // 782 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 783 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 784 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 781 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 782 + SPV_OPERAND_TYPE_ID, // 783 + SPV_OPERAND_TYPE_ID, // 784 SPV_OPERAND_TYPE_ID, // 785 SPV_OPERAND_TYPE_ID, // 786 SPV_OPERAND_TYPE_LITERAL_INTEGER, // 787 SPV_OPERAND_TYPE_LITERAL_INTEGER, // 788 - SPV_OPERAND_TYPE_VARIABLE_ID, // 789 + SPV_OPERAND_TYPE_ID, // 789 SPV_OPERAND_TYPE_ID, // 790 - SPV_OPERAND_TYPE_ID, // 791 - SPV_OPERAND_TYPE_ID, // 792 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 793 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 794 + SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 791 + SPV_OPERAND_TYPE_VARIABLE_ID, // 792 + SPV_OPERAND_TYPE_ID, // 793 + SPV_OPERAND_TYPE_DEBUG_COMPOSITE_TYPE, // 794 SPV_OPERAND_TYPE_ID, // 795 - SPV_OPERAND_TYPE_ID, // 796 - SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 797 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 796 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 797 SPV_OPERAND_TYPE_ID, // 798 SPV_OPERAND_TYPE_ID, // 799 - SPV_OPERAND_TYPE_ID, // 800 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 801 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 802 + SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 800 + SPV_OPERAND_TYPE_VARIABLE_ID, // 801 + SPV_OPERAND_TYPE_ID, // 802 SPV_OPERAND_TYPE_ID, // 803 SPV_OPERAND_TYPE_ID, // 804 - SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 805 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 805 SPV_OPERAND_TYPE_LITERAL_INTEGER, // 806 SPV_OPERAND_TYPE_ID, // 807 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 808 + SPV_OPERAND_TYPE_ID, // 808 SPV_OPERAND_TYPE_ID, // 809 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 810 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 811 + SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 810 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 811 SPV_OPERAND_TYPE_ID, // 812 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 813 + SPV_OPERAND_TYPE_ID, // 813 SPV_OPERAND_TYPE_ID, // 814 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 815 - SPV_OPERAND_TYPE_ID, // 816 + SPV_OPERAND_TYPE_ID, // 815 + SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 816 SPV_OPERAND_TYPE_ID, // 817 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 818 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 819 + SPV_OPERAND_TYPE_ID, // 818 + SPV_OPERAND_TYPE_ID, // 819 SPV_OPERAND_TYPE_ID, // 820 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 821 - SPV_OPERAND_TYPE_ID, // 822 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 821 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 822 SPV_OPERAND_TYPE_ID, // 823 SPV_OPERAND_TYPE_ID, // 824 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 825 + SPV_OPERAND_TYPE_ID, // 825 SPV_OPERAND_TYPE_LITERAL_INTEGER, // 826 - SPV_OPERAND_TYPE_ID, // 827 - SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER, // 828 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 827 + SPV_OPERAND_TYPE_ID, // 828 SPV_OPERAND_TYPE_ID, // 829 - SPV_OPERAND_TYPE_ID, // 830 - SPV_OPERAND_TYPE_VARIABLE_ID, // 831 - SPV_OPERAND_TYPE_DEBUG_OPERATION, // 832 - SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER, // 833 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 830 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 831 + SPV_OPERAND_TYPE_VARIABLE_ID, // 832 + SPV_OPERAND_TYPE_ID, // 833 SPV_OPERAND_TYPE_ID, // 834 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 835 - SPV_OPERAND_TYPE_ID, // 836 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 837 + SPV_OPERAND_TYPE_ID, // 835 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 836 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 837 SPV_OPERAND_TYPE_ID, // 838 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 839 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 840 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 841 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 842 + SPV_OPERAND_TYPE_ID, // 839 + SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 840 + SPV_OPERAND_TYPE_ID, // 841 + SPV_OPERAND_TYPE_ID, // 842 SPV_OPERAND_TYPE_ID, // 843 - SPV_OPERAND_TYPE_ID, // 844 - SPV_OPERAND_TYPE_ID, // 845 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 844 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 845 SPV_OPERAND_TYPE_ID, // 846 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 847 - SPV_OPERAND_TYPE_ID, // 848 - SPV_OPERAND_TYPE_ID, // 849 + SPV_OPERAND_TYPE_ID, // 847 + SPV_OPERAND_TYPE_DEBUG_INFO_FLAGS, // 848 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 849 SPV_OPERAND_TYPE_ID, // 850 - SPV_OPERAND_TYPE_ID, // 851 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 851 SPV_OPERAND_TYPE_ID, // 852 - SPV_OPERAND_TYPE_ID, // 853 - SPV_OPERAND_TYPE_ID, // 854 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 853 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 854 SPV_OPERAND_TYPE_ID, // 855 - SPV_OPERAND_TYPE_VARIABLE_ID, // 856 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 856 SPV_OPERAND_TYPE_ID, // 857 - SPV_OPERAND_TYPE_ID, // 858 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 858 SPV_OPERAND_TYPE_ID, // 859 SPV_OPERAND_TYPE_ID, // 860 - SPV_OPERAND_TYPE_ID, // 861 - SPV_OPERAND_TYPE_ID, // 862 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 861 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 862 SPV_OPERAND_TYPE_ID, // 863 - SPV_OPERAND_TYPE_ID, // 864 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 864 SPV_OPERAND_TYPE_ID, // 865 - SPV_OPERAND_TYPE_VARIABLE_ID, // 866 + SPV_OPERAND_TYPE_ID, // 866 SPV_OPERAND_TYPE_ID, // 867 - SPV_OPERAND_TYPE_ID, // 868 - SPV_OPERAND_TYPE_ID, // 869 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 868 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 869 SPV_OPERAND_TYPE_ID, // 870 - SPV_OPERAND_TYPE_ID, // 871 - SPV_OPERAND_TYPE_ID, // 872 - SPV_OPERAND_TYPE_ID, // 873 + SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER, // 871 + SPV_OPERAND_TYPE_DEBUG_OPERATION, // 872 + SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER, // 873 SPV_OPERAND_TYPE_ID, // 874 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 875 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 875 SPV_OPERAND_TYPE_ID, // 876 - SPV_OPERAND_TYPE_ID, // 877 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 877 SPV_OPERAND_TYPE_ID, // 878 - SPV_OPERAND_TYPE_ID, // 879 - SPV_OPERAND_TYPE_VARIABLE_ID, // 880 - SPV_OPERAND_TYPE_ID, // 881 - SPV_OPERAND_TYPE_ID, // 882 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 879 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 880 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 881 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 882 SPV_OPERAND_TYPE_ID, // 883 SPV_OPERAND_TYPE_ID, // 884 SPV_OPERAND_TYPE_ID, // 885 SPV_OPERAND_TYPE_ID, // 886 - SPV_OPERAND_TYPE_ID, // 887 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 887 SPV_OPERAND_TYPE_ID, // 888 SPV_OPERAND_TYPE_ID, // 889 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 890 + SPV_OPERAND_TYPE_ID, // 890 SPV_OPERAND_TYPE_ID, // 891 SPV_OPERAND_TYPE_ID, // 892 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 893 + SPV_OPERAND_TYPE_ID, // 893 SPV_OPERAND_TYPE_ID, // 894 SPV_OPERAND_TYPE_ID, // 895 - SPV_OPERAND_TYPE_ID, // 896 + SPV_OPERAND_TYPE_VARIABLE_ID, // 896 SPV_OPERAND_TYPE_ID, // 897 SPV_OPERAND_TYPE_ID, // 898 SPV_OPERAND_TYPE_ID, // 899 SPV_OPERAND_TYPE_ID, // 900 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 901 + SPV_OPERAND_TYPE_ID, // 901 SPV_OPERAND_TYPE_ID, // 902 SPV_OPERAND_TYPE_ID, // 903 SPV_OPERAND_TYPE_ID, // 904 - SPV_OPERAND_TYPE_VARIABLE_ID, // 905 - SPV_OPERAND_TYPE_ID, // 906 + SPV_OPERAND_TYPE_ID, // 905 + SPV_OPERAND_TYPE_VARIABLE_ID, // 906 SPV_OPERAND_TYPE_ID, // 907 SPV_OPERAND_TYPE_ID, // 908 SPV_OPERAND_TYPE_ID, // 909 @@ -9575,12 +9687,12 @@ static const spv_operand_type_t kOperandSpans[] = { SPV_OPERAND_TYPE_ID, // 912 SPV_OPERAND_TYPE_ID, // 913 SPV_OPERAND_TYPE_ID, // 914 - SPV_OPERAND_TYPE_ID, // 915 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 915 SPV_OPERAND_TYPE_ID, // 916 SPV_OPERAND_TYPE_ID, // 917 SPV_OPERAND_TYPE_ID, // 918 SPV_OPERAND_TYPE_ID, // 919 - SPV_OPERAND_TYPE_ID, // 920 + SPV_OPERAND_TYPE_VARIABLE_ID, // 920 SPV_OPERAND_TYPE_ID, // 921 SPV_OPERAND_TYPE_ID, // 922 SPV_OPERAND_TYPE_ID, // 923 @@ -9590,10 +9702,10 @@ static const spv_operand_type_t kOperandSpans[] = { SPV_OPERAND_TYPE_ID, // 927 SPV_OPERAND_TYPE_ID, // 928 SPV_OPERAND_TYPE_ID, // 929 - SPV_OPERAND_TYPE_ID, // 930 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 930 SPV_OPERAND_TYPE_ID, // 931 SPV_OPERAND_TYPE_ID, // 932 - SPV_OPERAND_TYPE_ID, // 933 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 933 SPV_OPERAND_TYPE_ID, // 934 SPV_OPERAND_TYPE_ID, // 935 SPV_OPERAND_TYPE_ID, // 936 @@ -9601,11 +9713,11 @@ static const spv_operand_type_t kOperandSpans[] = { SPV_OPERAND_TYPE_ID, // 938 SPV_OPERAND_TYPE_ID, // 939 SPV_OPERAND_TYPE_ID, // 940 - SPV_OPERAND_TYPE_ID, // 941 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 941 SPV_OPERAND_TYPE_ID, // 942 SPV_OPERAND_TYPE_ID, // 943 SPV_OPERAND_TYPE_ID, // 944 - SPV_OPERAND_TYPE_ID, // 945 + SPV_OPERAND_TYPE_VARIABLE_ID, // 945 SPV_OPERAND_TYPE_ID, // 946 SPV_OPERAND_TYPE_ID, // 947 SPV_OPERAND_TYPE_ID, // 948 @@ -9633,104 +9745,144 @@ static const spv_operand_type_t kOperandSpans[] = { SPV_OPERAND_TYPE_ID, // 970 SPV_OPERAND_TYPE_ID, // 971 SPV_OPERAND_TYPE_ID, // 972 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 973 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 974 + SPV_OPERAND_TYPE_ID, // 973 + SPV_OPERAND_TYPE_ID, // 974 SPV_OPERAND_TYPE_ID, // 975 - SPV_OPERAND_TYPE_SOURCE_LANGUAGE, // 976 + SPV_OPERAND_TYPE_ID, // 976 SPV_OPERAND_TYPE_ID, // 977 SPV_OPERAND_TYPE_ID, // 978 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING, // 979 + SPV_OPERAND_TYPE_ID, // 979 SPV_OPERAND_TYPE_ID, // 980 - SPV_OPERAND_TYPE_STORAGE_CLASS, // 981 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 982 + SPV_OPERAND_TYPE_ID, // 981 + SPV_OPERAND_TYPE_ID, // 982 SPV_OPERAND_TYPE_ID, // 983 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER, // 984 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 985 + SPV_OPERAND_TYPE_ID, // 984 + SPV_OPERAND_TYPE_ID, // 985 SPV_OPERAND_TYPE_ID, // 986 - SPV_OPERAND_TYPE_VARIABLE_ID, // 987 + SPV_OPERAND_TYPE_ID, // 987 SPV_OPERAND_TYPE_ID, // 988 SPV_OPERAND_TYPE_ID, // 989 SPV_OPERAND_TYPE_ID, // 990 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 991 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 992 + SPV_OPERAND_TYPE_ID, // 991 + SPV_OPERAND_TYPE_ID, // 992 SPV_OPERAND_TYPE_ID, // 993 SPV_OPERAND_TYPE_ID, // 994 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 995 - SPV_OPERAND_TYPE_VARIABLE_ID, // 996 + SPV_OPERAND_TYPE_ID, // 995 + SPV_OPERAND_TYPE_ID, // 996 SPV_OPERAND_TYPE_ID, // 997 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE, // 998 + SPV_OPERAND_TYPE_ID, // 998 SPV_OPERAND_TYPE_ID, // 999 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1000 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1001 + SPV_OPERAND_TYPE_ID, // 1000 + SPV_OPERAND_TYPE_ID, // 1001 SPV_OPERAND_TYPE_ID, // 1002 SPV_OPERAND_TYPE_ID, // 1003 SPV_OPERAND_TYPE_ID, // 1004 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1005 - SPV_OPERAND_TYPE_VARIABLE_ID, // 1006 + SPV_OPERAND_TYPE_ID, // 1005 + SPV_OPERAND_TYPE_ID, // 1006 SPV_OPERAND_TYPE_ID, // 1007 SPV_OPERAND_TYPE_ID, // 1008 SPV_OPERAND_TYPE_ID, // 1009 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1010 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1011 + SPV_OPERAND_TYPE_ID, // 1010 + SPV_OPERAND_TYPE_ID, // 1011 SPV_OPERAND_TYPE_ID, // 1012 - SPV_OPERAND_TYPE_ID, // 1013 - SPV_OPERAND_TYPE_ID, // 1014 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1015 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 1016 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1013 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1014 + SPV_OPERAND_TYPE_ID, // 1015 + SPV_OPERAND_TYPE_SOURCE_LANGUAGE, // 1016 SPV_OPERAND_TYPE_ID, // 1017 SPV_OPERAND_TYPE_ID, // 1018 - SPV_OPERAND_TYPE_ID, // 1019 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_BASE_TYPE_ATTRIBUTE_ENCODING, // 1019 SPV_OPERAND_TYPE_ID, // 1020 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1021 - SPV_OPERAND_TYPE_ID, // 1022 + SPV_OPERAND_TYPE_STORAGE_CLASS, // 1021 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1022 SPV_OPERAND_TYPE_ID, // 1023 - SPV_OPERAND_TYPE_ID, // 1024 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1025 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1026 - SPV_OPERAND_TYPE_ID, // 1027 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_TYPE_QUALIFIER, // 1024 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1025 + SPV_OPERAND_TYPE_ID, // 1026 + SPV_OPERAND_TYPE_VARIABLE_ID, // 1027 SPV_OPERAND_TYPE_ID, // 1028 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1029 + SPV_OPERAND_TYPE_ID, // 1029 SPV_OPERAND_TYPE_ID, // 1030 - SPV_OPERAND_TYPE_ID, // 1031 - SPV_OPERAND_TYPE_ID, // 1032 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1033 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1034 - SPV_OPERAND_TYPE_ID, // 1035 - SPV_OPERAND_TYPE_ID, // 1036 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1037 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1038 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1031 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1032 + SPV_OPERAND_TYPE_ID, // 1033 + SPV_OPERAND_TYPE_ID, // 1034 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1035 + SPV_OPERAND_TYPE_VARIABLE_ID, // 1036 + SPV_OPERAND_TYPE_ID, // 1037 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_COMPOSITE_TYPE, // 1038 SPV_OPERAND_TYPE_ID, // 1039 - SPV_OPERAND_TYPE_OPTIONAL_ID, // 1040 - SPV_OPERAND_TYPE_ID, // 1041 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1040 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1041 SPV_OPERAND_TYPE_ID, // 1042 SPV_OPERAND_TYPE_ID, // 1043 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1044 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1045 - SPV_OPERAND_TYPE_ID, // 1046 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1047 - SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER, // 1048 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION, // 1049 - SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER, // 1050 - SPV_OPERAND_TYPE_ID, // 1051 - SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY, // 1052 + SPV_OPERAND_TYPE_ID, // 1044 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1045 + SPV_OPERAND_TYPE_VARIABLE_ID, // 1046 + SPV_OPERAND_TYPE_ID, // 1047 + SPV_OPERAND_TYPE_ID, // 1048 + SPV_OPERAND_TYPE_ID, // 1049 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1050 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1051 + SPV_OPERAND_TYPE_ID, // 1052 SPV_OPERAND_TYPE_ID, // 1053 SPV_OPERAND_TYPE_ID, // 1054 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1055 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1056 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1055 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 1056 SPV_OPERAND_TYPE_ID, // 1057 SPV_OPERAND_TYPE_ID, // 1058 SPV_OPERAND_TYPE_ID, // 1059 SPV_OPERAND_TYPE_ID, // 1060 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1061 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1061 SPV_OPERAND_TYPE_ID, // 1062 SPV_OPERAND_TYPE_ID, // 1063 SPV_OPERAND_TYPE_ID, // 1064 SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1065 - SPV_OPERAND_TYPE_ID, // 1066 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1066 SPV_OPERAND_TYPE_ID, // 1067 - SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1068 - SPV_OPERAND_TYPE_ID, // 1069 + SPV_OPERAND_TYPE_ID, // 1068 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1069 SPV_OPERAND_TYPE_ID, // 1070 SPV_OPERAND_TYPE_ID, // 1071 - SPV_OPERAND_TYPE_FP_ROUNDING_MODE, // 1072 + SPV_OPERAND_TYPE_ID, // 1072 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1073 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1074 + SPV_OPERAND_TYPE_ID, // 1075 + SPV_OPERAND_TYPE_ID, // 1076 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1077 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1078 + SPV_OPERAND_TYPE_ID, // 1079 + SPV_OPERAND_TYPE_OPTIONAL_ID, // 1080 + SPV_OPERAND_TYPE_ID, // 1081 + SPV_OPERAND_TYPE_ID, // 1082 + SPV_OPERAND_TYPE_ID, // 1083 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1084 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1085 + SPV_OPERAND_TYPE_ID, // 1086 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_INFO_FLAGS, // 1087 + SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER, // 1088 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_OPERATION, // 1089 + SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER, // 1090 + SPV_OPERAND_TYPE_ID, // 1091 + SPV_OPERAND_TYPE_CLDEBUG100_DEBUG_IMPORTED_ENTITY, // 1092 + SPV_OPERAND_TYPE_ID, // 1093 + SPV_OPERAND_TYPE_ID, // 1094 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1095 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1096 + SPV_OPERAND_TYPE_ID, // 1097 + SPV_OPERAND_TYPE_ID, // 1098 + SPV_OPERAND_TYPE_ID, // 1099 + SPV_OPERAND_TYPE_ID, // 1100 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1101 + SPV_OPERAND_TYPE_ID, // 1102 + SPV_OPERAND_TYPE_ID, // 1103 + SPV_OPERAND_TYPE_ID, // 1104 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1105 + SPV_OPERAND_TYPE_ID, // 1106 + SPV_OPERAND_TYPE_ID, // 1107 + SPV_OPERAND_TYPE_LITERAL_INTEGER, // 1108 + SPV_OPERAND_TYPE_ID, // 1109 + SPV_OPERAND_TYPE_ID, // 1110 + SPV_OPERAND_TYPE_ID, // 1111 + SPV_OPERAND_TYPE_FP_ROUNDING_MODE, // 1112 }; diff --git a/libs/bgfx/3rdparty/spirv-tools/include/generated/core_tables_header.inc b/libs/bgfx/3rdparty/spirv-tools/include/generated/core_tables_header.inc index 3e1067f..ee68efc 100644 --- a/libs/bgfx/3rdparty/spirv-tools/include/generated/core_tables_header.inc +++ b/libs/bgfx/3rdparty/spirv-tools/include/generated/core_tables_header.inc @@ -13,6 +13,7 @@ enum class PrintingClass : uint32_t { kDevice_Side_Enqueue, kExtension, kFunction, + kGraph, kGroup, kImage, kMemory, @@ -43,6 +44,7 @@ enum Extension : uint32_t { kSPV_AMD_texture_gather_bias_lod, kSPV_ARM_cooperative_matrix_layouts, kSPV_ARM_core_builtins, + kSPV_ARM_graph, kSPV_ARM_tensors, kSPV_EXT_arithmetic_fence, kSPV_EXT_demote_to_helper_invocation, @@ -91,6 +93,7 @@ enum Extension : uint32_t { kSPV_INTEL_fpga_memory_attributes, kSPV_INTEL_fpga_reg, kSPV_INTEL_function_pointers, + kSPV_INTEL_function_variants, kSPV_INTEL_global_variable_fpga_decorations, kSPV_INTEL_global_variable_host_access, kSPV_INTEL_inline_assembly, @@ -127,6 +130,7 @@ enum Extension : uint32_t { kSPV_KHR_expect_assume, kSPV_KHR_float_controls, kSPV_KHR_float_controls2, + kSPV_KHR_fma, kSPV_KHR_fragment_shader_barycentric, kSPV_KHR_fragment_shading_rate, kSPV_KHR_integer_dot_product, @@ -182,6 +186,7 @@ enum Extension : uint32_t { kSPV_NV_stereo_view_rendering, kSPV_NV_tensor_addressing, kSPV_NV_viewport_array2, + kSPV_QCOM_cooperative_matrix_conversion, kSPV_QCOM_image_processing, kSPV_QCOM_image_processing2, kSPV_QCOM_tile_shading, diff --git a/libs/bgfx/3rdparty/spirv-tools/include/generated/generators.inc b/libs/bgfx/3rdparty/spirv-tools/include/generated/generators.inc index 71fb3c5..67aa737 100644 --- a/libs/bgfx/3rdparty/spirv-tools/include/generated/generators.inc +++ b/libs/bgfx/3rdparty/spirv-tools/include/generated/generators.inc @@ -46,4 +46,5 @@ {45, "Kitsunebi Games", "Nuvk SPIR-V Emitter and DLSL compiler", "Kitsunebi Games Nuvk SPIR-V Emitter and DLSL compiler"}, {46, "Nintendo", "", "Nintendo"}, {47, "ARM", "", "ARM"}, -{48, "Goopax", "", "Goopax"}, \ No newline at end of file +{48, "Goopax", "", "Goopax"}, +{49, "Icyllis Milica", "Arc3D Shader Compiler", "Icyllis Milica Arc3D Shader Compiler"}, \ No newline at end of file diff --git a/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/libspirv.h b/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/libspirv.h index 7a076c0..347f540 100644 --- a/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/libspirv.h +++ b/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/libspirv.h @@ -80,6 +80,8 @@ typedef enum spv_result_t { SPV_ERROR_INVALID_DATA = -14, // Indicates data rules validation failure. SPV_ERROR_MISSING_EXTENSION = -15, SPV_ERROR_WRONG_VERSION = -16, // Indicates wrong SPIR-V version + SPV_ERROR_FNVAR = + -17, // Error related to SPV_INTEL_function_variants extension SPV_FORCE_32_BIT_ENUM(spv_result_t) } spv_result_t; @@ -189,36 +191,24 @@ typedef enum spv_operand_type_t { SPV_OPERAND_TYPE_MEMORY_ACCESS, // SPIR-V Sec 3.26 SPV_OPERAND_TYPE_FRAGMENT_SHADING_RATE, // SPIR-V Sec 3.FSR -// NOTE: New concrete enum values should be added at the end. - -// The "optional" and "variable" operand types are only used internally by -// the assembler and the binary parser. -// There are two categories: -// Optional : expands to 0 or 1 operand, like ? in regular expressions. -// Variable : expands to 0, 1 or many operands or pairs of operands. -// This is similar to * in regular expressions. - -// NOTE: These FIRST_* and LAST_* enum values are DEPRECATED. -// The concept of "optional" and "variable" operand types are only intended -// for use as an implementation detail of parsing SPIR-V, either in text or -// binary form. Instead of using enum ranges, use characteristic function -// spvOperandIsConcrete. -// The use of enum value ranges in a public API makes it difficult to insert -// new values into a range without also breaking binary compatibility. -// -// Macros for defining bounds on optional and variable operand types. -// Any variable operand type is also optional. -// TODO(dneto): Remove SPV_OPERAND_TYPE_FIRST_* and SPV_OPERAND_TYPE_LAST_* -#define FIRST_OPTIONAL(ENUM) ENUM, SPV_OPERAND_TYPE_FIRST_OPTIONAL_TYPE = ENUM -#define FIRST_VARIABLE(ENUM) ENUM, SPV_OPERAND_TYPE_FIRST_VARIABLE_TYPE = ENUM -#define LAST_VARIABLE(ENUM) \ - ENUM, SPV_OPERAND_TYPE_LAST_VARIABLE_TYPE = ENUM, \ - SPV_OPERAND_TYPE_LAST_OPTIONAL_TYPE = ENUM + // NOTE: New concrete enum values should be added at the end. + + // The "optional" and "variable" operand types are only used internally by + // the assembler and the binary parser. + // There are two categories: + // Optional : expands to 0 or 1 operand, like ? in regular expressions. + // Variable : expands to 0, 1 or many operands or pairs of operands. + // This is similar to * in regular expressions. + + // Use characteristic function spvOperandIsConcrete to classify the + // operand types; when it returns false, the operand is optional or variable. + // + // Any variable operand type is also optional. // An optional operand represents zero or one logical operands. // In an instruction definition, this may only appear at the end of the // operand types. - FIRST_OPTIONAL(SPV_OPERAND_TYPE_OPTIONAL_ID), + SPV_OPERAND_TYPE_OPTIONAL_ID, // An optional image operand type. SPV_OPERAND_TYPE_OPTIONAL_IMAGE, // An optional memory access type. @@ -243,7 +233,7 @@ typedef enum spv_operand_type_t { // A variable operand represents zero or more logical operands. // In an instruction definition, this may only appear at the end of the // operand types. - FIRST_VARIABLE(SPV_OPERAND_TYPE_VARIABLE_ID), + SPV_OPERAND_TYPE_VARIABLE_ID, SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER, // A sequence of zero or more pairs of (typed literal integer, Id). // Expands to zero or more: @@ -251,7 +241,7 @@ typedef enum spv_operand_type_t { // where the literal number must always be an integer of some sort. SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER_ID, // A sequence of zero or more pairs of (Id, Literal integer) - LAST_VARIABLE(SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER), + SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER, // The following are concrete enum types from the DebugInfo extended // instruction set. @@ -344,6 +334,10 @@ typedef enum spv_operand_type_t { SPV_OPERAND_TYPE_TENSOR_OPERANDS, SPV_OPERAND_TYPE_OPTIONAL_TENSOR_OPERANDS, + // SPV_INTEL_function_variants + SPV_OPERAND_TYPE_OPTIONAL_CAPABILITY, + SPV_OPERAND_TYPE_VARIABLE_CAPABILITY, + // This is a sentinel value, and does not represent an operand type. // It should come last. SPV_OPERAND_TYPE_NUM_OPERAND_TYPES, @@ -370,6 +364,8 @@ typedef enum spv_ext_inst_type_t { SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION, SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100, SPV_EXT_INST_TYPE_NONSEMANTIC_VKSPREFLECTION, + SPV_EXT_INST_TYPE_TOSA_001000_1, + SPV_EXT_INST_TYPE_ARM_MOTION_ENGINE_100, // Multiple distinct extended instruction set types could return this // value, if they are prefixed with NonSemantic. and are otherwise @@ -438,7 +434,7 @@ typedef enum spv_binary_to_text_options_t { // The default id bound is to the minimum value for the id limit // in the spir-v specification under the section "Universal Limits". -const uint32_t kDefaultMaxIdBound = 0x3FFFFF; +const static uint32_t kDefaultMaxIdBound = 0x3FFFFF; // Structures @@ -772,6 +768,7 @@ SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowOffsetTextureOperand( spv_validator_options options, bool val); // Allow base operands of some bit operations to be non-32-bit wide. +// Was added for VK_KHR_maintenance9 SPIRV_TOOLS_EXPORT void spvValidatorOptionsSetAllowVulkan32BitBitwise( spv_validator_options options, bool val); diff --git a/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/libspirv.hpp b/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/libspirv.hpp index 2cbb749..1b3ed86 100644 --- a/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/libspirv.hpp +++ b/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/libspirv.hpp @@ -133,6 +133,7 @@ class SPIRV_TOOLS_EXPORT ValidatorOptions { } // Allow base operands of some bit operations to be non-32-bit wide. + // Was added for VK_KHR_maintenance9 void SetAllowVulkan32BitBitwise(bool val) { spvValidatorOptionsSetAllowVulkan32BitBitwise(options_, val); } diff --git a/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/linker.hpp b/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/linker.hpp index 9037b94..99527ed 100644 --- a/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/linker.hpp +++ b/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/linker.hpp @@ -67,12 +67,36 @@ class SPIRV_TOOLS_EXPORT LinkerOptions { allow_ptr_type_mismatch_ = allow_ptr_type_mismatch; } + std::string GetFnVarTargetsCsv() const { return fnvar_targets_csv_; } + void SetFnVarTargetsCsv(std::string fnvar_targets_csv) { + fnvar_targets_csv_ = fnvar_targets_csv; + } + + std::string GetFnVarArchitecturesCsv() const { + return fnvar_architectures_csv_; + } + void SetFnVarArchitecturesCsv(std::string fnvar_architectures_csv) { + fnvar_architectures_csv_ = fnvar_architectures_csv; + } + + bool GetHasFnVarCapabilities() const { return has_fnvar_capabilities_; } + void SetHasFnVarCapabilities(bool fnvar_capabilities) { + has_fnvar_capabilities_ = fnvar_capabilities; + } + + std::vector GetInFiles() const { return in_files_; } + void SetInFiles(std::vector in_files) { in_files_ = in_files; } + private: bool create_library_{false}; bool verify_ids_{false}; bool allow_partial_linkage_{false}; bool use_highest_version_{false}; bool allow_ptr_type_mismatch_{false}; + std::string fnvar_targets_csv_{""}; + std::string fnvar_architectures_csv_{""}; + bool has_fnvar_capabilities_ = false; + std::vector in_files_{{}}; }; // Links one or more SPIR-V modules into a new SPIR-V module. That is, combine diff --git a/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/optimizer.hpp b/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/optimizer.hpp index 5fb9a33..b25ad47 100644 --- a/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/optimizer.hpp +++ b/libs/bgfx/3rdparty/spirv-tools/include/spirv-tools/optimizer.hpp @@ -1022,6 +1022,16 @@ Optimizer::PassToken CreateSplitCombinedImageSamplerPass(); // This pass assumes binding numbers are not applid via decoration groups // (OpDecorationGroup). Optimizer::PassToken CreateResolveBindingConflictsPass(); + +// Create a pass to canonicalize IDs to improve compression of SPIR-V binary +// files. The resulting modules have an increased ID range (IDs are not as +// tightly packed around zero), but will compress better when multiple modules +// are compressed together, since the compressor's dictionary can find better +// cross module commonality. This pass should be run after most optimization +// passes except for +// --strip-debug because this pass will use OpName to canonicalize IDs. i.e. Run +// --strip-debug after this pass. +Optimizer::PassToken CreateCanonicalizeIdsPass(); } // namespace spvtools #endif // INCLUDE_SPIRV_TOOLS_OPTIMIZER_HPP_ diff --git a/libs/bgfx/3rdparty/spirv-tools/source/binary.cpp b/libs/bgfx/3rdparty/spirv-tools/source/binary.cpp index 180d0a9..997a30c 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/binary.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/binary.cpp @@ -636,6 +636,7 @@ spv_result_t Parser::parseOperand(size_t inst_offset, } break; case SPV_OPERAND_TYPE_CAPABILITY: + case SPV_OPERAND_TYPE_OPTIONAL_CAPABILITY: case SPV_OPERAND_TYPE_EXECUTION_MODEL: case SPV_OPERAND_TYPE_ADDRESSING_MODEL: case SPV_OPERAND_TYPE_MEMORY_MODEL: @@ -689,6 +690,8 @@ spv_result_t Parser::parseOperand(size_t inst_offset, parsed_operand.type = SPV_OPERAND_TYPE_PACKED_VECTOR_FORMAT; if (type == SPV_OPERAND_TYPE_OPTIONAL_FPENCODING) parsed_operand.type = SPV_OPERAND_TYPE_FPENCODING; + if (type == SPV_OPERAND_TYPE_OPTIONAL_CAPABILITY) + parsed_operand.type = SPV_OPERAND_TYPE_CAPABILITY; const spvtools::OperandDesc* entry = nullptr; if (spvtools::LookupOperand(type, word, &entry)) { @@ -853,7 +856,7 @@ void Parser::recordNumberType(size_t inst_offset, info.type = SPV_NUMBER_FLOATING; info.bit_width = peekAt(inst_offset + 2); if (inst->num_words >= 4) { - const spvtools::OperandDesc* desc; + const spvtools::OperandDesc* desc = nullptr; spv_result_t status = spvtools::LookupOperand( SPV_OPERAND_TYPE_FPENCODING, peekAt(inst_offset + 3), &desc); if (status == SPV_SUCCESS) { diff --git a/libs/bgfx/3rdparty/spirv-tools/source/disassemble.cpp b/libs/bgfx/3rdparty/spirv-tools/source/disassemble.cpp index 2d9bb0f..43db1da 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/disassemble.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/disassemble.cpp @@ -694,12 +694,12 @@ void InstructionDisassembler::EmitInstructionImpl( } if (inst.result_id) { - SetBlue(); + SetBlue(line); const std::string id_name = name_mapper_(inst.result_id); if (indent_) line << std::setw(std::max(0, indent_ - 3 - int(id_name.size()))); line << "%" << id_name; - ResetColor(); + ResetColor(line); line << " = "; } else { line << std::string(indent_, ' '); @@ -907,6 +907,7 @@ void InstructionDisassembler::EmitOperand(std::ostream& stream, stream << '"'; } break; case SPV_OPERAND_TYPE_CAPABILITY: + case SPV_OPERAND_TYPE_OPTIONAL_CAPABILITY: case SPV_OPERAND_TYPE_SOURCE_LANGUAGE: case SPV_OPERAND_TYPE_EXECUTION_MODEL: case SPV_OPERAND_TYPE_ADDRESSING_MODEL: diff --git a/libs/bgfx/3rdparty/spirv-tools/source/ext_inst.cpp b/libs/bgfx/3rdparty/spirv-tools/source/ext_inst.cpp index c8fe8bb..a616a1e 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/ext_inst.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/ext_inst.cpp @@ -55,6 +55,12 @@ spv_ext_inst_type_t spvExtInstImportTypeGet(const char* name) { if (!strncmp("NonSemantic.VkspReflection.", name, 27)) { return SPV_EXT_INST_TYPE_NONSEMANTIC_VKSPREFLECTION; } + if (!strcmp("TOSA.001000.1", name)) { + return SPV_EXT_INST_TYPE_TOSA_001000_1; + } + if (!strcmp("Arm.MotionEngine.100", name)) { + return SPV_EXT_INST_TYPE_ARM_MOTION_ENGINE_100; + } // ensure to add any known non-semantic extended instruction sets // above this point, and update spvExtInstIsNonSemantic() if (!strncmp("NonSemantic.", name, 12)) { diff --git a/libs/bgfx/3rdparty/spirv-tools/source/extensions.cpp b/libs/bgfx/3rdparty/spirv-tools/source/extensions.cpp index 91136e6..ab4caa0 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/extensions.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/extensions.cpp @@ -24,18 +24,24 @@ namespace spvtools { std::string GetExtensionString(const spv_parsed_instruction_t* inst) { - if (inst->opcode != static_cast(spv::Op::OpExtension)) { + if ((inst->opcode != static_cast(spv::Op::OpExtension)) && + (inst->opcode != + static_cast(spv::Op::OpConditionalExtensionINTEL))) { return "ERROR_not_op_extension"; } - assert(inst->num_operands == 1); + const bool is_conditional = + inst->opcode == + static_cast(spv::Op::OpConditionalExtensionINTEL); + assert(inst->num_operands == (is_conditional ? 2 : 1)); + const uint16_t op_i = is_conditional ? 1 : 0; - const auto& operand = inst->operands[0]; + const auto& operand = inst->operands[op_i]; assert(operand.type == SPV_OPERAND_TYPE_LITERAL_STRING); assert(inst->num_words > operand.offset); (void)operand; /* No unused variables in release builds. */ - return spvDecodeLiteralStringOperand(*inst, 0); + return spvDecodeLiteralStringOperand(*inst, op_i); } std::string ExtensionSetToString(const ExtensionSet& extensions) { diff --git a/libs/bgfx/3rdparty/spirv-tools/source/link/fnvar.cpp b/libs/bgfx/3rdparty/spirv-tools/source/link/fnvar.cpp new file mode 100644 index 0000000..352e7ea --- /dev/null +++ b/libs/bgfx/3rdparty/spirv-tools/source/link/fnvar.cpp @@ -0,0 +1,1011 @@ +// Copyright 2025 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "fnvar.h" + +#include +#include +#include + +#include "source/opt/instruction.h" + +namespace spvtools { + +using opt::Function; +using opt::Instruction; +using opt::analysis::Type; + +namespace { +// Helper functions + +// Parses a CSV source string for the purpose of this extension. +// +// Required columns must be known in advance and supplied as the required_cols +// argument -- this is used for error checking. Values are assumed to be +// separated by CSV_SEP. The input source string is assumed to be the output of +// io::ReadTextFile and no other validation, apart from the CSV parsing, is +// performed. +// +// Returns true on success, false on error (with error message stored in +// err_msg). +bool ParseCsv(const std::string& source, + const std::vector& required_cols, + std::stringstream& err_msg, + std::vector>& result) { + std::stringstream fn_variants_csv_stream(source); + std::string line; + std::vector columns; + constexpr char CSV_SEP = ','; + bool first_line = true; + + while (std::getline(fn_variants_csv_stream, line, '\n')) { + if (line.empty()) { + continue; + } + + std::vector vals; + std::string val; + std::stringstream line_stream(line); + auto* vec = first_line ? &columns : &vals; + + while (std::getline(line_stream, val, CSV_SEP)) { + vec->push_back(val); + } + + if (!line_stream && val.empty()) { + vec->push_back(""); + } + + if (!first_line) { + if (vals.size() != columns.size()) { + err_msg << "Number of values does not match the number of columns. " + "Offending line:\n" + << line; + return false; + } + result.push_back(vals); + } + + first_line = false; + } + + // check if required columns match actual columns (ordering matters) + + if (columns.size() != required_cols.size()) { + err_msg << "Invalid number of CSV columns: " << columns.size() + << ", expected " << required_cols.size() << "."; + return false; + } + + for (size_t i = 0; i < columns.size(); ++i) { + if (columns[i] != required_cols[i]) { + err_msg << "Invalid name of column " << i + 1 << ". Expected '" + << required_cols[i] << "', got '" << columns[i] << "'."; + return false; + } + } + + return true; +} + +// Annotate ID with ConditionalINTEL decoration +void DecorateConditional(IRContext* context, uint32_t id_to_decorate, + uint32_t spec_const_id) { + auto decor_instr = + std::make_unique(context, spv::Op::OpDecorate); + decor_instr->AddOperand({SPV_OPERAND_TYPE_ID, {id_to_decorate}}); + decor_instr->AddOperand({SPV_OPERAND_TYPE_DECORATION, + {uint32_t(spv::Decoration::ConditionalINTEL)}}); + decor_instr->AddOperand({SPV_OPERAND_TYPE_ID, {spec_const_id}}); + context->module()->AddAnnotationInst(std::move(decor_instr)); +} + +// Finds entry point corresponding to a function +// +// Returns null if not found, otherwise returns pointer to the EP Instruction. +Instruction* FindEntryPoint(const Instruction& fn_inst) { + auto* mod = fn_inst.context()->module(); + for (auto& entry_point : mod->entry_points()) { + const int ep_i = + entry_point.opcode() == spv::Op::OpConditionalEntryPointINTEL ? 2 : 1; + if (entry_point.GetOperand(ep_i).AsId() == fn_inst.result_id()) { + return &entry_point; + } + } + return nullptr; +} + +// If the function has an entry point, converts it to a conditional one +void ConvertEPToConditional(Module* module, const Function& fn, + uint32_t spec_const_id) { + for (const auto& ep_inst : module->entry_points()) { + if (ep_inst.opcode() == spv::Op::OpEntryPoint) { + auto* entry_point = FindEntryPoint(fn.DefInst()); + if (entry_point != nullptr) { + std::vector old_operands; + for (auto operand : *entry_point) { + old_operands.push_back(operand); + } + entry_point->ToNop(); + entry_point->SetOpcode(spv::Op::OpConditionalEntryPointINTEL); + entry_point->AddOperand({SPV_OPERAND_TYPE_ID, {spec_const_id}}); + for (auto old_operand : old_operands) { + entry_point->AddOperand(old_operand); + } + } + } + } +} + +// Finds ID of a bool type (returns 0 if not found) +uint32_t FindIdOfBoolType(const Module* const mod) { + return mod->context()->get_type_mgr()->GetBoolTypeId(); +} + +// Combines IDs using OpSpecConstantOp with the operation defined by cmp_op. +// +// Returns the ID of the final result. If there are no IDs, returns 0. If there +// is one ID, does not generate any instructions and returns the ID. +uint32_t CombineIds(IRContext* const context, const std::vector& ids, + spv::Op cmp_op) { + if (ids.empty()) { + return 0; + } else if (ids.size() == 1) { + return ids[0]; + } else { + uint32_t bool_id = FindIdOfBoolType(context->module()); + assert(bool_id != 0); + + uint32_t prev_spec_const_id = ids[0]; + + for (size_t i = 1; i < ids.size(); ++i) { + const uint32_t id = ids[i]; + const uint32_t spec_const_op_id = context->TakeNextId(); + + auto inst = std::make_unique( + context, spv::Op::OpSpecConstantOp, bool_id, spec_const_op_id, + std::initializer_list{ + {SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER, {(uint32_t)(cmp_op)}}, + {SPV_OPERAND_TYPE_ID, {prev_spec_const_id}}, + {SPV_OPERAND_TYPE_ID, {id}}}); + context->module()->AddType(std::move(inst)); + + prev_spec_const_id = spec_const_op_id; + } + + return prev_spec_const_id; + } +} + +// Returns whether instruction can be shared between variant modules and +// combined using spec constants (such as conditional capabilities). +bool CanBeFnVarCombined(const Instruction* inst) { + const spv::Op opcode = inst->opcode(); + + if ((opcode != spv::Op::OpExtInstImport) && + (opcode != spv::Op::OpCapability) && (opcode != spv::Op::OpExtension) && + !spvOpcodeGeneratesType(opcode)) { + return false; + } + + if ((opcode == spv::Op::OpCapability) && + ((inst->GetSingleWordOperand(0) == + static_cast(spv::Capability::FunctionVariantsINTEL)) || + (inst->GetSingleWordOperand(0) == + static_cast(spv::Capability::SpecConditionalINTEL)))) { + // Always enabled + return false; + } + + if ((opcode == spv::Op::OpExtension) && + (inst->GetOperand(0).AsString() == FNVAR_EXT_NAME)) { + // Always enabled + return false; + } + + return true; +} + +// Calculates hash of an instruction. +// +// Applicable only to instructions that can be combined (ie. with +// CanBeFnVarCombined being true) and from those, hash can be only computed for +// selected instructions. Computing hash from other instruction is unsupported. +size_t HashInst(const Instruction* inst) { + if (CanBeFnVarCombined(inst)) { + if (spvOpcodeGeneratesType(inst->opcode())) { + const Type* t = + inst->context()->get_type_mgr()->GetType(inst->result_id()); + assert(t != nullptr); + return t->HashValue(); + } + + if (inst->opcode() == spv::Op::OpExtension) { + const auto name = inst->GetOperand(0).AsString(); + return std::hash()(name); + } + + if (inst->opcode() == spv::Op::OpCapability) { + const auto cap = inst->GetSingleWordOperand(0); + return std::hash()(cap); + } + + if (inst->opcode() == spv::Op::OpExtInstImport) { + const auto name = inst->GetOperand(1).AsString(); + return std::hash()(name); + } + } + + assert(false && "Unsupported instruction hash"); + return std::hash()(inst); +} + +std::string GetFnName(const Instruction& fn_inst) { + // Check entry point + const auto* ep_inst = FindEntryPoint(fn_inst); + if (ep_inst != nullptr) { + const int name_i = + ep_inst->opcode() == spv::Op::OpConditionalEntryPointINTEL ? 3 : 2; + return ep_inst->GetOperand(name_i).AsString(); + } + + // Check name of export linkage attribute decoration + const auto* decor_mgr = fn_inst.context()->get_decoration_mgr(); + for (const auto* inst : + decor_mgr->GetDecorationsFor(fn_inst.result_id(), true)) { + const auto decoration = inst->GetOperand(1); + if ((decoration.type == SPV_OPERAND_TYPE_DECORATION) && + (decoration.words.size() == 1) && + (decoration.words[0] == + static_cast(spv::Decoration::LinkageAttributes))) { + const auto linkage = inst->GetOperand(3); + if ((linkage.type == SPV_OPERAND_TYPE_LINKAGE_TYPE) && + (linkage.words.size() == 1) && + (linkage.words[0] == + static_cast(spv::LinkageType::Export))) { + // decorates fn with LinkageAttribute and Export linkage type -> get the + // name + return inst->GetOperand(2).AsString(); + } + } + } + + return ""; +} + +uint32_t FindSpecConstByName(const Module* mod, std::string name) { + for (const auto* const_inst : mod->context()->GetConstants()) { + if (opt::IsSpecConstantInst(const_inst->opcode())) { + const auto id = const_inst->result_id(); + for (const auto& name_inst : mod->debugs2()) { + if ((name_inst.opcode() == spv::Op::OpName) && + (name_inst.GetOperand(0).AsId() == id) && + (name_inst.GetOperand(1).AsString() == name)) { + return id; + } + } + } + } + return 0; +} + +uint32_t CombineVariantDefs(const std::vector& variant_defs, + const std::vector var_ids, + IRContext* context, + std::map, uint32_t>& cache) { + assert(var_ids.size() <= variant_defs.size()); + uint32_t spec_const_comb_id = 0; + if (var_ids.size() != variant_defs.size()) { + // if not used by all variants + if (cache.find(var_ids) == cache.end()) { + // cache variant combinations + std::vector spec_const_ids; + for (const auto& var_id : var_ids) { + const auto var_name = variant_defs[var_id].GetName(); + const auto var_spec_id = + FindSpecConstByName(context->module(), var_name); + spec_const_ids.push_back(var_spec_id); + } + spec_const_comb_id = + CombineIds(context, spec_const_ids, spv::Op::OpLogicalOr); + assert(spec_const_comb_id != 0); + cache.insert({var_ids, spec_const_comb_id}); + } else { + spec_const_comb_id = cache[var_ids]; + } + } + return spec_const_comb_id; +} + +bool strToInt(std::string s, uint32_t* x) { + for (const char& c : s) { + if (c < '0' || c > '9') { + return false; + } + } + if (!(std::stringstream(s) >> *x)) { + return false; + } + return true; +} + +} // anonymous namespace + +bool VariantDefs::ProcessFnVar(const LinkerOptions& options, + const std::vector& modules) { + assert(variant_defs_.empty()); + assert(modules.size() == options.GetInFiles().size()); + + for (size_t i = 0; i < modules.size(); ++i) { + const auto* feat_mgr = modules[i]->context()->get_feature_mgr(); + if ((feat_mgr->HasCapability(spv::Capability::FunctionVariantsINTEL)) || + (feat_mgr->HasCapability(spv::Capability::SpecConditionalINTEL)) || + (feat_mgr->HasExtension(kSPV_INTEL_function_variants))) { + // In principle, it can be done but it's complicated due to having to + // combine the existing conditionals with the new ones. For example, + // conditional capabilities would need to become "doubly-conditional". + err_ << "Creating multitarget modules from multitarget modules is not " + "supported. Offending file: " + << options.GetInFiles()[i]; + return false; + } + } + + std::vector> target_rows; + std::vector> architecture_rows; + + if (!options.GetFnVarTargetsCsv().empty()) { + const std::vector tgt_cols = {"module", "target", "features"}; + if (!ParseCsv(options.GetFnVarTargetsCsv(), tgt_cols, err_, target_rows)) { + return false; + } + } + + if (!options.GetFnVarArchitecturesCsv().empty()) { + const std::vector arch_cols = {"module", "category", "family", + "op", "architecture"}; + if (!ParseCsv(options.GetFnVarArchitecturesCsv(), arch_cols, err_, + architecture_rows)) { + return false; + } + } + + // check that all modules defined in the CSV exist + + for (const auto& tgt_vals : target_rows) { + bool found = false; + for (const auto& in_file : options.GetInFiles()) { + if (tgt_vals[0] == in_file) { + found = true; + } + } + if (!found) { + err_ << "Module '" << tgt_vals[0] + << "' found in targets CSV not passed to the CLI."; + return false; + } + } + + for (const auto& arch_vals : architecture_rows) { + bool found = false; + for (const auto& in_file : options.GetInFiles()) { + if (arch_vals[0] == in_file) { + found = true; + } + } + if (!found) { + err_ << "Module '" << arch_vals[0] + << "' found in architectures CSV not passed to the CLI."; + return false; + } + } + + // create per-module variant defs + + for (size_t i = 0; i < modules.size(); ++i) { + // first module passed to the CLI is considered the base module + bool is_base = i == 0; + const auto name = options.GetInFiles()[i]; + auto variant_def = VariantDef(is_base, name, modules[i]); + + for (const auto& arch_row : architecture_rows) { + const auto row_name = arch_row[0]; + if (row_name == name) { + uint32_t category, family, op, architecture; + + if (!strToInt(arch_row[1], &category)) { + err_ << "Error converting " << arch_row[1] + << " to architecture category."; + return false; + } + if (!strToInt(arch_row[2], &family)) { + err_ << "Error converting " << arch_row[2] + << " to architecture family."; + return false; + } + if (!strToInt(arch_row[3], &op)) { + err_ << "Error converting " << arch_row[3] << " to architecture op."; + return false; + } + if (!strToInt(arch_row[4], &architecture)) { + err_ << "Error converting " << arch_row[4] << " to architecture."; + return false; + } + + variant_def.AddArchDef(category, family, op, architecture); + } + } + + for (const auto& tgt_row : target_rows) { + const auto row_name = tgt_row[0]; + if (row_name == name) { + uint32_t target; + std::vector features; + + if (!strToInt(tgt_row[1], &target)) { + err_ << "Error converting " << tgt_row[1] << " to target."; + return false; + } + + // get features as FEAT_SEP-delimited integers + + std::stringstream feat_stream(tgt_row[2]); + std::string feat; + while (std::getline(feat_stream, feat, FEAT_SEP)) { + uint32_t ufeat; + // if (!(std::stringstream(feat) >> ufeat)) { + if (!strToInt(feat, &ufeat)) { + err_ << "Error converting " << feat << " in " << tgt_row[2] + << " to target feature."; + return false; + } + features.push_back(ufeat); + } + + variant_def.AddTgtDef(target, features); + } + } + + if (options.GetHasFnVarCapabilities()) { + variant_def.InferCapabilities(); + } + + variant_defs_.push_back(variant_def); + } + + return true; +} + +bool VariantDefs::ProcessVariantDefs() { + EnsureBoolType(); + CollectVarInsts(); + if (!GenerateFnVarConstants()) { + return false; + } + CollectBaseFnCalls(); + return true; +} + +void VariantDefs::GenerateHeader(IRContext* linked_context) { + linked_context->AddCapability(spv::Capability::SpecConditionalINTEL); + linked_context->AddCapability(spv::Capability::FunctionVariantsINTEL); + linked_context->AddExtension(std::string(FNVAR_EXT_NAME)); + + // Specifies used registry version + auto inst = + std::make_unique(linked_context, spv::Op::OpModuleProcessed); + std::stringstream line; + line << "SPV_INTEL_function_variants registry version " + << FNVAR_REGISTRY_VERSION; + inst->AddOperand( + {SPV_OPERAND_TYPE_LITERAL_STRING, utils::MakeVector(line.str())}); + linked_context->AddDebug3Inst(std::move(inst)); +} + +void VariantDefs::CombineVariantInstructions(IRContext* linked_context) { + CombineBaseFnCalls(linked_context); + CombineInstructions(linked_context); +} + +void VariantDefs::EnsureBoolType() { + for (auto& variant_def : variant_defs_) { + Module* module = variant_def.GetModule(); + IRContext* context = module->context(); + + uint32_t bool_id = FindIdOfBoolType(module); + if (bool_id == 0) { + bool_id = context->TakeNextId(); + auto variant_bool = std::make_unique( + context, spv::Op::OpTypeBool, 0, bool_id, + std::initializer_list{}); + module->AddType(std::move(variant_bool)); + } + } +} + +void VariantDefs::CollectVarInsts() { + for (size_t i = 0; i < variant_defs_.size(); ++i) { + const auto variant_def = variant_defs_[i]; + const auto* var_mod = variant_def.GetModule(); + + var_mod->ForEachInst([this, &i](const Instruction* inst) { + if (CanBeFnVarCombined(inst)) { + const size_t inst_hash = HashInst(inst); + if (fnvar_usage_.find(inst_hash) == fnvar_usage_.end()) { + fnvar_usage_.insert({inst_hash, {i}}); + } else { + assert(fnvar_usage_[inst_hash].size() < variant_defs_.size()); + fnvar_usage_[inst_hash].push_back(i); + } + } + }); + } +} + +bool VariantDefs::GenerateFnVarConstants() { + assert(variant_defs_.size() > 0); + assert(variant_defs_[0].IsBase()); + + if (variant_defs_.size() == 1) { + return true; + } + + for (auto& variant_def : variant_defs_) { + Module* module = variant_def.GetModule(); + IRContext* context = module->context(); + + uint32_t bool_id = FindIdOfBoolType(module); + if (bool_id == 0) { + // add a bool type if not present already + bool_id = context->TakeNextId(); + auto variant_bool = std::make_unique( + context, spv::Op::OpTypeBool, 0, bool_id, + std::initializer_list{}); + module->AddType(std::move(variant_bool)); + } + + // Spec constant architecture and target + + std::vector spec_const_arch_ids; + for (const auto& arch_def : variant_def.GetArchDefs()) { + const uint32_t spec_const_arch_id = context->TakeNextId(); + spec_const_arch_ids.push_back(spec_const_arch_id); + + auto inst = std::make_unique( + context, spv::Op::OpSpecConstantArchitectureINTEL, bool_id, + spec_const_arch_id, + std::initializer_list{ + {SPV_OPERAND_TYPE_LITERAL_INTEGER, {arch_def.category}}, + {SPV_OPERAND_TYPE_LITERAL_INTEGER, {arch_def.family}}, + // Using spec op opcode here expects then next operand to be + // a type: + {SPV_OPERAND_TYPE_LITERAL_INTEGER, {arch_def.op}}, + {SPV_OPERAND_TYPE_LITERAL_INTEGER, {arch_def.architecture}}, + }); + module->AddType(std::move(inst)); + } + + std::vector spec_const_tgt_ids; + for (const auto& tgt_def : variant_def.GetTgtDefs()) { + const uint32_t spec_const_tgt_id = context->TakeNextId(); + spec_const_tgt_ids.push_back(spec_const_tgt_id); + + auto inst = std::make_unique( + context, spv::Op::OpSpecConstantTargetINTEL, bool_id, + spec_const_tgt_id, + std::initializer_list{ + {SPV_OPERAND_TYPE_LITERAL_INTEGER, {tgt_def.target}}, + }); + for (const auto& feat : tgt_def.features) { + inst->AddOperand({SPV_OPERAND_TYPE_LITERAL_INTEGER, {feat}}); + } + module->AddType(std::move(inst)); + } + + std::vector spec_const_ids; + + // Spec constant capabilities + + const auto variant_capabilities = variant_def.GetCapabilities(); + if (!variant_capabilities.empty()) { + const uint32_t spec_const_cap_id = context->TakeNextId(); + auto inst = std::make_unique( + context, spv::Op::OpSpecConstantCapabilitiesINTEL, bool_id, + spec_const_cap_id, std::initializer_list{}); + for (const auto& cap : variant_capabilities) { + inst->AddOperand({SPV_OPERAND_TYPE_CAPABILITY, {uint32_t(cap)}}); + } + module->AddType(std::move(inst)); + spec_const_ids.push_back(spec_const_cap_id); + } + + // Combine architectures such that, for the same module, those with the same + // category and family are combined with AND and different cat/fam are + // combined with OR. + // This lets you create combinations like "architecture between X and Y". + + // map (category, family) -> IDs + std::map, std::vector> arch_map_and; + + for (size_t i = 0; i < spec_const_arch_ids.size(); ++i) { + const auto& arch_def = variant_def.GetArchDefs()[i]; + const auto id = spec_const_arch_ids[i]; + const auto key = std::make_pair(arch_def.category, arch_def.family); + if (arch_map_and.find(key) == arch_map_and.end()) { + arch_map_and[key] = {id}; + } else { + arch_map_and[key].push_back(id); + } + } + + std::vector arch_ids_or; + for (const auto& it : arch_map_and) { + const auto id = CombineIds(context, it.second, spv::Op::OpLogicalAnd); + if (id > 0) { + arch_ids_or.push_back(id); + } + } + + const uint32_t spec_const_arch_id = + CombineIds(context, arch_ids_or, spv::Op::OpLogicalOr); + if (spec_const_arch_id > 0) { + spec_const_ids.push_back(spec_const_arch_id); + } + + const uint32_t spec_const_tgt_id = + CombineIds(context, spec_const_tgt_ids, spv::Op::OpLogicalOr); + if (spec_const_tgt_id > 0) { + spec_const_ids.push_back(spec_const_tgt_id); + } + + uint32_t combined_spec_const_id = + CombineIds(context, spec_const_ids, spv::Op::OpLogicalAnd); + if (combined_spec_const_id == 0) { + // If the variant module has no constraints, use SpecConstantTrue + combined_spec_const_id = context->TakeNextId(); + auto inst = std::make_unique( + context, spv::Op::OpSpecConstantTrue, bool_id, combined_spec_const_id, + std::initializer_list{}); + context->module()->AddType(std::move(inst)); + } + assert(combined_spec_const_id != 0); + + // Add a name the combined boolean ID so we can look it up after the IDs are + // shifted + auto inst = std::make_unique(context, spv::Op::OpName); + inst->AddOperand({SPV_OPERAND_TYPE_ID, {combined_spec_const_id}}); + std::vector str_words; + utils::AppendToVector(variant_def.GetName(), &str_words); + inst->AddOperand({SPV_OPERAND_TYPE_LITERAL_STRING, {str_words}}); + module->AddDebug2Inst(std::move(inst)); + + // Annotate all instructions in the types section (eg. constants) with + // ConditionalINTEL, unless they can be shared between variant_defs_ (eg. + // types). Spec constants are excluded because they might have been + // generated by this extension. + for (const auto& type_inst : module->types_values()) { + if (!CanBeFnVarCombined(&type_inst) && + !spvOpcodeIsSpecConstant(type_inst.opcode())) { + DecorateConditional(context, type_inst.result_id(), + combined_spec_const_id); + } + } + } + + // Annotate functions with ConditionalINTEL + + for (const auto& base_fn : *variant_defs_[0].GetModule()) { + // For each function of the base module, find matching variant functions in + // other modules + + auto base_fn_name = GetFnName(base_fn.DefInst()); + if (base_fn_name.empty()) { + err_ << "Could not find name of a function " << base_fn.result_id() + << " in a base module " << variant_defs_[0].GetName() + << ". To be usable by SPV_INTEL_function_variants, a function " + "must either have an entry point or an export " + "LinkAttribute decoration."; + return false; + } + + bool base_fn_needs_conditional = false; + for (size_t i = 1; i < variant_defs_.size(); ++i) { + const auto& variant_def = variant_defs_[i]; + auto* variant_module = variant_def.GetModule(); + auto* variant_context = variant_module->context(); + + for (const auto& var_fn : *variant_module) { + auto var_fn_name = GetFnName(var_fn.DefInst()); + if (var_fn_name.empty()) { + err_ << "Could not find name of a function " << var_fn.result_id() + << " in a base module " << variant_def.GetName() + << ". To be usable by SPV_INTEL_function_variants, a function " + "must either have an entry point or an export " + "LinkAttribute decoration."; + return false; + } + + if (base_fn_name == var_fn_name) { + base_fn_needs_conditional = true; + } + + // each function in a variant module gets a ConditionalINTEL decoration + + uint32_t spec_const_id = + FindSpecConstByName(variant_module, variant_def.GetName()); + assert(spec_const_id != 0); + DecorateConditional(variant_context, var_fn.result_id(), spec_const_id); + ConvertEPToConditional(variant_module, var_fn, spec_const_id); + } + } + + if (base_fn_needs_conditional) { + // only a base function that has a variant in another module gets a + // ConditionalINTEL decoration, the others are common for all + // variant_defs_ + auto* base_module = variant_defs_[0].GetModule(); + auto* base_context = base_module->context(); + uint32_t spec_const_id = + FindSpecConstByName(base_module, variant_defs_[0].GetName()); + assert(spec_const_id != 0); + DecorateConditional(base_context, base_fn.result_id(), spec_const_id); + ConvertEPToConditional(base_module, base_fn, spec_const_id); + } + } + + return true; +} + +void VariantDefs::CollectBaseFnCalls() { + auto* base_mod = variant_defs_[0].GetModule(); + assert(variant_defs_[0].IsBase()); + const auto* base_def_use_mgr = base_mod->context()->get_def_use_mgr(); + + base_mod->ForEachInst([this, &base_def_use_mgr](const Instruction* inst) { + if (inst->opcode() == spv::Op::OpFunctionCall) { + // For each function call in base module, get the function name + const auto fn_id = inst->GetOperand(2).AsId(); + const auto* called_fn_inst = base_def_use_mgr->GetDef(fn_id); + assert(called_fn_inst != nullptr); + const auto called_fn_name = GetFnName(*called_fn_inst); + assert(!called_fn_name.empty()); + + std::vector> called_fns; + for (size_t i = 1; i < variant_defs_.size(); ++i) { + // ... then see in which variant the called function was defined + const auto& variant_def = variant_defs_[i]; + assert(!variant_def.IsBase()); + + for (const auto& fn : *variant_def.GetModule()) { + const auto fn_name = GetFnName(fn.DefInst()); + if (fn_name == called_fn_name) { + called_fns.push_back(std::make_pair(variant_def.GetName(), &fn)); + } + } + } + + if (!called_fns.empty()) { + base_fn_calls_[inst->result_id()] = called_fns; + } + } + }); +} + +void VariantDefs::CombineBaseFnCalls(IRContext* linked_context) { + for (auto kv : base_fn_calls_) { + const uint32_t call_id = kv.first; + const auto called_fns = kv.second; + + if (called_fns.empty()) { + return; + } + + opt::BasicBlock* fn_call_bb = linked_context->get_instr_block(call_id); + + Instruction* found_call_inst = nullptr; + auto bb_iter = fn_call_bb->begin(); + while (bb_iter != fn_call_bb->end() && found_call_inst == nullptr) { + if (bb_iter->HasResultId() && bb_iter->result_id() == call_id) { + found_call_inst = &*bb_iter; + } + ++bb_iter; + } + + if (found_call_inst == nullptr) { + return; + } + + const auto base_spec_const_id = FindSpecConstByName( + variant_defs_[0].GetModule(), variant_defs_[0].GetName()); + const auto base_type_op = found_call_inst->context() + ->get_def_use_mgr() + ->GetDef(found_call_inst->type_id()) + ->opcode(); + const auto base_call_id = found_call_inst->result_id(); + + // decorate the base call with ConditionalINTEL + DecorateConditional(linked_context, base_call_id, base_spec_const_id); + + // Add OpFunctionCall for each variant + Instruction* last_inst = found_call_inst; + std::vector> var_call_ids; + for (const auto& kv2 : called_fns) { + const std::string var_name = kv2.first; + const opt::Function* fn = kv2.second; + const uint32_t spec_const_id = + FindSpecConstByName(linked_context->module(), var_name); + assert(spec_const_id != 0); + const uint32_t var_call_id = linked_context->TakeNextId(); + var_call_ids.push_back(std::make_pair(spec_const_id, var_call_id)); + + auto* var_call_inst = found_call_inst->Clone(linked_context); + var_call_inst->SetResultId(var_call_id); + var_call_inst->SetOperand(2, {fn->result_id()}); + var_call_inst->InsertAfter(last_inst); + linked_context->set_instr_block(var_call_inst, fn_call_bb); + last_inst = var_call_inst; + + // decorate the variant call with ConditionalINTEL + DecorateConditional(linked_context, var_call_id, spec_const_id); + } + + if (base_type_op != spv::Op::OpTypeVoid) { + // Add OpConditionalCopyObjectINTEL combining the function calls + const uint32_t result_id = linked_context->TakeNextId(); + auto conditional_copy_inst = new Instruction( + linked_context, spv::Op::OpConditionalCopyObjectINTEL, + found_call_inst->type_id(), result_id, + {{SPV_OPERAND_TYPE_ID, {base_spec_const_id}}, + {SPV_OPERAND_TYPE_ID, {found_call_inst->result_id()}}}); + + for (const auto& kv3 : var_call_ids) { + const auto spec_const_id = kv3.first; + const auto var_call_id = kv3.second; + conditional_copy_inst->AddOperand( + {SPV_OPERAND_TYPE_ID, {spec_const_id}}); + conditional_copy_inst->AddOperand({SPV_OPERAND_TYPE_ID, {var_call_id}}); + } + conditional_copy_inst->InsertAfter(last_inst); + linked_context->set_instr_block(conditional_copy_inst, fn_call_bb); + last_inst = conditional_copy_inst; + + // In all remaining instructions within the basic block, replace all + // usages of the base call ID with the result of + // OpConditionalCopyObjectINTEL + do { + last_inst = last_inst->NextNode(); + last_inst->ForEachInId([base_call_id, result_id](uint32_t* id) { + if (*id == base_call_id) { + *id = result_id; + } + }); + } while (last_inst != nullptr && *last_inst != *fn_call_bb->tail()); + } + } + + // Combine spec consts for the base module (base module is activated if all + // variant defs are inactive AND the base module constraints are satisfied) + + std::vector var_spec_const_ids; + for (const auto& variant_def : variant_defs_) { + if (variant_def.IsBase()) { + continue; + } + + const auto id = + FindSpecConstByName(linked_context->module(), variant_def.GetName()); + assert(id != 0); + var_spec_const_ids.push_back(id); + } + const uint32_t base_or_id = + CombineIds(linked_context, var_spec_const_ids, spv::Op::OpLogicalOr); + + if (base_or_id != 0) { + const uint32_t bool_id = FindIdOfBoolType(linked_context->module()); + assert(bool_id != 0); + + const uint32_t base_not_id = linked_context->TakeNextId(); + auto spec_const_op_inst = std::make_unique( + linked_context, spv::Op::OpSpecConstantOp, bool_id, base_not_id, + std::initializer_list{ + {SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER, + {(uint32_t)(spv::Op::OpLogicalNot)}}, + {SPV_OPERAND_TYPE_ID, {base_or_id}}}); + linked_context->module()->AddType(std::move(spec_const_op_inst)); + + // Update any ConditionalINTEL annotations, names and entry points + // referencing the old spec const ID to use the new one + + const uint32_t old_base_spec_const_id = FindSpecConstByName( + linked_context->module(), variant_defs_[0].GetName()); + assert(old_base_spec_const_id != 0); + const uint32_t base_spec_const_id = + CombineIds(linked_context, {old_base_spec_const_id, base_not_id}, + spv::Op::OpLogicalAnd); + + for (auto& annot_inst : linked_context->module()->annotations()) { + if ((annot_inst.GetSingleWordOperand(1) == + uint32_t(spv::Decoration::ConditionalINTEL)) && + (annot_inst.GetOperand(2).AsId() == old_base_spec_const_id)) { + annot_inst.SetOperand(2, {base_spec_const_id}); + } + } + + for (auto& name_inst : linked_context->module()->debugs2()) { + if ((name_inst.opcode() == spv::Op::OpName) && + (name_inst.GetOperand(0).AsId() == old_base_spec_const_id)) { + name_inst.SetOperand(0, {base_spec_const_id}); + } + } + + for (auto& ep_inst : linked_context->module()->entry_points()) { + if ((ep_inst.opcode() == spv::Op::OpConditionalEntryPointINTEL) && + (ep_inst.GetOperand(0).AsId() == old_base_spec_const_id)) { + ep_inst.SetOperand(0, {base_spec_const_id}); + } + } + + linked_context->module()->ForEachInst( + [old_base_spec_const_id, base_spec_const_id](Instruction* inst) { + if (inst->opcode() == spv::Op::OpConditionalCopyObjectINTEL) { + inst->ForEachInId( + [old_base_spec_const_id, base_spec_const_id](uint32_t* id) { + if (*id == old_base_spec_const_id) { + *id = base_spec_const_id; + } + }); + } + }); + } +} + +void VariantDefs::CombineInstructions(IRContext* linked_context) { + // cache for existing variant ID combinations + std::map, uint32_t> spec_const_comb_ids; + + linked_context->module()->ForEachInst( + [this, &linked_context, &spec_const_comb_ids](Instruction* inst) { + if (!CanBeFnVarCombined(inst)) { + return; + } + + const size_t inst_hash = HashInst(inst); + if (fnvar_usage_.find(inst_hash) != fnvar_usage_.end()) { + const std::vector var_ids = fnvar_usage_[inst_hash]; + const uint32_t spec_const_comb_id = CombineVariantDefs( + variant_defs_, var_ids, linked_context, spec_const_comb_ids); + if (spec_const_comb_id != 0) { + if (inst->HasResultId()) { + DecorateConditional(linked_context, inst->result_id(), + spec_const_comb_id); + } else if (inst->opcode() == spv::Op::OpCapability) { + const uint32_t cap = inst->GetSingleWordOperand(0); + inst->SetOpcode(spv::Op::OpConditionalCapabilityINTEL); + inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {spec_const_comb_id}}, + {SPV_OPERAND_TYPE_CAPABILITY, {cap}}}); + } else if (inst->opcode() == spv::Op::OpExtension) { + const std::string ext_name = inst->GetOperand(0).AsString(); + inst->SetOpcode(spv::Op::OpConditionalExtensionINTEL); + inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {spec_const_comb_id}}, + {SPV_OPERAND_TYPE_LITERAL_STRING, + {utils::MakeVector(ext_name)}}}); + } else { + assert(false && "Unsupported"); + } + } + } + }); +} + +} // namespace spvtools diff --git a/libs/bgfx/3rdparty/spirv-tools/source/link/fnvar.h b/libs/bgfx/3rdparty/spirv-tools/source/link/fnvar.h new file mode 100644 index 0000000..49db030 --- /dev/null +++ b/libs/bgfx/3rdparty/spirv-tools/source/link/fnvar.h @@ -0,0 +1,244 @@ +// Copyright 2025 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Implementation of generating multitarget modules according to the +// *SPV_INTEL_function_variants* extension +// +// Multitarget module is generated by linking separate modules: a base module +// and variant modules containing device-specific variants of the functions in +// the base module. The behavior is controlled by Comma-Separated Values (CSV) +// files passed to the following flags: +// --fnvar-targets: Required columns: +// module - module file name +// target - device target ISA value +// features - feature values for the target separated by '/' (FEAT_SEP) +// --fnvar-architectures: Required columns: +// module - module file name +// category - device category value +// family - device family value +// op - opcode of the comparison instruction +// architecture - device architecture +// The values (except module) are decimal strings with their meaning defined in +// the 'targets registry' as described in the extension spec. The decimal +// strings may only encode unsigned 32-bit integers (characters 0-9), possibly +// with leading zeros. +// +// In addition, --fnvar-capabilities generates OpSpecConstantCapabilitiesINTEL +// for each module with operands corresponding to the module's capabilities. +// +// Each line in the targets/architectures CSV file defines one +// OpSpecConstantINTEL instruction, the columns correspond +// to the operands of these instructions. One module can have multiple lines, in +// which case they are combined into a single boolean spec constant using +// OpSpecConstantOp and OpLogicalOr (except when category and family in the +// architectures CSV are the same, then the lines are combined with +// OpLogicalAnd). For example, the following architectures CSV +// +// module,category,family,op,architecture +// foo.spv,1,7,174,1 +// foo.spv,1,7,178,3 +// foo.spv,1,8,170,1 +// +// is combined as follows: +// +// %53 = OpSpecConstantArchitectureINTEL %bool 1 7 174 1 +// %54 = OpSpecConstantArchitectureINTEL %bool 1 7 178 3 +// %55 = OpSpecConstantArchitectureINTEL %bool 1 8 170 1 +// %56 = OpSpecConstantOp %bool LogicalAnd %53 %54 +// %foo_spv = OpSpecConstantOp %bool LogicalOr %55 %56 +// +// The %foo_spv is annotated with OpName "foo.spv" (the module's name) which +// serves as an identifier to find the constant later. We cannot use IDs for it +// because the IDs get shifted during linking. +// +// The first module passed to `spirv-link` is considered the 'base' module. For +// example, if base module defines functions 'foo' and 'bar' and the other +// modules define only 'foo', only the 'foo' is treated as a function variant +// guarded by spec constants. The 'bar' function will be untouched and therefore +// present for all variants. The function variants are matched by name, and +// therefore they must either have an entry point, or an Export linkage +// attribute. + +#ifndef FNVAR_H +#define FNVAR_H + +#include +#include +#include +#include + +#include "source/opt/ir_context.h" +#include "source/opt/module.h" +#include "spirv-tools/linker.hpp" + +namespace spvtools { + +using opt::IRContext; +using opt::Module; + +// Map of instruction hash -> which variants are using the instruction (denoted +// by the index to the variants vector) +using FnVarUsage = std::unordered_map>; + +// Map of base function call ID -> variant functions corresponding to the +// called function (along with the variant name) +using BaseFnCalls = + std::map>>; + +constexpr char FNVAR_EXT_NAME[] = "SPV_INTEL_function_variants"; +constexpr uint32_t FNVAR_REGISTRY_VERSION = 0; +constexpr char FEAT_SEP = '/'; + +struct FnVarArchDef { + uint32_t category; + uint32_t family; + uint32_t op; + uint32_t architecture; +}; + +struct FnVarTargetDef { + uint32_t target; + std::vector features; +}; + +// Definition of a variant +// +// Stores architecture and target definitions inferred from lines in the CSV +// files for a single module (as well as a pointer to the Module). +class VariantDef { + public: + VariantDef(bool isbase, std::string nm, Module* mod) + : is_base(isbase), name(nm), module(mod) {} + + bool IsBase() const { return this->is_base; } + std::string GetName() const { return this->name; } + Module* GetModule() const { return this->module; } + + void AddArchDef(uint32_t category, uint32_t family, uint32_t op, + uint32_t architecture) { + FnVarArchDef arch_def; + arch_def.category = category; + arch_def.family = family; + arch_def.op = op; + arch_def.architecture = architecture; + this->arch_defs.push_back(arch_def); + } + const std::vector& GetArchDefs() const { + return this->arch_defs; + } + + void AddTgtDef(uint32_t target, std::vector features) { + FnVarTargetDef tgt_def; + tgt_def.target = target; + tgt_def.features = features; + this->tgt_defs.push_back(tgt_def); + } + const std::vector& GetTgtDefs() const { + return this->tgt_defs; + } + + void InferCapabilities() { + for (const auto& cap_inst : module->capabilities()) { + capabilities.insert(spv::Capability(cap_inst.GetOperand(0).words[0])); + } + } + const std::set& GetCapabilities() const { + return this->capabilities; + } + + private: + bool is_base; + std::string name; + Module* module; + std::vector tgt_defs; + std::vector arch_defs; + std::set capabilities; +}; + +// Collection of VariantDef instances +// +// Apart from being a wrapper around a vector of VariantDef instances, it +// defines the main API for generating SPV_INTEL_function_variants instructions +// based on the CSV files. +class VariantDefs { + public: + // Returns last error message. + std::string GetErr() { return err_.str(); } + + // Processes CSV files passed to the CLI and populate _variants. + // + // Returns true on success, false on error. + bool ProcessFnVar(const LinkerOptions& options, + const std::vector& modules); + + // Analyses each variant def module and generates those instructions that are + // module-specific, ie., not requiring knowledge from other modules. + // + // Returns true on success, false on error. + bool ProcessVariantDefs(); + + // Generates basic instructions required for this extension to work. + void GenerateHeader(IRContext* linked_context); + + // Generates instructions from this extension that result from combining + // several variant def modules. + void CombineVariantInstructions(IRContext* linked_context); + + private: + // Adds a boolean type to every module if there is none. + // + // These are necessary for spec constants. + void EnsureBoolType(); + + // Collects which combinable instructions are defined in which modules + void CollectVarInsts(); + + // Generates OpSpecConstantINTEL and + // combines them as necessary. Also converts entry points to conditional ones + // and decorates module-specific instructions with ConditionalINTEL. + // + // Returns true on success, false on error. + bool GenerateFnVarConstants(); + + // Determines which functions in the base module are called by which function + // variants. + void CollectBaseFnCalls(); + + // Combines OpFunctionCall instructions collected with CollectBaseFnCalls() + // using conditional copy. + void CombineBaseFnCalls(IRContext* linked_context); + + // Decorates instructions shared between modules with ConditionalINTEL or + // generates conditional capabilities and extensions, depending on which + // variants are used by each. + void CombineInstructions(IRContext* linked_context); + + // Accumulates all errors encountered during processing. + std::stringstream err_; + + // Collection of VariantDef instances + std::vector variant_defs_; + + // Used for combining OpFunctionCall instructions + BaseFnCalls base_fn_calls_; + + // Used for determining which function variant uses which (applicable) + // instruction + FnVarUsage fnvar_usage_; +}; + +} // namespace spvtools + +#endif // FNVAR_H diff --git a/libs/bgfx/3rdparty/spirv-tools/source/link/linker.cpp b/libs/bgfx/3rdparty/spirv-tools/source/link/linker.cpp index 5fb4478..002cc41 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/link/linker.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/link/linker.cpp @@ -15,9 +15,10 @@ #include "spirv-tools/linker.hpp" #include +#include #include #include -#include +#include #include #include #include @@ -26,18 +27,17 @@ #include #include +#include "fnvar.h" #include "source/diagnostic.h" #include "source/opt/build_module.h" #include "source/opt/compact_ids_pass.h" #include "source/opt/decoration_manager.h" #include "source/opt/ir_builder.h" -#include "source/opt/ir_loader.h" #include "source/opt/pass_manager.h" #include "source/opt/remove_duplicates_pass.h" #include "source/opt/remove_unused_interface_variables_pass.h" #include "source/opt/type_manager.h" #include "source/spirv_constant.h" -#include "source/spirv_target_env.h" #include "source/table2.h" #include "source/util/make_unique.h" #include "source/util/string_utils.h" @@ -328,7 +328,10 @@ spv_result_t MergeModules(const MessageConsumer& consumer, for (const auto& module : input_modules) for (const auto& inst : module->entry_points()) { const uint32_t model = inst.GetSingleWordInOperand(0); - const std::string name = inst.GetInOperand(2).AsString(); + const std::string name = + inst.opcode() == spv::Op::OpConditionalEntryPointINTEL + ? inst.GetOperand(3).AsString() + : inst.GetOperand(2).AsString(); const auto i = std::find_if( entry_points.begin(), entry_points.end(), [model, name](const std::pair& v) { @@ -728,8 +731,7 @@ spv_result_t VerifyLimits(const MessageConsumer& consumer, if (max_id_bound >= SPV_LIMIT_RESULT_ID_BOUND) DiagnosticStream({0u, 0u, 4u}, consumer, "", SPV_WARNING) << "The minimum limit of IDs, " << (SPV_LIMIT_RESULT_ID_BOUND - 1) - << ", was exceeded:" - << " " << max_id_bound << " is the current ID bound.\n" + << ", was exceeded: " << max_id_bound << " is the current ID bound.\n" << "The resulting module might not be supported by all " "implementations."; @@ -740,8 +742,8 @@ spv_result_t VerifyLimits(const MessageConsumer& consumer, if (num_global_values >= SPV_LIMIT_GLOBAL_VARIABLES_MAX) DiagnosticStream(position, consumer, "", SPV_WARNING) << "The minimum limit of global values, " - << (SPV_LIMIT_GLOBAL_VARIABLES_MAX - 1) << ", was exceeded;" - << " " << num_global_values << " global values were found.\n" + << (SPV_LIMIT_GLOBAL_VARIABLES_MAX - 1) << ", was exceeded; " + << num_global_values << " global values were found.\n" << "The resulting module might not be supported by all " "implementations."; @@ -853,6 +855,22 @@ spv_result_t Link(const Context& context, const uint32_t* const* binaries, ir_contexts.push_back(std::move(ir_context)); } + const bool make_multitarget = !options.GetFnVarArchitecturesCsv().empty() || + !options.GetFnVarTargetsCsv().empty(); + + VariantDefs variant_defs; + + if (make_multitarget) { + if (!variant_defs.ProcessFnVar(options, modules)) { + return DiagnosticStream(position, consumer, "", SPV_ERROR_FNVAR) + << variant_defs.GetErr(); + } + if (!variant_defs.ProcessVariantDefs()) { + return DiagnosticStream(position, consumer, "", SPV_ERROR_FNVAR) + << variant_defs.GetErr(); + } + } + // Phase 1: Shift the IDs used in each binary so that they occupy a disjoint // range from the other binaries, and compute the new ID bound. uint32_t max_id_bound = 0u; @@ -866,6 +884,10 @@ spv_result_t Link(const Context& context, const uint32_t* const* binaries, IRContext linked_context(c_context->target_env, consumer); linked_context.module()->SetHeader(header); + if (make_multitarget) { + variant_defs.GenerateHeader(&linked_context); + } + // Phase 3: Merge all the binaries into a single one. res = MergeModules(consumer, modules, &linked_context); if (res != SPV_SUCCESS) return res; @@ -882,6 +904,10 @@ spv_result_t Link(const Context& context, const uint32_t* const* binaries, opt::Pass::Status pass_res = manager.Run(&linked_context); if (pass_res == opt::Pass::Status::Failure) return SPV_ERROR_INVALID_DATA; + if (make_multitarget) { + variant_defs.CombineVariantInstructions(&linked_context); + } + // Phase 5: Find the import/export pairs LinkageTable linkings_to_do; res = GetImportExportPairs(consumer, linked_context, diff --git a/libs/bgfx/3rdparty/spirv-tools/source/mimalloc.cpp b/libs/bgfx/3rdparty/spirv-tools/source/mimalloc.cpp new file mode 100644 index 0000000..8e086d5 --- /dev/null +++ b/libs/bgfx/3rdparty/spirv-tools/source/mimalloc.cpp @@ -0,0 +1,15 @@ +// Copyright (c) 2025 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "mimalloc-new-delete.h" diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opcode.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opcode.cpp index 665574a..a8b4102 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opcode.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opcode.cpp @@ -120,6 +120,9 @@ int32_t spvOpcodeIsSpecConstant(const spv::Op opcode) { case spv::Op::OpSpecConstantComposite: case spv::Op::OpSpecConstantCompositeReplicateEXT: case spv::Op::OpSpecConstantOp: + case spv::Op::OpSpecConstantArchitectureINTEL: + case spv::Op::OpSpecConstantTargetINTEL: + case spv::Op::OpSpecConstantCapabilitiesINTEL: return true; default: return false; @@ -144,6 +147,12 @@ int32_t spvOpcodeIsConstant(const spv::Op opcode) { case spv::Op::OpSpecConstantCompositeReplicateEXT: case spv::Op::OpSpecConstantOp: case spv::Op::OpSpecConstantStringAMDX: + case spv::Op::OpGraphConstantARM: + case spv::Op::OpAsmTargetINTEL: + case spv::Op::OpAsmINTEL: + case spv::Op::OpSpecConstantArchitectureINTEL: + case spv::Op::OpSpecConstantTargetINTEL: + case spv::Op::OpSpecConstantCapabilitiesINTEL: return true; default: return false; @@ -264,6 +273,7 @@ int32_t spvOpcodeGeneratesType(spv::Op op) { case spv::Op::OpTypeTensorViewNV: case spv::Op::OpTypeTensorARM: case spv::Op::OpTypeTaskSequenceINTEL: + case spv::Op::OpTypeGraphARM: return true; default: // In particular, OpTypeForwardPointer does not generate a type, diff --git a/libs/bgfx/3rdparty/spirv-tools/source/operand.cpp b/libs/bgfx/3rdparty/spirv-tools/source/operand.cpp index c635c72..033c01a 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/operand.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/operand.cpp @@ -111,6 +111,7 @@ const char* spvOperandTypeStr(spv_operand_type_t type) { case SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO: return "kernel profiling info"; case SPV_OPERAND_TYPE_CAPABILITY: + case SPV_OPERAND_TYPE_OPTIONAL_CAPABILITY: return "capability"; case SPV_OPERAND_TYPE_RAY_FLAGS: return "ray flags"; @@ -394,6 +395,7 @@ bool spvOperandIsOptional(spv_operand_type_t type) { case SPV_OPERAND_TYPE_OPTIONAL_RAW_ACCESS_CHAIN_OPERANDS: case SPV_OPERAND_TYPE_OPTIONAL_FPENCODING: case SPV_OPERAND_TYPE_OPTIONAL_TENSOR_OPERANDS: + case SPV_OPERAND_TYPE_OPTIONAL_CAPABILITY: return true; default: break; @@ -408,6 +410,7 @@ bool spvOperandIsVariable(spv_operand_type_t type) { case SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER: case SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER_ID: case SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER: + case SPV_OPERAND_TYPE_VARIABLE_CAPABILITY: return true; default: break; @@ -439,6 +442,10 @@ bool spvExpandOperandSequenceOnce(spv_operand_type_t type, pattern->push_back(SPV_OPERAND_TYPE_LITERAL_INTEGER); pattern->push_back(SPV_OPERAND_TYPE_OPTIONAL_ID); return true; + case SPV_OPERAND_TYPE_VARIABLE_CAPABILITY: + pattern->push_back(type); + pattern->push_back(SPV_OPERAND_TYPE_OPTIONAL_CAPABILITY); + return true; default: break; } @@ -521,6 +528,9 @@ std::function spvOperandCanBeForwardDeclaredFunction( case spv::Op::OpMemberDecorateStringGOOGLE: case spv::Op::OpBranch: case spv::Op::OpLoopMerge: + case spv::Op::OpConditionalEntryPointINTEL: + case spv::Op::OpConditionalCapabilityINTEL: + case spv::Op::OpConditionalExtensionINTEL: out = [](unsigned) { return true; }; break; case spv::Op::OpGroupDecorate: @@ -571,6 +581,9 @@ std::function spvOperandCanBeForwardDeclaredFunction( // approximate, due to variable operands out = [](unsigned index) { return index > 6; }; break; + case spv::Op::OpGraphEntryPointARM: + out = [](unsigned index) { return index == 0; }; + break; default: out = [](unsigned) { return false; }; break; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/aggressive_dead_code_elim_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/aggressive_dead_code_elim_pass.cpp index 51f2f1a..795f8c3 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/aggressive_dead_code_elim_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/aggressive_dead_code_elim_pass.cpp @@ -44,6 +44,9 @@ constexpr uint32_t kExtInstSetInIdx = 0; constexpr uint32_t kExtInstOpInIdx = 1; constexpr uint32_t kInterpolantInIdx = 2; constexpr uint32_t kCooperativeMatrixLoadSourceAddrInIdx = 0; +constexpr uint32_t kDebugValueLocalVariable = 2; +constexpr uint32_t kDebugValueValue = 3; +constexpr uint32_t kDebugValueExpression = 4; // Sorting functor to present annotation instructions in an easy-to-process // order. The functor orders by opcode first and falls back on unique id @@ -270,17 +273,67 @@ void AggressiveDCEPass::AddBreaksAndContinuesToWorklist( }); } -bool AggressiveDCEPass::AggressiveDCE(Function* func) { - if (func->IsDeclaration()) return false; +Pass::Status AggressiveDCEPass::AggressiveDCE(Function* func) { + if (func->IsDeclaration()) return Pass::Status::SuccessWithoutChange; std::list structured_order; cfg()->ComputeStructuredOrder(func, &*func->begin(), &structured_order); live_local_vars_.clear(); InitializeWorkList(func, structured_order); ProcessWorkList(func); + if (ProcessDebugInformation(structured_order) == Pass::Status::Failure) + return Pass::Status::Failure; + ProcessWorkList(func); return KillDeadInstructions(func, structured_order); } -bool AggressiveDCEPass::KillDeadInstructions( +Pass::Status AggressiveDCEPass::ProcessDebugInformation( + std::list& structured_order) { + for (auto bi = structured_order.begin(); bi != structured_order.end(); bi++) { + bool succeeded = (*bi)->WhileEachInst([this](Instruction* inst) { + // DebugDeclare is not dead. It must be converted to DebugValue in a + // later pass + if (inst->IsNonSemanticInstruction() && + inst->GetShader100DebugOpcode() == + NonSemanticShaderDebugInfo100DebugDeclare) { + AddToWorklist(inst); + return true; + } + + // If the Value of a DebugValue is killed, set Value operand to Undef + if (inst->IsNonSemanticInstruction() && + inst->GetShader100DebugOpcode() == + NonSemanticShaderDebugInfo100DebugValue) { + uint32_t id = inst->GetSingleWordInOperand(kDebugValueValue); + auto def = get_def_use_mgr()->GetDef(id); + if (!live_insts_.Set(def->unique_id())) { + AddToWorklist(inst); + uint32_t undef_id = Type2Undef(def->type_id()); + if (undef_id == 0) { + return false; + } + inst->SetInOperand(kDebugValueValue, {undef_id}); + context()->get_def_use_mgr()->UpdateDefUse(inst); + id = inst->GetSingleWordInOperand(kDebugValueLocalVariable); + auto localVar = get_def_use_mgr()->GetDef(id); + AddToWorklist(localVar); + context()->get_def_use_mgr()->UpdateDefUse(localVar); + AddOperandsToWorkList(localVar); + id = inst->GetSingleWordInOperand(kDebugValueExpression); + auto expression = get_def_use_mgr()->GetDef(id); + AddToWorklist(expression); + context()->get_def_use_mgr()->UpdateDefUse(expression); + return true; + } + } + return true; + }); + + if (!succeeded) return Pass::Status::Failure; + } + return Pass::Status::SuccessWithoutChange; +} + +Pass::Status AggressiveDCEPass::KillDeadInstructions( const Function* func, std::list& structured_order) { bool modified = false; for (auto bi = structured_order.begin(); bi != structured_order.end();) { @@ -315,6 +368,9 @@ bool AggressiveDCEPass::KillDeadInstructions( // Find an undef for the return value and make sure it gets kept by // the pass. auto undef_id = Type2Undef(func->type_id()); + if (undef_id == 0) { + return Pass::Status::Failure; + } auto undef = get_def_use_mgr()->GetDef(undef_id); live_insts_.Set(undef->unique_id()); merge_terminator->SetOpcode(spv::Op::OpReturnValue); @@ -333,7 +389,8 @@ bool AggressiveDCEPass::KillDeadInstructions( ++bi; } } - return modified; + return modified ? Pass::Status::SuccessWithChange + : Pass::Status::SuccessWithoutChange; } void AggressiveDCEPass::ProcessWorkList(Function* func) { @@ -593,7 +650,7 @@ void AggressiveDCEPass::InitializeWorkList( } } -void AggressiveDCEPass::InitializeModuleScopeLiveInstructions() { +Pass::Status AggressiveDCEPass::InitializeModuleScopeLiveInstructions() { // Keep all execution modes. for (auto& exec : get_module()->execution_modes()) { AddToWorklist(&exec); @@ -668,6 +725,9 @@ void AggressiveDCEPass::InitializeModuleScopeLiveInstructions() { } if (debug_global_seen) { auto dbg_none = context()->get_debug_info_mgr()->GetDebugInfoNone(); + if (dbg_none == nullptr) { + return Pass::Status::Failure; + } AddToWorklist(dbg_none); } @@ -681,6 +741,7 @@ void AggressiveDCEPass::InitializeModuleScopeLiveInstructions() { AddToWorklist(&dbg); } } + return Pass::Status::SuccessWithoutChange; } Pass::Status AggressiveDCEPass::ProcessImpl() { @@ -708,7 +769,9 @@ Pass::Status AggressiveDCEPass::ProcessImpl() { // Eliminate Dead functions. bool modified = EliminateDeadFunctions(); - InitializeModuleScopeLiveInstructions(); + if (InitializeModuleScopeLiveInstructions() == Pass::Status::Failure) { + return Pass::Status::Failure; + } // Run |AggressiveDCE| on the remaining functions. The order does not matter, // since |AggressiveDCE| is intra-procedural. This can mean that function @@ -716,7 +779,13 @@ Pass::Status AggressiveDCEPass::ProcessImpl() { // function will still be in the module after this pass. We expect this to be // rare. for (Function& fp : *context()->module()) { - modified |= AggressiveDCE(&fp); + Pass::Status function_status = AggressiveDCE(&fp); + if (function_status == Pass::Status::Failure) { + return Pass::Status::Failure; + } + if (function_status == Pass::Status::SuccessWithChange) { + modified = true; + } } // If the decoration manager is kept live then the context will try to keep it @@ -916,8 +985,17 @@ bool AggressiveDCEPass::ProcessGlobalValues() { } // Save debug build identifier even if no other instructions refer to it. if (dbg.GetShader100DebugOpcode() == - NonSemanticShaderDebugInfo100DebugBuildIdentifier) + NonSemanticShaderDebugInfo100DebugBuildIdentifier) { + // The debug build identifier refers to other instructions that + // can potentially be removed, they also need to be kept alive. + dbg.ForEachInId([this](const uint32_t* id) { + Instruction* ref_inst = get_def_use_mgr()->GetDef(*id); + if (ref_inst) { + live_insts_.Set(ref_inst->unique_id()); + } + }); continue; + } to_kill_.push_back(&dbg); modified = true; } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/aggressive_dead_code_elim_pass.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/aggressive_dead_code_elim_pass.h index fbe08ad..12a5ff7 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/aggressive_dead_code_elim_pass.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/aggressive_dead_code_elim_pass.h @@ -85,8 +85,10 @@ class AggressiveDCEPass : public MemPass { } // Adds entry points, execution modes and workgroup size decorations to the - // worklist for processing with the first function. - void InitializeModuleScopeLiveInstructions(); + // worklist for processing with the first function. Returns + // Pass::Status::Failure if it could not create a required debug instruction. + // Returns Pass::Status::SuccessWithoutChange otherwise. + Pass::Status InitializeModuleScopeLiveInstructions(); // Add |inst| to worklist_ and live_insts_. void AddToWorklist(Instruction* inst) { @@ -136,7 +138,7 @@ class AggressiveDCEPass : public MemPass { // existing control structures will remain. This can leave not-insignificant // sequences of ultimately useless code. // TODO(): Remove useless control constructs. - bool AggressiveDCE(Function* func); + Pass::Status AggressiveDCE(Function* func); Pass::Status ProcessImpl(); @@ -150,9 +152,21 @@ class AggressiveDCEPass : public MemPass { // will be empty at the end. void ProcessWorkList(Function* func); + // Process each DebugDeclare and DebugValue in |func| that has not been + // marked as live in the work list. DebugDeclare's are marked live now, and + // DebugValue Value operands are set to OpUndef. The work list will be empty + // at the end. + // Returns Pass::Status::Failure if it could not create an OpUndef. + // Otherwise, returns Pass::Status::SuccessWithChange if it made changes, + Pass::Status ProcessDebugInformation( + std::list& structured_order); + // Kills any instructions in |func| that have not been marked as live. - bool KillDeadInstructions(const Function* func, - std::list& structured_order); + // Returns Pass::Status::Failure if it could not create an OpUndef. + // Otherwise, returns Pass::Status::SuccessWithChange if it made changes, + // and Pass::Status::SuccessWithoutChange otherwise. + Pass::Status KillDeadInstructions(const Function* func, + std::list& structured_order); // Adds the instructions that define the operands of |inst| to the work list. void AddOperandsToWorkList(const Instruction* inst); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/amd_ext_to_khr.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/amd_ext_to_khr.cpp index 085751b..5cdf26a 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/amd_ext_to_khr.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/amd_ext_to_khr.cpp @@ -232,6 +232,7 @@ bool ReplaceSwizzleInvocations(IRContext* ctx, Instruction* inst, ctx->get_def_use_mgr()->GetDef(var_inst->type_id()); uint32_t uint_type_id = var_ptr_type->GetSingleWordInOperand(1); + // TODO(1841): Handle id overflow. Instruction* id = ir_builder.AddLoad(uint_type_id, var_id); uint32_t quad_mask = ir_builder.GetUintConstantId(3); @@ -239,21 +240,25 @@ bool ReplaceSwizzleInvocations(IRContext* ctx, Instruction* inst, // This gives the offset in the group of 4 of this invocation. Instruction* quad_idx = ir_builder.AddBinaryOp( uint_type_id, spv::Op::OpBitwiseAnd, id->result_id(), quad_mask); + if (quad_idx == nullptr) return false; // Get the invocation id of the first invocation in the group of 4. Instruction* quad_ldr = ir_builder.AddBinaryOp(uint_type_id, spv::Op::OpBitwiseXor, id->result_id(), quad_idx->result_id()); + if (quad_ldr == nullptr) return false; // Get the offset of the target invocation from the offset vector. Instruction* my_offset = ir_builder.AddBinaryOp(uint_type_id, spv::Op::OpVectorExtractDynamic, offset_id, quad_idx->result_id()); + if (my_offset == nullptr) return false; // Determine the index of the invocation to read from. Instruction* target_inv = ir_builder.AddBinaryOp(uint_type_id, spv::Op::OpIAdd, quad_ldr->result_id(), my_offset->result_id()); + if (target_inv == nullptr) return false; // Do the group operations uint32_t uint_max_id = ir_builder.GetUintConstantId(0xFFFFFFFF); @@ -264,9 +269,11 @@ bool ReplaceSwizzleInvocations(IRContext* ctx, Instruction* inst, {uint_max_id, uint_max_id, uint_max_id, uint_max_id}); Instruction* ballot_value = const_mgr->GetDefiningInstruction(ballot_value_const); + // TODO(1841): Handle id overflow. Instruction* is_active = ir_builder.AddNaryOp( type_mgr->GetBoolTypeId(), spv::Op::OpGroupNonUniformBallotBitExtract, {subgroup_scope, ballot_value->result_id(), target_inv->result_id()}); + // TODO(1841): Handle id overflow. Instruction* shuffle = ir_builder.AddNaryOp(inst->type_id(), spv::Op::OpGroupNonUniformShuffle, {subgroup_scope, data_id, target_inv->result_id()}); @@ -358,19 +365,24 @@ bool ReplaceSwizzleInvocationsMasked( ctx->get_def_use_mgr()->GetDef(var_inst->type_id()); uint32_t uint_type_id = var_ptr_type->GetSingleWordInOperand(1); + // TODO(1841): Handle id overflow. Instruction* id = ir_builder.AddLoad(uint_type_id, var_id); // Do the bitwise operations. uint32_t mask_extended = ir_builder.GetUintConstantId(0xFFFFFFE0); Instruction* and_mask = ir_builder.AddBinaryOp( uint_type_id, spv::Op::OpBitwiseOr, uint_x, mask_extended); + if (and_mask == nullptr) return false; Instruction* and_result = ir_builder.AddBinaryOp(uint_type_id, spv::Op::OpBitwiseAnd, id->result_id(), and_mask->result_id()); + if (and_result == nullptr) return false; Instruction* or_result = ir_builder.AddBinaryOp( uint_type_id, spv::Op::OpBitwiseOr, and_result->result_id(), uint_y); + if (or_result == nullptr) return false; Instruction* target_inv = ir_builder.AddBinaryOp( uint_type_id, spv::Op::OpBitwiseXor, or_result->result_id(), uint_z); + if (target_inv == nullptr) return false; // Do the group operations uint32_t uint_max_id = ir_builder.GetUintConstantId(0xFFFFFFFF); @@ -381,9 +393,11 @@ bool ReplaceSwizzleInvocationsMasked( {uint_max_id, uint_max_id, uint_max_id, uint_max_id}); Instruction* ballot_value = const_mgr->GetDefiningInstruction(ballot_value_const); + // TODO(1841): Handle id overflow. Instruction* is_active = ir_builder.AddNaryOp( type_mgr->GetBoolTypeId(), spv::Op::OpGroupNonUniformBallotBitExtract, {subgroup_scope, ballot_value->result_id(), target_inv->result_id()}); + // TODO(1841): Handle id overflow. Instruction* shuffle = ir_builder.AddNaryOp(inst->type_id(), spv::Op::OpGroupNonUniformShuffle, {subgroup_scope, data_id, target_inv->result_id()}); @@ -435,6 +449,7 @@ bool ReplaceWriteInvocation(IRContext* ctx, Instruction* inst, InstructionBuilder ir_builder( ctx, inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); + // TODO(1841): Handle id overflow. Instruction* t = ir_builder.AddLoad(var_ptr_type->GetSingleWordInOperand(1), var_id); analysis::Bool bool_type; @@ -442,6 +457,7 @@ bool ReplaceWriteInvocation(IRContext* ctx, Instruction* inst, Instruction* cmp = ir_builder.AddBinaryOp(bool_type_id, spv::Op::OpIEqual, t->result_id(), inst->GetSingleWordInOperand(4)); + if (cmp == nullptr) return false; // Build a select. inst->SetOpcode(spv::Op::OpSelect); @@ -517,6 +533,7 @@ bool ReplaceMbcnt(IRContext* context, Instruction* inst, Instruction* t = ir_builder.AddBinaryOp(mask_inst->type_id(), spv::Op::OpBitwiseAnd, bitcast->result_id(), mask_id); + if (t == nullptr) return false; inst->SetOpcode(spv::Op::OpBitCount); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {t->result_id()}}}); @@ -598,8 +615,11 @@ bool ReplaceCubeFaceCoord(IRContext* ctx, Instruction* inst, const_mgr->GetDefiningInstruction(vec_const)->result_id(); // Extract the input values. + // TODO(1841): Handle id overflow. Instruction* x = ir_builder.AddCompositeExtract(float_type_id, input_id, {0}); + // TODO(1841): Handle id overflow. Instruction* y = ir_builder.AddCompositeExtract(float_type_id, input_id, {1}); + // TODO(1-841): Handle id overflow. Instruction* z = ir_builder.AddCompositeExtract(float_type_id, input_id, {2}); // Negate the input values. @@ -621,10 +641,13 @@ bool ReplaceCubeFaceCoord(IRContext* ctx, Instruction* inst, // Find which values are negative. Used in later computations. Instruction* is_z_neg = ir_builder.AddBinaryOp( bool_id, spv::Op::OpFOrdLessThan, z->result_id(), f0_const_id); + if (is_z_neg == nullptr) return false; Instruction* is_y_neg = ir_builder.AddBinaryOp( bool_id, spv::Op::OpFOrdLessThan, y->result_id(), f0_const_id); + if (is_y_neg == nullptr) return false; Instruction* is_x_neg = ir_builder.AddBinaryOp( bool_id, spv::Op::OpFOrdLessThan, x->result_id(), f0_const_id); + if (is_x_neg == nullptr) return false; // Compute cubema Instruction* amax_x_y = ir_builder.AddNaryExtendedInstruction( @@ -635,36 +658,46 @@ bool ReplaceCubeFaceCoord(IRContext* ctx, Instruction* inst, {az->result_id(), amax_x_y->result_id()}); Instruction* cubema = ir_builder.AddBinaryOp(float_type_id, spv::Op::OpFMul, f2_const_id, amax->result_id()); + if (cubema == nullptr) return false; // Do the comparisons needed for computing cubesc and cubetc. Instruction* is_z_max = ir_builder.AddBinaryOp(bool_id, spv::Op::OpFOrdGreaterThanEqual, az->result_id(), amax_x_y->result_id()); + if (is_z_max == nullptr) return false; Instruction* not_is_z_max = ir_builder.AddUnaryOp( bool_id, spv::Op::OpLogicalNot, is_z_max->result_id()); Instruction* y_gr_x = ir_builder.AddBinaryOp(bool_id, spv::Op::OpFOrdGreaterThanEqual, ay->result_id(), ax->result_id()); + if (y_gr_x == nullptr) return false; Instruction* is_y_max = ir_builder.AddBinaryOp(bool_id, spv::Op::OpLogicalAnd, not_is_z_max->result_id(), y_gr_x->result_id()); + if (is_y_max == nullptr) return false; // Select the correct value for cubesc. + // TODO(1841): Handle id overflow. Instruction* cubesc_case_1 = ir_builder.AddSelect( float_type_id, is_z_neg->result_id(), nx->result_id(), x->result_id()); + // TODO(1841): Handle id overflow. Instruction* cubesc_case_2 = ir_builder.AddSelect( float_type_id, is_x_neg->result_id(), z->result_id(), nz->result_id()); Instruction* sel = + // TODO(1841): Handle id overflow. ir_builder.AddSelect(float_type_id, is_y_max->result_id(), x->result_id(), cubesc_case_2->result_id()); Instruction* cubesc = + // TODO(1841): Handle id overflow. ir_builder.AddSelect(float_type_id, is_z_max->result_id(), cubesc_case_1->result_id(), sel->result_id()); // Select the correct value for cubetc. + // TODO(1841): Handle id overflow. Instruction* cubetc_case_1 = ir_builder.AddSelect( float_type_id, is_y_neg->result_id(), nz->result_id(), z->result_id()); Instruction* cubetc = + // TODO(1841): Handle id overflow. ir_builder.AddSelect(float_type_id, is_y_max->result_id(), cubetc_case_1->result_id(), ny->result_id()); @@ -675,6 +708,7 @@ bool ReplaceCubeFaceCoord(IRContext* ctx, Instruction* inst, v2_float_type_id, {cubema->result_id(), cubema->result_id()}); Instruction* div = ir_builder.AddBinaryOp( v2_float_type_id, spv::Op::OpFDiv, cube->result_id(), denom->result_id()); + if (div == nullptr) return false; // Get the final result by adding 0.5 to |div|. inst->SetOpcode(spv::Op::OpFAdd); @@ -746,8 +780,11 @@ bool ReplaceCubeFaceIndex(IRContext* ctx, Instruction* inst, uint32_t f5_const_id = const_mgr->GetFloatConstId(5.0); // Extract the input values. + // TODO(1841): Handle id overflow. Instruction* x = ir_builder.AddCompositeExtract(float_type_id, input_id, {0}); + // TODO(1841): Handle id overflow. Instruction* y = ir_builder.AddCompositeExtract(float_type_id, input_id, {1}); + // TODO(1-841): Handle id overflow. Instruction* z = ir_builder.AddCompositeExtract(float_type_id, input_id, {2}); // Get the absolute values of the inputs. @@ -761,10 +798,13 @@ bool ReplaceCubeFaceIndex(IRContext* ctx, Instruction* inst, // Find which values are negative. Used in later computations. Instruction* is_z_neg = ir_builder.AddBinaryOp( bool_id, spv::Op::OpFOrdLessThan, z->result_id(), f0_const_id); + if (is_z_neg == nullptr) return false; Instruction* is_y_neg = ir_builder.AddBinaryOp( bool_id, spv::Op::OpFOrdLessThan, y->result_id(), f0_const_id); + if (is_y_neg == nullptr) return false; Instruction* is_x_neg = ir_builder.AddBinaryOp( bool_id, spv::Op::OpFOrdLessThan, x->result_id(), f0_const_id); + if (is_x_neg == nullptr) return false; // Find the max value. Instruction* amax_x_y = ir_builder.AddNaryExtendedInstruction( @@ -773,20 +813,26 @@ bool ReplaceCubeFaceIndex(IRContext* ctx, Instruction* inst, Instruction* is_z_max = ir_builder.AddBinaryOp(bool_id, spv::Op::OpFOrdGreaterThanEqual, az->result_id(), amax_x_y->result_id()); + if (is_z_max == nullptr) return false; Instruction* y_gr_x = ir_builder.AddBinaryOp(bool_id, spv::Op::OpFOrdGreaterThanEqual, ay->result_id(), ax->result_id()); + if (y_gr_x == nullptr) return false; // Get the value for each case. + // TODO(1841): Handle id overflow. Instruction* case_z = ir_builder.AddSelect( float_type_id, is_z_neg->result_id(), f5_const_id, f4_const_id); + // TODO(1841): Handle id overflow. Instruction* case_y = ir_builder.AddSelect( float_type_id, is_y_neg->result_id(), f3_const_id, f2_const_id); + // TODO(1841): Handle id overflow. Instruction* case_x = ir_builder.AddSelect( float_type_id, is_x_neg->result_id(), f1_const_id, f0_const_id); // Select the correct case. Instruction* sel = + // TODO(1841): Handle id overflow. ir_builder.AddSelect(float_type_id, y_gr_x->result_id(), case_y->result_id(), case_x->result_id()); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/basic_block.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/basic_block.cpp index a9fc8e2..84cf488 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/basic_block.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/basic_block.cpp @@ -29,11 +29,19 @@ constexpr uint32_t kSelectionMergeMergeBlockIdInIdx = 0; } // namespace BasicBlock* BasicBlock::Clone(IRContext* context) const { - BasicBlock* clone = new BasicBlock( - std::unique_ptr(GetLabelInst()->Clone(context))); + Instruction* label_clone = GetLabelInst()->Clone(context); + if (!label_clone) { + return nullptr; + } + BasicBlock* clone = new BasicBlock(std::unique_ptr(label_clone)); for (const auto& inst : insts_) { // Use the incoming context - clone->AddInstruction(std::unique_ptr(inst.Clone(context))); + Instruction* inst_clone = inst.Clone(context); + if (!inst_clone) { + delete clone; + return nullptr; + } + clone->AddInstruction(std::unique_ptr(inst_clone)); } if (context->AreAnalysesValid( diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/canonicalize_ids_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/canonicalize_ids_pass.cpp new file mode 100644 index 0000000..658dec5 --- /dev/null +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/canonicalize_ids_pass.cpp @@ -0,0 +1,516 @@ +// Copyright (c) 2025 LunarG Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "source/opt/canonicalize_ids_pass.h" + +#include +#include + +namespace spvtools { +namespace opt { + +Pass::Status CanonicalizeIdsPass::Process() { + // Initialize the new ID map. + new_id_.resize(GetBound(), unused_); + + // Scan the IDs and set to unmapped. + ScanIds(); + + // Create new IDs for types and consts. + CanonicalizeTypeAndConst(); + + // Create new IDs for names. + CanonicalizeNames(); + + // Create new IDs for functions. + CanonicalizeFunctions(); + + // Create new IDs for everything else. + CanonicalizeRemainders(); + + // Apply the new IDs to the module. + auto const modified = ApplyMap(); + + // Update bound in the header. + if (modified) { + UpdateBound(); + } + + return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; +} + +void CanonicalizeIdsPass::ScanIds() { + get_module()->ForEachInst( + [this](Instruction* inst) { + // Look for types and constants. + if (spvOpcodeGeneratesType(inst->opcode()) || + spvOpcodeIsConstant(inst->opcode())) { + type_and_const_ids_.push_back(inst->result_id()); + SetNewId(inst->result_id(), unmapped_); + } + // Look for names. + else if (inst->opcode() == spv::Op::OpName) { + // store name string in map so that we can compute the hash later + auto const name = inst->GetOperand(1).AsString(); + auto const target = inst->GetSingleWordInOperand(0); + name_ids_[name] = target; + SetNewId(target, unmapped_); + } + // Look for function IDs. + else if (inst->opcode() == spv::Op::OpFunction) { + auto const res_id = inst->result_id(); + function_ids_.push_back(res_id); + SetNewId(res_id, unmapped_); + } + // Look for remaining result IDs. + else if (inst->HasResultId()) { + auto const res_id = inst->result_id(); + SetNewId(res_id, unmapped_); + } + }, + true); +} + +void CanonicalizeIdsPass::CanonicalizeTypeAndConst() { + // Remap type IDs. + static constexpr std::uint32_t soft_type_id_limit = 3011; // small prime. + static constexpr std::uint32_t first_mapped_id = 8; // offset into ID space + for (auto const id : type_and_const_ids_) { + if (!IsOldIdUnmapped(id)) { + continue; + } + + // Compute the hash value. + auto const hash_value = HashTypeAndConst(id); + if (hash_value != unmapped_) { + SetNewId(id, hash_value % soft_type_id_limit + first_mapped_id); + } + } +} + +// Hash types to canonical values. This can return ID collisions (it's a bit +// inevitable): it's up to the caller to handle that gracefully. +spv::Id CanonicalizeIdsPass::HashTypeAndConst(spv::Id const id) const { + spv::Id value = 0; + + auto const inst = get_def_use_mgr()->GetDef(id); + auto const op_code = inst->opcode(); + switch (op_code) { + case spv::Op::OpTypeVoid: + value = 0; + break; + case spv::Op::OpTypeBool: + value = 1; + break; + case spv::Op::OpTypeInt: { + auto const signedness = inst->GetSingleWordOperand(2); + value = 3 + signedness; + break; + } + case spv::Op::OpTypeFloat: + value = 5; + break; + case spv::Op::OpTypeVector: { + auto const component_type = inst->GetSingleWordOperand(1); + auto const component_count = inst->GetSingleWordOperand(2); + value = 6 + HashTypeAndConst(component_type) * (component_count - 1); + break; + } + case spv::Op::OpTypeMatrix: { + auto const column_type = inst->GetSingleWordOperand(1); + auto const column_count = inst->GetSingleWordOperand(2); + value = 30 + HashTypeAndConst(column_type) * (column_count - 1); + break; + } + case spv::Op::OpTypeImage: { + // TODO: Why isn't the format used to compute the hash value? + auto const sampled_type = inst->GetSingleWordOperand(1); + auto const dim = inst->GetSingleWordOperand(2); + auto const depth = inst->GetSingleWordOperand(3); + auto const arrayed = inst->GetSingleWordOperand(4); + auto const ms = inst->GetSingleWordOperand(5); + auto const sampled = inst->GetSingleWordOperand(6); + value = 120 + HashTypeAndConst(sampled_type) + dim + depth * 8 * 16 + + arrayed * 4 * 16 + ms * 2 * 16 + sampled * 1 * 16; + break; + } + case spv::Op::OpTypeSampler: + value = 500; + break; + case spv::Op::OpTypeSampledImage: + value = 502; + break; + case spv::Op::OpTypeArray: { + auto const element_type = inst->GetSingleWordOperand(1); + auto const length = inst->GetSingleWordOperand(2); + value = 501 + HashTypeAndConst(element_type) * length; + break; + } + case spv::Op::OpTypeRuntimeArray: { + auto const element_type = inst->GetSingleWordOperand(1); + value = 5000 + HashTypeAndConst(element_type); + break; + } + case spv::Op::OpTypeStruct: + value = 10000; + for (uint32_t w = 1; w < inst->NumOperandWords(); ++w) { + value += (w + 1) * HashTypeAndConst(inst->GetSingleWordOperand(w)); + } + break; + case spv::Op::OpTypeOpaque: { + // TODO: Name is a literal that may have more than one word. + auto const name = inst->GetSingleWordOperand(1); + value = 6000 + name; + break; + } + case spv::Op::OpTypePointer: { + auto const type = inst->GetSingleWordOperand(2); + value = 100000 + HashTypeAndConst(type); + break; + } + case spv::Op::OpTypeFunction: + value = 200000; + for (uint32_t w = 1; w < inst->NumOperandWords(); ++w) { + value += (w + 1) * HashTypeAndConst(inst->GetSingleWordOperand(w)); + } + break; + case spv::Op::OpTypeEvent: + value = 300000; + break; + case spv::Op::OpTypeDeviceEvent: + value = 300001; + break; + case spv::Op::OpTypeReserveId: + value = 300002; + break; + case spv::Op::OpTypeQueue: + value = 300003; + break; + case spv::Op::OpTypePipe: + value = 300004; + break; + case spv::Op::OpTypePipeStorage: + value = 300005; + break; + case spv::Op::OpTypeNamedBarrier: + value = 300006; + break; + case spv::Op::OpConstantTrue: + value = 300007; + break; + case spv::Op::OpConstantFalse: + value = 300008; + break; + case spv::Op::OpTypeRayQueryKHR: + value = 300009; + break; + case spv::Op::OpTypeAccelerationStructureKHR: + value = 300010; + break; + // Don't map the following types. + // TODO: These types were not remapped in the glslang version of the + // remapper. Support should be added as necessary. + case spv::Op::OpTypeCooperativeMatrixNV: + case spv::Op::OpTypeCooperativeMatrixKHR: + case spv::Op::OpTypeCooperativeVectorNV: + case spv::Op::OpTypeHitObjectNV: + case spv::Op::OpTypeUntypedPointerKHR: + case spv::Op::OpTypeNodePayloadArrayAMDX: + case spv::Op::OpTypeTensorLayoutNV: + case spv::Op::OpTypeTensorViewNV: + case spv::Op::OpTypeTensorARM: + case spv::Op::OpTypeTaskSequenceINTEL: + value = unmapped_; + break; + case spv::Op::OpConstant: { + auto const result_type = inst->GetSingleWordOperand(0); + value = 400011 + HashTypeAndConst(result_type); + auto const literal = inst->GetOperand(2); + for (uint32_t w = 0; w < literal.words.size(); ++w) { + value += (w + 3) * literal.words[w]; + } + break; + } + case spv::Op::OpConstantComposite: { + auto const result_type = inst->GetSingleWordOperand(0); + value = 300011 + HashTypeAndConst(result_type); + for (uint32_t w = 2; w < inst->NumOperandWords(); ++w) { + value += (w + 1) * HashTypeAndConst(inst->GetSingleWordOperand(w)); + } + break; + } + case spv::Op::OpConstantNull: { + auto const result_type = inst->GetSingleWordOperand(0); + value = 500009 + HashTypeAndConst(result_type); + break; + } + case spv::Op::OpConstantSampler: { + auto const result_type = inst->GetSingleWordOperand(0); + value = 600011 + HashTypeAndConst(result_type); + for (uint32_t w = 2; w < inst->NumOperandWords(); ++w) { + value += (w + 1) * inst->GetSingleWordOperand(w); + } + break; + } + // Don't map the following constants. + // TODO: These constants were not remapped in the glslang version of the + // remapper. Support should be added as necessary. + case spv::Op::OpConstantCompositeReplicateEXT: + case spv::Op::OpConstantFunctionPointerINTEL: + case spv::Op::OpConstantStringAMDX: + case spv::Op::OpSpecConstantTrue: + case spv::Op::OpSpecConstantFalse: + case spv::Op::OpSpecConstant: + case spv::Op::OpSpecConstantComposite: + case spv::Op::OpSpecConstantCompositeReplicateEXT: + case spv::Op::OpSpecConstantOp: + case spv::Op::OpSpecConstantStringAMDX: + value = unmapped_; + break; + // TODO: Add additional types/constants as needed. See + // spvOpcodeGeneratesType and spvOpcodeIsConstant. + default: + context()->consumer()(SPV_MSG_WARNING, "", {0, 0, 0}, + "unhandled opcode will not be canonicalized"); + break; + } + + return value; +} + +void CanonicalizeIdsPass::CanonicalizeNames() { + static constexpr std::uint32_t soft_type_id_limit = 3011; // Small prime. + static constexpr std::uint32_t first_mapped_id = + 3019; // Offset into ID space. + + for (auto const& [name, target] : name_ids_) { + if (!IsOldIdUnmapped(target)) { + continue; + } + + spv::Id hash_value = 1911; + for (const char c : name) { + hash_value = hash_value * 1009 + c; + } + + if (IsOldIdUnmapped(target)) { + SetNewId(target, hash_value % soft_type_id_limit + first_mapped_id); + } + } +} + +void CanonicalizeIdsPass::CanonicalizeFunctions() { + static constexpr std::uint32_t soft_type_id_limit = 19071; // Small prime. + static constexpr std::uint32_t first_mapped_id = + 6203; // Offset into ID space. + // Window size for context-sensitive canonicalization values + // Empirical best size from a single data set. TODO: Would be a good tunable. + // We essentially perform a little convolution around each instruction, + // to capture the flavor of nearby code, to hopefully match to similar + // code in other modules. + static const int32_t window_size = 2; + + for (auto const func_id : function_ids_) { + // Store the instructions and opcode hash values in vectors so that the + // window of instructions can be easily accessed and avoid having to + // recompute the hash value repeatedly in overlapping windows. + std::vector insts; + std::vector opcode_hashvals; + auto const func = context()->GetFunction(func_id); + func->WhileEachInst([&](Instruction* inst) { + insts.emplace_back(inst); + opcode_hashvals.emplace_back(HashOpCode(inst)); + return true; + }); + + // For every instruction in the function, compute the hash value using the + // instruction and a small window of surrounding instructions. + assert(insts.size() < (size_t)std::numeric_limits::max()); + for (int32_t i = 0; i < (int32_t)insts.size(); ++i) { + auto const inst = insts[i]; + if (!inst->HasResultId()) { + continue; + } + + auto const old_id = inst->result_id(); + if (!IsOldIdUnmapped(old_id)) { + continue; + } + + int32_t const lower_bound = std::max(0, i - window_size); + int32_t const upper_bound = + std::min((int32_t)insts.size() - 1, i + window_size); + spv::Id hash_value = func_id * 17; // Small prime. + // Include the hash value of the preceding instructions in the hash but + // don't include instructions before the OpFunction. + for (int32_t j = i - 1; j >= lower_bound; --j) { + auto const local_inst = insts[j]; + if (local_inst->opcode() == spv::Op::OpFunction) { + break; + } + + hash_value = hash_value * 30103 + + opcode_hashvals[j]; // 30103 is a semi-arbitrary prime. + } + + // Include the hash value of the subsequent instructions in the hash but + // don't include instructions past OpFunctionEnd. + for (int32_t j = i; j <= upper_bound; ++j) { + auto const local_inst = insts[j]; + if (local_inst->opcode() == spv::Op::OpFunctionEnd) { + break; + } + + hash_value = hash_value * 30103 + + opcode_hashvals[j]; // 30103 is a semiarbitrary prime. + } + + SetNewId(old_id, hash_value % soft_type_id_limit + first_mapped_id); + } + } +} + +spv::Id CanonicalizeIdsPass::HashOpCode(Instruction const* const inst) const { + auto const op_code = inst->opcode(); + std::uint32_t offset = 0; + if (op_code == spv::Op::OpExtInst) { + // offset is literal instruction + offset = inst->GetSingleWordOperand(3); + } + + return (std::uint32_t)op_code * 19 + offset; // 19 is a small prime. +} + +// Assign remaining IDs sequentially from remaining holes in the new ID space. +void CanonicalizeIdsPass::CanonicalizeRemainders() { + spv::Id next_id = 1; + for (uint32_t old_id = 0; old_id < new_id_.size(); ++old_id) { + if (IsOldIdUnmapped(old_id)) { + next_id = SetNewId(old_id, next_id); + } + } +} + +bool CanonicalizeIdsPass::ApplyMap() { + bool modified = false; + context()->module()->ForEachInst( + [this, &modified](Instruction* inst) { + for (auto operand = inst->begin(); operand != inst->end(); ++operand) { + const auto type = operand->type; + if (spvIsIdType(type)) { + uint32_t& id = operand->words[0]; + uint32_t const new_id = GetNewId(id); + if (new_id == unused_) { + continue; + } + + assert(new_id != unmapped_ && "new_id should not be unmapped_"); + + if (id != new_id) { + modified = true; + id = new_id; + if (type == SPV_OPERAND_TYPE_RESULT_ID) { + inst->SetResultId(new_id); + } else if (type == SPV_OPERAND_TYPE_TYPE_ID) { + inst->SetResultType(new_id); + } + } + } + } + }, + true); + + return modified; +} + +spv::Id CanonicalizeIdsPass::GetBound() const { + return context()->module()->id_bound(); +} + +void CanonicalizeIdsPass::UpdateBound() { + context()->module()->SetIdBound(context()->module()->ComputeIdBound()); + + context()->ResetFeatureManager(); +} + +// Set a new ID. If the new ID is alreadly claimed, the next consecutive ID +// will be claimed, mapped, and returned to the caller. +spv::Id CanonicalizeIdsPass::SetNewId(spv::Id const old_id, spv::Id new_id) { + assert(old_id < GetBound() && "don't remap an ID that is out of bounds"); + + if (old_id >= new_id_.size()) { + new_id_.resize(old_id + 1, unused_); + } + + if (new_id != unmapped_ && new_id != unused_) { + assert(!IsOldIdUnused(old_id) && "don't remap unused IDs"); + assert(IsOldIdUnmapped(old_id) && "don't remap already mapped IDs"); + + new_id = ClaimNewId(new_id); + } + + new_id_[old_id] = new_id; + + return new_id; +} + +// Helper function for SetNewID. Claim a new ID. If the new ID is already +// claimed, the next consecutive ID will be claimed and returned to the caller. +spv::Id CanonicalizeIdsPass::ClaimNewId(spv::Id new_id) { + // Return the ID if it's not taken. + auto iter = claimed_new_ids_.find(new_id); + if (iter != claimed_new_ids_.end()) { + // Otherwise, search for the next unused ID using our current iterator. + // Technically, it's a linear search across the set starting at the + // iterator, but it's not as bad as it would appear in practice assuming the + // hash values are well distributed. + iter = std::adjacent_find(iter, claimed_new_ids_.end(), [](int a, int b) { + return a + 1 != b; // Stop at the first non-consecutive pair. + }); + if (iter != claimed_new_ids_.end()) { + new_id = + *iter + 1; // We need the next ID after where the search stopped. + } else { + new_id = *(--iter) + 1; // We reached the end so we use the next ID. + } + } + + assert(!IsNewIdClaimed(new_id) && + "don't remap to an ID that is already claimed"); + iter = claimed_new_ids_.insert(iter, new_id); + assert(*iter == new_id); + + return new_id; +} + +std::string CanonicalizeIdsPass::IdAsString(spv::Id const id) const { + if (id == unused_) { + return "unused"; + } else if (id == unmapped_) { + return "unmapped"; + } else { + return std::to_string(id); + } +} + +void CanonicalizeIdsPass::PrintNewIds() const { + for (spv::Id id = 0; id < new_id_.size(); ++id) { + auto const message = + "new id[" + IdAsString(id) + "]: " + IdAsString(new_id_[id]); + context()->consumer()(SPV_MSG_INFO, "", {0, 0, 0}, message.c_str()); + } +} + +} // namespace opt +} // namespace spvtools diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/canonicalize_ids_pass.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/canonicalize_ids_pass.h new file mode 100644 index 0000000..6c38d34 --- /dev/null +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/canonicalize_ids_pass.h @@ -0,0 +1,115 @@ +// Copyright (c) 2025 LunarG Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include +#include + +#include "source/opt/pass.h" + +namespace spvtools { +namespace opt { + +// The canonicalize IDs pass is an optimization to improve compression of SPIR-V +// binary files via entropy reduction. It transforms SPIR-V to SPIR-V, remapping +// IDs. The resulting modules have an increased ID range (IDs are not as tightly +// packed around zero), but will compress better when multiple modules are +// compressed together, since the compressor's dictionary can find better cross +// module commonality. Remapping is accomplished via canonicalization. Thus, +// modules can be compressed one at a time with no loss of quality relative to +// operating on many modules at once. + +// This pass should be run after most optimization passes except for +// --strip-debug because this pass will use OpName to canonicalize IDs. i.e. Run +// --strip-debug after this pass. + +// This is a port of remap utility in glslang. There are great deal of magic +// numbers that are present throughout this code. The general goal is to replace +// the IDs with a hash value such that the distribution of IDs is deterministic +// and minimizes collisions. The magic numbers in the glslang version were +// chosen semi-arbitrarily and have been preserved in this port in order to +// maintain backward compatibility. + +class CanonicalizeIdsPass : public Pass { + public: + CanonicalizeIdsPass() = default; + virtual ~CanonicalizeIdsPass() = default; + + Pass::Status Process() override; + + const char* name() const override { return "canonicalize-ids"; } + + private: + // Special values for IDs. + static constexpr spv::Id unmapped_{spv::Id(-10000)}; + static constexpr spv::Id unused_{spv::Id(-10001)}; + + // Scans the module for IDs and sets them to unmapped_. + void ScanIds(); + + // Functions to compute new IDs. + void CanonicalizeTypeAndConst(); + spv::Id HashTypeAndConst( + spv::Id const id) const; // Helper for CanonicalizeTypeAndConst. + void CanonicalizeNames(); + void CanonicalizeFunctions(); + spv::Id HashOpCode(Instruction const* const inst) + const; // Helper for CanonicalizeFunctions. + void CanonicalizeRemainders(); + + // Applies the new IDs. + bool ApplyMap(); + + // Methods to manage the bound field in header. + spv::Id GetBound() const; // All IDs must satisfy 0 < ID < bound. + void UpdateBound(); + + // Methods to map from old IDs to new IDs. + spv::Id GetNewId(spv::Id const old_id) const { return new_id_[old_id]; } + spv::Id SetNewId(spv::Id const old_id, spv::Id new_id); + + // Methods to manage claimed IDs. + spv::Id ClaimNewId(spv::Id new_id); + bool IsNewIdClaimed(spv::Id const new_id) const { + return claimed_new_ids_.find(new_id) != claimed_new_ids_.end(); + } + + // Queries for old IDs. + bool IsOldIdUnmapped(spv::Id const old_id) const { + return GetNewId(old_id) == unmapped_; + } + bool IsOldIdUnused(spv::Id const old_id) const { + return GetNewId(old_id) == unused_; + } + + // Container to map old IDs to new IDs. e.g. new_id_[old_id] = new_id + std::vector new_id_; + + // IDs from the new ID space that have been claimed (faster than searching + // through new_id_). + std::set claimed_new_ids_; + + // Helper functions for printing IDs (useful for debugging). + std::string IdAsString(spv::Id const id) const; + void PrintNewIds() const; + + // Containers to track IDs we want to canonicalize. + std::vector type_and_const_ids_; + std::map name_ids_; + std::vector function_ids_; +}; + +} // namespace opt +} // namespace spvtools diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/ccp_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/ccp_pass.cpp index 46bfc90..c53ee19 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/ccp_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/ccp_pass.cpp @@ -165,6 +165,9 @@ SSAPropagator::PropStatus CCPPass::VisitAssignment(Instruction* instr) { context()->get_instruction_folder().FoldInstructionToConstant(instr, map_func); + if (folded_inst && context()->id_overflow()) { + return SSAPropagator::kFailed; + } if (folded_inst != nullptr) { // We do not want to change the body of the function by adding new // instructions. When folding we can only generate new constants. @@ -360,6 +363,13 @@ void CCPPass::Initialize() { } } + // Mark the extended instruction imports as `kVarying`. We know they + // will not be constants, and will be used by `OpExtInst` instructions. + // This allows those instructions to be fully processed. + for (const auto& inst : get_module()->ext_inst_imports()) { + values_[inst.result_id()] = kVaryingSSAId; + } + original_id_bound_ = context()->module()->IdBound(); } @@ -369,6 +379,7 @@ Pass::Status CCPPass::Process() { // Process all entry point functions. ProcessFunction pfn = [this](Function* fp) { return PropagateConstants(fp); }; bool modified = context()->ProcessReachableCallTree(pfn); + if (context()->id_overflow()) return Pass::Status::Failure; return modified ? Pass::Status::SuccessWithChange : Pass::Status::SuccessWithoutChange; } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/cfg.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/cfg.cpp index 4c4bb25..5f4a7d1 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/cfg.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/cfg.cpp @@ -254,12 +254,13 @@ BasicBlock* CFG::SplitLoopHeader(BasicBlock* bb) { } // Adjust the OpPhi instructions as needed. - bb->ForEachPhiInst([latch_block, bb, new_header, context](Instruction* phi) { + bool ok = bb->WhileEachPhiInst([latch_block, bb, new_header, + context](Instruction* phi) -> bool { std::vector preheader_phi_ops; std::vector header_phi_ops; - // Identify where the original inputs to original OpPhi belong: header or - // preheader. + // Identify where the original inputs to original OpPhi belong: header + // or preheader. for (uint32_t i = 0; i < phi->NumInOperands(); i += 2) { uint32_t def_id = phi->GetSingleWordInOperand(i); uint32_t branch_id = phi->GetSingleWordInOperand(i + 1); @@ -272,21 +273,24 @@ BasicBlock* CFG::SplitLoopHeader(BasicBlock* bb) { } } - // Create a phi instruction if and only if the preheader_phi_ops has more - // than one pair. + // Create a phi instruction if and only if the preheader_phi_ops has + // more than one pair. if (preheader_phi_ops.size() > 2) { InstructionBuilder builder( context, &*bb->begin(), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* new_phi = builder.AddPhi(phi->type_id(), preheader_phi_ops); + if (!new_phi) { + return false; + } // Add the OpPhi to the header bb. header_phi_ops.push_back({SPV_OPERAND_TYPE_ID, {new_phi->result_id()}}); header_phi_ops.push_back({SPV_OPERAND_TYPE_ID, {bb->id()}}); } else { - // An OpPhi with a single entry is just a copy. In this case use the same - // instruction in the new header. + // An OpPhi with a single entry is just a copy. In this case use the + // same instruction in the new header. header_phi_ops.push_back({SPV_OPERAND_TYPE_ID, {preheader_phi_ops[0]}}); header_phi_ops.push_back({SPV_OPERAND_TYPE_ID, {bb->id()}}); } @@ -297,8 +301,13 @@ BasicBlock* CFG::SplitLoopHeader(BasicBlock* bb) { new_header->begin()->InsertBefore(std::move(phi_owner)); context->set_instr_block(phi, new_header); context->AnalyzeUses(phi); + return true; }); + if (!ok) { + return nullptr; + } + // Add a branch to the new header. InstructionBuilder branch_builder( context, bb, diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/combine_access_chains.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/combine_access_chains.cpp index 99ec796..734c967 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/combine_access_chains.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/combine_access_chains.cpp @@ -158,6 +158,7 @@ bool CombineAccessChains::CombineIndices(Instruction* ptr_input, InstructionBuilder builder( context(), inst, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); + // TODO(1841): Handle id overflow. Instruction* addition = builder.AddIAdd(last_index_inst->type_id(), last_index_inst->result_id(), element_inst->result_id()); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/const_folding_rules.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/const_folding_rules.cpp index a5d4cbe..0f4e440 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/const_folding_rules.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/const_folding_rules.cpp @@ -829,7 +829,9 @@ const analysis::Constant* FoldFPBinaryOp( // Build the constant object and return it. std::vector ids; for (const analysis::Constant* member : results_components) { - ids.push_back(const_mgr->GetDefiningInstruction(member)->result_id()); + Instruction* def = const_mgr->GetDefiningInstruction(member); + if (!def) return nullptr; + ids.push_back(def->result_id()); } return const_mgr->GetConstant(vector_type, ids); } else { @@ -1395,13 +1397,18 @@ ConstantFoldingRule FoldFMix() { if (base_type->AsFloat()->width() == 32) { one = const_mgr->GetConstant(base_type, utils::FloatProxy(1.0f).GetWords()); - } else { + } else if (base_type->AsFloat()->width() == 64) { one = const_mgr->GetConstant(base_type, utils::FloatProxy(1.0).GetWords()); + } else { + // We won't support folding half types. + return nullptr; } if (is_vector) { - uint32_t one_id = const_mgr->GetDefiningInstruction(one)->result_id(); + Instruction* one_inst = const_mgr->GetDefiningInstruction(one); + if (one_inst == nullptr) return nullptr; + uint32_t one_id = one_inst->result_id(); one = const_mgr->GetConstant(result_type, std::vector(4, one_id)); } @@ -1433,14 +1440,29 @@ const analysis::Constant* FoldMin(const analysis::Type* result_type, const analysis::Constant* b, analysis::ConstantManager*) { if (const analysis::Integer* int_type = result_type->AsInteger()) { - if (int_type->width() == 32) { + if (int_type->width() <= 32) { + assert( + (a->AsIntConstant() != nullptr || a->AsNullConstant() != nullptr) && + "Must be an integer or null constant."); + assert( + (b->AsIntConstant() != nullptr || b->AsNullConstant() != nullptr) && + "Must be an integer or null constant."); + if (int_type->IsSigned()) { - int32_t va = a->GetS32(); - int32_t vb = b->GetS32(); + int32_t va = (a->AsIntConstant() != nullptr) + ? a->AsIntConstant()->GetS32BitValue() + : 0; + int32_t vb = (b->AsIntConstant() != nullptr) + ? b->AsIntConstant()->GetS32BitValue() + : 0; return (va < vb ? a : b); } else { - uint32_t va = a->GetU32(); - uint32_t vb = b->GetU32(); + uint32_t va = (a->AsIntConstant() != nullptr) + ? a->AsIntConstant()->GetU32BitValue() + : 0; + uint32_t vb = (b->AsIntConstant() != nullptr) + ? b->AsIntConstant()->GetU32BitValue() + : 0; return (va < vb ? a : b); } } else if (int_type->width() == 64) { @@ -1473,14 +1495,29 @@ const analysis::Constant* FoldMax(const analysis::Type* result_type, const analysis::Constant* b, analysis::ConstantManager*) { if (const analysis::Integer* int_type = result_type->AsInteger()) { - if (int_type->width() == 32) { + if (int_type->width() <= 32) { + assert( + (a->AsIntConstant() != nullptr || a->AsNullConstant() != nullptr) && + "Must be an integer or null constant."); + assert( + (b->AsIntConstant() != nullptr || b->AsNullConstant() != nullptr) && + "Must be an integer or null constant."); + if (int_type->IsSigned()) { - int32_t va = a->GetS32(); - int32_t vb = b->GetS32(); + int32_t va = (a->AsIntConstant() != nullptr) + ? a->AsIntConstant()->GetS32BitValue() + : 0; + int32_t vb = (b->AsIntConstant() != nullptr) + ? b->AsIntConstant()->GetS32BitValue() + : 0; return (va > vb ? a : b); } else { - uint32_t va = a->GetU32(); - uint32_t vb = b->GetU32(); + uint32_t va = (a->AsIntConstant() != nullptr) + ? a->AsIntConstant()->GetU32BitValue() + : 0; + uint32_t vb = (b->AsIntConstant() != nullptr) + ? b->AsIntConstant()->GetU32BitValue() + : 0; return (va > vb ? a : b); } } else if (int_type->width() == 64) { diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/constants.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/constants.cpp index 7dc02de..00682d0 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/constants.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/constants.cpp @@ -315,6 +315,7 @@ const Constant* ConstantManager::GetConstantFromInst(const Instruction* inst) { case spv::Op::OpConstant: case spv::Op::OpConstantComposite: case spv::Op::OpSpecConstantComposite: + case spv::Op::OpSpecConstantCompositeReplicateEXT: break; default: return nullptr; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/convert_to_half_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/convert_to_half_pass.cpp index e243bed..77558c7 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/convert_to_half_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/convert_to_half_pass.cpp @@ -75,6 +75,9 @@ analysis::Type* ConvertToHalfPass::FloatScalarType(uint32_t width) { analysis::Type* ConvertToHalfPass::FloatVectorType(uint32_t v_len, uint32_t width) { analysis::Type* reg_float_ty = FloatScalarType(width); + if (reg_float_ty == nullptr) { + return nullptr; + } analysis::Vector vec_ty(reg_float_ty, v_len); return context()->get_type_mgr()->GetRegisteredType(&vec_ty); } @@ -85,6 +88,9 @@ analysis::Type* ConvertToHalfPass::FloatMatrixType(uint32_t v_cnt, Instruction* vty_inst = get_def_use_mgr()->GetDef(vty_id); uint32_t v_len = vty_inst->GetSingleWordInOperand(1); analysis::Type* reg_vec_ty = FloatVectorType(v_len, width); + if (reg_vec_ty == nullptr) { + return nullptr; + } analysis::Matrix mat_ty(reg_vec_ty, v_cnt); return context()->get_type_mgr()->GetRegisteredType(&mat_ty); } @@ -99,6 +105,9 @@ uint32_t ConvertToHalfPass::EquivFloatTypeId(uint32_t ty_id, uint32_t width) { reg_equiv_ty = FloatVectorType(ty_inst->GetSingleWordInOperand(1), width); else // spv::Op::OpTypeFloat reg_equiv_ty = FloatScalarType(width); + if (reg_equiv_ty == nullptr) { + return 0; + } return context()->get_type_mgr()->GetTypeInstruction(reg_equiv_ty); } @@ -107,6 +116,10 @@ void ConvertToHalfPass::GenConvert(uint32_t* val_idp, uint32_t width, Instruction* val_inst = get_def_use_mgr()->GetDef(*val_idp); uint32_t ty_id = val_inst->type_id(); uint32_t nty_id = EquivFloatTypeId(ty_id, width); + if (nty_id == 0) { + status_ = Status::Failure; + return; + } if (nty_id == ty_id) return; Instruction* cvt_inst; InstructionBuilder builder( @@ -116,6 +129,10 @@ void ConvertToHalfPass::GenConvert(uint32_t* val_idp, uint32_t width, cvt_inst = builder.AddNullaryOp(nty_id, spv::Op::OpUndef); else cvt_inst = builder.AddUnaryOp(nty_id, spv::Op::OpFConvert, *val_idp); + if (cvt_inst == nullptr) { + status_ = Status::Failure; + return; + } *val_idp = cvt_inst->result_id(); } @@ -137,22 +154,43 @@ bool ConvertToHalfPass::MatConvertCleanup(Instruction* inst) { uint32_t orig_width = (cty_inst->GetSingleWordInOperand(0) == 16) ? 32 : 16; uint32_t orig_mat_id = inst->GetSingleWordInOperand(0); uint32_t orig_vty_id = EquivFloatTypeId(vty_id, orig_width); + if (orig_vty_id == 0) { + status_ = Status::Failure; + return false; + } std::vector opnds = {}; for (uint32_t vidx = 0; vidx < v_cnt; ++vidx) { Instruction* ext_inst = builder.AddIdLiteralOp( orig_vty_id, spv::Op::OpCompositeExtract, orig_mat_id, vidx); + if (ext_inst == nullptr) { + status_ = Status::Failure; + return false; + } Instruction* cvt_inst = builder.AddUnaryOp(vty_id, spv::Op::OpFConvert, ext_inst->result_id()); + if (cvt_inst == nullptr) { + status_ = Status::Failure; + return false; + } opnds.push_back({SPV_OPERAND_TYPE_ID, {cvt_inst->result_id()}}); } uint32_t mat_id = TakeNextId(); + if (mat_id == 0) { + status_ = Status::Failure; + return false; + } std::unique_ptr mat_inst(new Instruction( context(), spv::Op::OpCompositeConstruct, mty_id, mat_id, opnds)); (void)builder.AddInstruction(std::move(mat_inst)); context()->ReplaceAllUsesWith(inst->result_id(), mat_id); // Turn original instruction into copy so it is valid. + uint32_t new_type_id = EquivFloatTypeId(mty_id, orig_width); + if (new_type_id == 0) { + status_ = Status::Failure; + return false; + } inst->SetOpcode(spv::Op::OpCopyObject); - inst->SetResultType(EquivFloatTypeId(mty_id, orig_width)); + inst->SetResultType(new_type_id); get_def_use_mgr()->AnalyzeInstUse(inst); return true; } @@ -187,13 +225,24 @@ bool ConvertToHalfPass::GenHalfArith(Instruction* inst) { // Convert all float32 based operands to float16 equivalent and change // instruction type to float16 equivalent. inst->ForEachInId([&inst, &modified, this](uint32_t* idp) { + if (status_ == Status::Failure) { + return; + } Instruction* op_inst = get_def_use_mgr()->GetDef(*idp); if (!IsFloat(op_inst, 32)) return; GenConvert(idp, 16, inst); modified = true; }); + if (status_ == Status::Failure) { + return false; + } if (IsFloat(inst, 32)) { - inst->SetResultType(EquivFloatTypeId(inst->type_id(), 16)); + uint32_t new_type_id = EquivFloatTypeId(inst->type_id(), 16); + if (new_type_id == 0) { + status_ = Status::Failure; + return false; + } + inst->SetResultType(new_type_id); converted_ids_.insert(inst->result_id()); modified = true; } @@ -211,6 +260,9 @@ bool ConvertToHalfPass::ProcessPhi(Instruction* inst, uint32_t from_width, bool modified = false; inst->ForEachInId([&ocnt, &prev_idp, &from_width, &to_width, &modified, this](uint32_t* idp) { + if (status_ == Status::Failure) { + return; + } if (ocnt % 2 == 0) { prev_idp = idp; } else { @@ -230,8 +282,16 @@ bool ConvertToHalfPass::ProcessPhi(Instruction* inst, uint32_t from_width, } ++ocnt; }); + if (status_ == Status::Failure) { + return false; + } if (to_width == 16u) { - inst->SetResultType(EquivFloatTypeId(inst->type_id(), 16u)); + uint32_t new_type_id = EquivFloatTypeId(inst->type_id(), 16u); + if (new_type_id == 0) { + status_ = Status::Failure; + return false; + } + inst->SetResultType(new_type_id); converted_ids_.insert(inst->result_id()); modified = true; } @@ -242,7 +302,12 @@ bool ConvertToHalfPass::ProcessPhi(Instruction* inst, uint32_t from_width, bool ConvertToHalfPass::ProcessConvert(Instruction* inst) { // If float32 and relaxed, change to float16 convert if (IsFloat(inst, 32) && IsRelaxed(inst->result_id())) { - inst->SetResultType(EquivFloatTypeId(inst->type_id(), 16)); + uint32_t new_type_id = EquivFloatTypeId(inst->type_id(), 16); + if (new_type_id == 0) { + status_ = Status::Failure; + return false; + } + inst->SetResultType(new_type_id); get_def_use_mgr()->AnalyzeInstUse(inst); converted_ids_.insert(inst->result_id()); } @@ -255,7 +320,7 @@ bool ConvertToHalfPass::ProcessConvert(Instruction* inst) { Instruction* val_inst = get_def_use_mgr()->GetDef(val_id); if (inst->type_id() == val_inst->type_id()) inst->SetOpcode(spv::Op::OpCopyObject); - return true; // modified + return true; } bool ConvertToHalfPass::ProcessImageRef(Instruction* inst) { @@ -265,6 +330,9 @@ bool ConvertToHalfPass::ProcessImageRef(Instruction* inst) { uint32_t dref_id = inst->GetSingleWordInOperand(kImageSampleDrefIdInIdx); if (converted_ids_.count(dref_id) > 0) { GenConvert(&dref_id, 32, inst); + if (status_ == Status::Failure) { + return false; + } inst->SetInOperand(kImageSampleDrefIdInIdx, {dref_id}); get_def_use_mgr()->AnalyzeInstUse(inst); modified = true; @@ -279,11 +347,17 @@ bool ConvertToHalfPass::ProcessDefault(Instruction* inst) { if (inst->opcode() == spv::Op::OpPhi) return ProcessPhi(inst, 16u, 32u); bool modified = false; inst->ForEachInId([&inst, &modified, this](uint32_t* idp) { + if (status_ == Status::Failure) { + return; + } if (converted_ids_.count(*idp) == 0) return; uint32_t old_id = *idp; GenConvert(idp, 32, inst); if (*idp != old_id) modified = true; }); + if (status_ == Status::Failure) { + return false; + } if (modified) get_def_use_mgr()->AnalyzeInstUse(inst); return modified; } @@ -370,19 +444,38 @@ bool ConvertToHalfPass::ProcessFunction(Function* func) { }); // Replace invalid converts of matrix into equivalent vector extracts, // converts and finally a composite construct + bool ok = true; cfg()->ForEachBlockInReversePostOrder( - func->entry().get(), [&modified, this](BasicBlock* bb) { - for (auto ii = bb->begin(); ii != bb->end(); ++ii) - modified |= MatConvertCleanup(&*ii); + func->entry().get(), [&modified, &ok, this](BasicBlock* bb) { + if (!ok) { + return; + } + for (auto ii = bb->begin(); ii != bb->end(); ++ii) { + bool Mmodified = MatConvertCleanup(&*ii); + if (status_ == Status::Failure) { + ok = false; + break; + } + modified |= Mmodified; + } }); + + if (!ok) { + return false; + } return modified; } Pass::Status ConvertToHalfPass::ProcessImpl() { + status_ = Status::SuccessWithoutChange; Pass::ProcessFunction pfn = [this](Function* fp) { return ProcessFunction(fp); }; bool modified = context()->ProcessReachableCallTree(pfn); + if (status_ == Status::Failure) { + return status_; + } + // If modified, make sure module has Float16 capability if (modified) context()->AddCapability(spv::Capability::Float16); // Remove all RelaxedPrecision decorations from instructions and globals @@ -514,4 +607,4 @@ void ConvertToHalfPass::Initialize() { } } // namespace opt -} // namespace spvtools +} // namespace spvtools \ No newline at end of file diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/convert_to_half_pass.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/convert_to_half_pass.h index 8e10c4f..6e97a2d 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/convert_to_half_pass.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/convert_to_half_pass.h @@ -130,6 +130,9 @@ class ConvertToHalfPass : public Pass { } }; + // The status of the pass. + Pass::Status status_; + // Set of core operations to be processed std::unordered_set target_ops_core_; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/convert_to_sampled_image_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/convert_to_sampled_image_pass.cpp index d2da4d1..e720392 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/convert_to_sampled_image_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/convert_to_sampled_image_pass.cpp @@ -246,9 +246,10 @@ Instruction* ConvertToSampledImagePass::CreateImageExtraction( InstructionBuilder builder( context(), sampled_image->NextNode(), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); - return builder.AddUnaryOp( + Instruction* result = builder.AddUnaryOp( GetImageTypeOfSampledImage(context()->get_type_mgr(), sampled_image), spv::Op::OpImage, sampled_image->result_id()); + return result; } uint32_t ConvertToSampledImagePass::GetSampledImageTypeForImage( @@ -270,6 +271,9 @@ Instruction* ConvertToSampledImagePass::UpdateImageUses( if (uses_of_load.empty()) return nullptr; auto* extracted_image = CreateImageExtraction(sampled_image_load); + if (extracted_image == nullptr) { + return nullptr; + } for (auto* user : uses_of_load) { user->SetInOperand(0, {extracted_image->result_id()}); context()->get_def_use_mgr()->AnalyzeInstUse(user); @@ -306,8 +310,12 @@ void ConvertToSampledImagePass::UpdateSampledImageUses( def_use_mgr->AnalyzeInstUse(image_load); context()->KillInst(sampled_image_inst); } else { - if (!image_extraction) + if (!image_extraction) { image_extraction = CreateImageExtraction(image_load); + if (image_extraction == nullptr) { + return; + } + } sampled_image_inst->SetInOperand(0, {image_extraction->result_id()}); def_use_mgr->AnalyzeInstUse(sampled_image_inst); } @@ -333,6 +341,9 @@ bool ConvertToSampledImagePass::ConvertImageVariableToSampledImage( // reference. uint32_t type_id = context()->get_type_mgr()->FindPointerToType( sampled_image_type_id, storage_class); + if (type_id == 0) { + return false; + } MoveInstructionNextToType(image_variable, type_id); return true; } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/debug_info_manager.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/debug_info_manager.cpp index 24094b3..c084a6c 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/debug_info_manager.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/debug_info_manager.cpp @@ -390,6 +390,7 @@ Instruction* DebugInfoManager::GetDebugInfoNone() { if (debug_info_none_inst_ != nullptr) return debug_info_none_inst_; uint32_t result_id = context()->TakeNextId(); + if (result_id == 0) return nullptr; std::unique_ptr dbg_info_none_inst(new Instruction( context(), spv::Op::OpExtInst, context()->get_type_mgr()->GetVoidTypeId(), result_id, @@ -558,11 +559,11 @@ bool DebugInfoManager::IsDeclareVisibleToInstr(Instruction* dbg_declare, return false; } -bool DebugInfoManager::AddDebugValueForVariable(Instruction* scope_and_line, +bool DebugInfoManager::AddDebugValueForVariable(Instruction* line, uint32_t variable_id, uint32_t value_id, Instruction* insert_pos) { - assert(scope_and_line != nullptr); + assert(line != nullptr); auto dbg_decl_itr = var_id_to_dbg_decl_.find(variable_id); if (dbg_decl_itr == var_id_to_dbg_decl_.end()) return false; @@ -577,14 +578,15 @@ bool DebugInfoManager::AddDebugValueForVariable(Instruction* scope_and_line, insert_before = insert_before->NextNode(); } modified |= AddDebugValueForDecl(dbg_decl_or_val, value_id, insert_before, - scope_and_line) != nullptr; + line) != nullptr; } return modified; } -Instruction* DebugInfoManager::AddDebugValueForDecl( - Instruction* dbg_decl, uint32_t value_id, Instruction* insert_before, - Instruction* scope_and_line) { +Instruction* DebugInfoManager::AddDebugValueForDecl(Instruction* dbg_decl, + uint32_t value_id, + Instruction* insert_before, + Instruction* line) { if (dbg_decl == nullptr || !IsDebugDeclare(dbg_decl)) return nullptr; std::unique_ptr dbg_val(dbg_decl->Clone(context())); @@ -593,7 +595,7 @@ Instruction* DebugInfoManager::AddDebugValueForDecl( dbg_val->SetOperand(kDebugDeclareOperandVariableIndex, {value_id}); dbg_val->SetOperand(kDebugValueOperandExpressionIndex, {GetEmptyDebugExpression()->result_id()}); - dbg_val->UpdateDebugInfoFrom(scope_and_line); + dbg_val->UpdateDebugInfoFrom(dbg_decl, line); auto* added_dbg_val = insert_before->InsertBefore(std::move(dbg_val)); AnalyzeDebugInst(added_dbg_val); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/debug_info_manager.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/debug_info_manager.h index abb7b9a..631aedd 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/debug_info_manager.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/debug_info_manager.h @@ -143,22 +143,21 @@ class DebugInfoManager { bool KillDebugDeclares(uint32_t variable_id); // Generates a DebugValue instruction with value |value_id| for every local - // variable that is in the scope of |scope_and_line| and whose memory is - // |variable_id| and inserts it after the instruction |insert_pos|. + // variable that is in the scope of |line| and whose memory is |variable_id| + // and inserts it after the instruction |insert_pos|. // Returns whether a DebugValue is added or not. - bool AddDebugValueForVariable(Instruction* scope_and_line, - uint32_t variable_id, uint32_t value_id, - Instruction* insert_pos); + bool AddDebugValueForVariable(Instruction* line, uint32_t variable_id, + uint32_t value_id, Instruction* insert_pos); // Creates a DebugValue for DebugDeclare |dbg_decl| and inserts it before - // |insert_before|. The new DebugValue has the same line and scope as - // |scope_and_line|, or no scope and line information if |scope_and_line| - // is nullptr. The new DebugValue has the same operands as DebugDeclare - // but it uses |value_id| for the value. Returns the created DebugValue, + // |insert_before|. The new DebugValue has the same line as |line} and the + // same scope as |dbg_decl|. The new DebugValue has the same operands as + // DebugDeclare but it uses |value_id| for the value. Returns the created + // DebugValue, // or nullptr if fails to create one. Instruction* AddDebugValueForDecl(Instruction* dbg_decl, uint32_t value_id, Instruction* insert_before, - Instruction* scope_and_line); + Instruction* line); // Erases |instr| from data structures of this class. void ClearDebugInfo(Instruction* instr); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/desc_sroa.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/desc_sroa.cpp index 124a3d3..b2f1268 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/desc_sroa.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/desc_sroa.cpp @@ -58,7 +58,7 @@ bool DescriptorScalarReplacement::ReplaceCandidate(Instruction* var) { std::vector access_chain_work_list; std::vector load_work_list; std::vector entry_point_work_list; - bool failed = !get_def_use_mgr()->WhileEachUser( + bool ok = get_def_use_mgr()->WhileEachUser( var->result_id(), [this, &access_chain_work_list, &load_work_list, &entry_point_work_list](Instruction* use) { if (use->opcode() == spv::Op::OpName) { @@ -88,7 +88,7 @@ bool DescriptorScalarReplacement::ReplaceCandidate(Instruction* var) { return true; }); - if (failed) { + if (!ok) { return false; } @@ -128,6 +128,9 @@ bool DescriptorScalarReplacement::ReplaceAccessChain(Instruction* var, uint32_t idx = const_index->GetU32(); uint32_t replacement_var = GetReplacementVariable(var, idx); + if (replacement_var == 0) { + return false; + } if (use->NumInOperands() == 2) { // We are not indexing into the replacement variable. We can replaces the @@ -186,8 +189,11 @@ bool DescriptorScalarReplacement::ReplaceEntryPoint(Instruction* var, uint32_t num_replacement_vars = descsroautil::GetNumberOfElementsForArrayOrStruct(context(), var); for (uint32_t i = 0; i < num_replacement_vars; i++) { - new_operands.push_back( - {SPV_OPERAND_TYPE_ID, {GetReplacementVariable(var, i)}}); + uint32_t replacement_var_id = GetReplacementVariable(var, i); + if (replacement_var_id == 0) { + return false; + } + new_operands.push_back({SPV_OPERAND_TYPE_ID, {replacement_var_id}}); } use->ReplaceOperands(new_operands); @@ -310,7 +316,10 @@ uint32_t DescriptorScalarReplacement::CreateReplacementVariable( element_type_id, storage_class); // Create the variable. - uint32_t id = TakeNextId(); + uint32_t id = context()->TakeNextId(); + if (id == 0) { + return 0; + } std::unique_ptr variable( new Instruction(context(), spv::Op::OpVariable, ptr_element_type_id, id, std::initializer_list{ @@ -444,10 +453,16 @@ bool DescriptorScalarReplacement::ReplaceCompositeExtract( uint32_t replacement_var = GetReplacementVariable(var, extract->GetSingleWordInOperand(1)); + if (replacement_var == 0) { + return false; + } // The result type of the OpLoad is the same as the result type of the // OpCompositeExtract. - uint32_t load_id = TakeNextId(); + uint32_t load_id = context()->TakeNextId(); + if (load_id == 0) { + return false; + } std::unique_ptr load( new Instruction(context(), spv::Op::OpLoad, extract->type_id(), load_id, std::initializer_list{ diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/feature_manager.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/feature_manager.cpp index 2810739..e4d152b 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/feature_manager.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/feature_manager.cpp @@ -34,10 +34,13 @@ void FeatureManager::AddExtensions(Module* module) { } void FeatureManager::AddExtension(Instruction* ext) { - assert(ext->opcode() == spv::Op::OpExtension && + assert((ext->opcode() == spv::Op::OpExtension || + ext->opcode() == spv::Op::OpConditionalExtensionINTEL) && "Expecting an extension instruction."); - const std::string name = ext->GetInOperand(0u).AsString(); + const uint32_t name_i = + ext->opcode() == spv::Op::OpConditionalExtensionINTEL ? 1u : 0u; + const std::string name = ext->GetInOperand(name_i).AsString(); Extension extension; if (GetExtensionFromString(name.c_str(), &extension)) { extensions_.insert(extension); @@ -72,7 +75,10 @@ void FeatureManager::RemoveCapability(spv::Capability cap) { void FeatureManager::AddCapabilities(Module* module) { for (Instruction& inst : module->capabilities()) { - AddCapability(static_cast(inst.GetSingleWordInOperand(0))); + const uint32_t i_cap = + inst.opcode() == spv::Op::OpConditionalCapabilityINTEL ? 1 : 0; + AddCapability( + static_cast(inst.GetSingleWordInOperand(i_cap))); } } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/fix_func_call_arguments.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/fix_func_call_arguments.cpp index f3486be..aa45c9f 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/fix_func_call_arguments.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/fix_func_call_arguments.cpp @@ -74,16 +74,19 @@ uint32_t FixFuncCallArgumentsPass::ReplaceAccessChainFuncCallArguments( op_type->result_id(), spv::StorageClass::Function); // Create new variable builder.SetInsertPoint(variable_insertion_point); + // TODO(1841): Handle id overflow. Instruction* var = builder.AddVariable(varType, uint32_t(spv::StorageClass::Function)); // Load access chain to the new variable before function call builder.SetInsertPoint(func_call_inst); uint32_t operand_id = operand_inst->result_id(); + // TODO(1841): Handle id overflow. Instruction* load = builder.AddLoad(op_type->result_id(), operand_id); builder.AddStore(var->result_id(), load->result_id()); // Load return value to the acesschain after function call builder.SetInsertPoint(next_insert_point); + // TODO(1841): Handle id overflow. load = builder.AddLoad(op_type->result_id(), var->result_id()); builder.AddStore(operand_id, load->result_id()); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/fold.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/fold.cpp index cd070c7..64c947f 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/fold.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/fold.cpp @@ -597,6 +597,9 @@ Instruction* InstructionFolder::FoldInstructionToConstant( const analysis::Constant* folded_const = nullptr; for (auto rule : GetConstantFoldingRules().GetRulesForInstruction(inst)) { folded_const = rule(context_, inst, constants); + if (folded_const == nullptr && inst->context()->id_overflow()) { + return nullptr; + } if (folded_const != nullptr) { Instruction* const_inst = const_mgr->GetDefiningInstruction(folded_const, inst->type_id()); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/fold_spec_constant_op_and_composite_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/fold_spec_constant_op_and_composite_pass.cpp index ddfe59f..edcf551 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/fold_spec_constant_op_and_composite_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/fold_spec_constant_op_and_composite_pass.cpp @@ -1,4 +1,5 @@ // Copyright (c) 2016 Google Inc. +// Copyright (c) 2025 Arm Ltd. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -31,21 +32,20 @@ Pass::Status FoldSpecConstantOpAndCompositePass::Process() { // instructions, records their values in two internal maps: id_to_const_val_ // and const_val_to_id_ so that we can use them to infer the value of Spec // Constants later. - // For Spec Constants defined with OpSpecConstantComposite instructions, if - // all of their components are Normal Constants, they will be turned into - // Normal Constants too. For Spec Constants defined with OpSpecConstantOp - // instructions, we check if they only depends on Normal Constants and fold - // them when possible. The two maps for Normal Constants: id_to_const_val_ - // and const_val_to_id_ will be updated along the traversal so that the new - // Normal Constants generated from folding can be used to fold following Spec - // Constants. - // This algorithm depends on the SSA property of SPIR-V when - // defining constants. The dependent constants must be defined before the - // dependee constants. So a dependent Spec Constant must be defined and - // will be processed before its dependee Spec Constant. When we encounter - // the dependee Spec Constants, all its dependent constants must have been - // processed and all its dependent Spec Constants should have been folded if - // possible. + // For Spec Constants defined with OpSpecConstantComposite or + // OpSpecConstantCompositeReplicateEXT instructions, if all of their + // components are Normal Constants, they will be turned into Normal Constants + // too. For Spec Constants defined with OpSpecConstantOp instructions, we + // check if they only depends on Normal Constants and fold them when possible. + // The two maps for Normal Constants: id_to_const_val_ and const_val_to_id_ + // will be updated along the traversal so that the new Normal Constants + // generated from folding can be used to fold following Spec Constants. This + // algorithm depends on the SSA property of SPIR-V when defining constants. + // The dependent constants must be defined before the dependee constants. So a + // dependent Spec Constant must be defined and will be processed before its + // dependee Spec Constant. When we encounter the dependee Spec Constants, all + // its dependent constants must have been processed and all its dependent Spec + // Constants should have been folded if possible. Module::inst_iterator next_inst = context()->types_values_begin(); for (Module::inst_iterator inst_iter = next_inst; // Need to re-evaluate the end iterator since we may modify the list of @@ -54,8 +54,9 @@ Pass::Status FoldSpecConstantOpAndCompositePass::Process() { ++next_inst; Instruction* inst = &*inst_iter; // Collect constant values of normal constants and process the - // OpSpecConstantOp and OpSpecConstantComposite instructions if possible. - // The constant values will be stored in analysis::Constant instances. + // OpSpecConstantOp, OpSpecConstantComposite, and + // OpSpecConstantCompositeReplicateEXT instructions if possible. The + // constant values will be stored in analysis::Constant instances. // OpConstantSampler instruction is not collected here because it cannot be // used in OpSpecConstant{Composite|Op} instructions. // TODO(qining): If the constant or its type has decoration, we may need @@ -70,21 +71,29 @@ Pass::Status FoldSpecConstantOpAndCompositePass::Process() { case spv::Op::OpConstant: case spv::Op::OpConstantNull: case spv::Op::OpConstantComposite: - case spv::Op::OpSpecConstantComposite: { + case spv::Op::OpSpecConstantComposite: + case spv::Op::OpSpecConstantCompositeReplicateEXT: { // A Constant instance will be created if the given instruction is a // Normal Constant whose value(s) are fixed. Note that for a composite - // Spec Constant defined with OpSpecConstantComposite instruction, if - // all of its components are Normal Constants already, the Spec - // Constant will be turned in to a Normal Constant. In that case, a - // Constant instance should also be created successfully and recorded - // in the id_to_const_val_ and const_val_to_id_ mapps. + // Spec Constant defined with OpSpecConstantComposite or + // OpSpecConstantCompositeReplicateEXT instruction, if all of its + // components are Normal Constants already, the Spec Constant will be + // turned in to a Normal Constant. In that case, a Constant instance + // should also be created successfully and recorded in the + // id_to_const_val_ and const_val_to_id_ mapps. if (auto const_value = const_mgr->GetConstantFromInst(inst)) { - // Need to replace the OpSpecConstantComposite instruction with a - // corresponding OpConstantComposite instruction. + // Need to replace the OpSpecConstantComposite or + // OpSpecConstantCompositeReplicateEXT instruction with a + // corresponding OpConstantComposite or + // OpConstantCompositeReplicateEXT instruction. if (opcode == spv::Op::OpSpecConstantComposite) { inst->SetOpcode(spv::Op::OpConstantComposite); modified = true; } + if (opcode == spv::Op::OpSpecConstantCompositeReplicateEXT) { + inst->SetOpcode(spv::Op::OpConstantCompositeReplicateEXT); + modified = true; + } const_mgr->MapConstantToInst(const_value, inst); } break; @@ -96,9 +105,16 @@ Pass::Status FoldSpecConstantOpAndCompositePass::Process() { // Constants will be added to id_to_const_val_ and const_val_to_id_ so // that we can use the new Normal Constants when folding following Spec // Constants. - case spv::Op::OpSpecConstantOp: - modified |= ProcessOpSpecConstantOp(&inst_iter); + case spv::Op::OpSpecConstantOp: { + const auto status = ProcessOpSpecConstantOp(&inst_iter); + if (status == Status::Failure) { + return Status::Failure; + } + if (status == Status::SuccessWithChange) { + modified = true; + } break; + } default: break; } @@ -106,7 +122,7 @@ Pass::Status FoldSpecConstantOpAndCompositePass::Process() { return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } -bool FoldSpecConstantOpAndCompositePass::ProcessOpSpecConstantOp( +Pass::Status FoldSpecConstantOpAndCompositePass::ProcessOpSpecConstantOp( Module::inst_iterator* pos) { Instruction* inst = &**pos; Instruction* folded_inst = nullptr; @@ -116,10 +132,17 @@ bool FoldSpecConstantOpAndCompositePass::ProcessOpSpecConstantOp( "SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER type"); folded_inst = FoldWithInstructionFolder(pos); + if (context()->id_overflow()) { + return Status::Failure; + } + if (!folded_inst) { folded_inst = DoComponentWiseOperation(pos); + if (context()->id_overflow()) { + return Status::Failure; + } } - if (!folded_inst) return false; + if (!folded_inst) return Status::SuccessWithoutChange; // Replace the original constant with the new folded constant, kill the // original constant. @@ -127,7 +150,7 @@ bool FoldSpecConstantOpAndCompositePass::ProcessOpSpecConstantOp( uint32_t old_id = inst->result_id(); context()->ReplaceAllUsesWith(old_id, new_id); context()->KillDef(old_id); - return true; + return Status::SuccessWithChange; } Instruction* FoldSpecConstantOpAndCompositePass::FoldWithInstructionFolder( @@ -186,7 +209,11 @@ Instruction* FoldSpecConstantOpAndCompositePass::FoldWithInstructionFolder( if (need_to_clone) { new_const_inst = new_const_inst->Clone(context()); - new_const_inst->SetResultId(TakeNextId()); + uint32_t new_id = TakeNextId(); + if (new_id == 0) { + return nullptr; + } + new_const_inst->SetResultId(new_id); new_const_inst->InsertAfter(insert_pos); get_def_use_mgr()->AnalyzeInstDefUse(new_const_inst); } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/fold_spec_constant_op_and_composite_pass.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/fold_spec_constant_op_and_composite_pass.h index 9a8fb40..d48809c 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/fold_spec_constant_op_and_composite_pass.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/fold_spec_constant_op_and_composite_pass.h @@ -19,6 +19,7 @@ #include #include +#include "source/diagnostic.h" #include "source/opt/constants.h" #include "source/opt/def_use_manager.h" #include "source/opt/ir_context.h" @@ -45,14 +46,14 @@ class FoldSpecConstantOpAndCompositePass : public Pass { private: // Processes the OpSpecConstantOp instruction pointed by the given // instruction iterator, folds it to normal constants if possible. Returns - // true if the spec constant is folded to normal constants. New instructions - // will be inserted before the OpSpecConstantOp instruction pointed by the - // instruction iterator. The instruction iterator, which is passed by - // pointer, will still point to the original OpSpecConstantOp instruction. If - // folding is done successfully, the original OpSpecConstantOp instruction - // will be changed to Nop and new folded instruction will be inserted before - // it. - bool ProcessOpSpecConstantOp(Module::inst_iterator* pos); + // kSuccess if the spec constant is folded to normal constants. New + // instructions will be inserted before the OpSpecConstantOp instruction + // pointed by the instruction iterator. The instruction iterator, which is + // passed by pointer, will still point to the original OpSpecConstantOp + // instruction. If folding is done successfully, the original OpSpecConstantOp + // instruction will be changed to Nop and new folded instruction will be + // inserted before it. Returns kFail if an id overflow occurs. + Status ProcessOpSpecConstantOp(Module::inst_iterator* pos); // Returns the result of folding the OpSpecConstantOp instruction // |inst_iter_ptr| using the instruction folder. @@ -62,7 +63,24 @@ class FoldSpecConstantOpAndCompositePass : public Pass { // pointed by the given instruction iterator to a normal constant defining // instruction. Returns the pointer to the new constant defining instruction // if succeeded, otherwise return nullptr. + // instruction if succeeded, otherwise return nullptr. Instruction* DoComponentWiseOperation(Module::inst_iterator* inst_iter_ptr); + + // Returns the next available id, or 0 if the id overflows. + uint32_t TakeNextId() { + uint32_t next_id = context()->TakeNextId(); + if (next_id == 0) { + Fail() << "ID overflow. Try running compact-ids."; + } + return next_id; + } + + // Records failure for the current module and returns a stream for printing + // diagnostics. + spvtools::DiagnosticStream Fail() { + return spvtools::DiagnosticStream({}, context()->consumer(), "", + SPV_ERROR_INTERNAL); + } }; } // namespace opt diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/folding_rules.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/folding_rules.cpp index 3f5f79a..ee2f24e 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/folding_rules.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/folding_rules.cpp @@ -176,12 +176,57 @@ std::vector GetWordsFromNumericScalarOrVectorConstant( return GetWordsFromScalarIntConstant(int_constant); } else if (const auto* vec_constant = c->AsVectorConstant()) { std::vector words; + // Retrieve all the components as 32bit words. for (const auto* comp : vec_constant->GetComponents()) { auto comp_in_words = GetWordsFromNumericScalarOrVectorConstant(const_mgr, comp); words.insert(words.end(), comp_in_words.begin(), comp_in_words.end()); } - return words; + + if (ElementWidth(c->type()) >= 32) { + return words; + } + // Check the element width and concactenate if the width is less than 32. + if (ElementWidth(c->type()) == 8) { + assert(words.size() <= 4); + // Each 32-bit word will comprise 4 8-bit integers. + // reverse the order when compacting. + uint32_t compacted_word = 0; + for (int32_t i = static_cast(words.size()) - 1; i >= 0; --i) { + compacted_word <<= 8; + compacted_word |= words[i]; + } + return {compacted_word}; + } else if (ElementWidth(c->type()) == 16) { + assert(words.size() <= 4); + std::vector compacted_words; + // Each 32-bit word will comprise 2 16-bit integers. + // reverse the order pair-wise when compacting. + for (uint32_t i = 0; i < words.size(); i += 2) { + uint32_t word1 = words[i]; + uint32_t word2 = (i + 1 < words.size()) ? words[i + 1] : 0; + uint32_t compacted_word = (word2 << 16) | word1; + compacted_words.push_back(compacted_word); + } + return compacted_words; + } + assert(false && "Unhandled element width"); + } else if (c->AsNullConstant()) { + uint32_t num_elements = 1; + + if (const auto* vec_type = c->type()->AsVector()) { + num_elements = vec_type->element_count(); + } + + // We need to check the element width to determine how many 32-bit words are + // needed. + uint32_t element_width = ElementWidth(c->type()); + if (element_width < 32) { + num_elements = (num_elements + 1) / 2; + } else if (element_width == 64) { + num_elements = num_elements * 2; + } + return std::vector(num_elements, 0); } return {}; } @@ -634,6 +679,15 @@ uint32_t PerformIntegerOperation(analysis::ConstantManager* const_mgr, case spv::Op::OpISub: FOLD_OP(-); break; + case spv::Op::OpBitwiseXor: + FOLD_OP(^); + break; + case spv::Op::OpBitwiseOr: + FOLD_OP(|); + break; + case spv::Op::OpBitwiseAnd: + FOLD_OP(&); + break; default: assert(false && "Unexpected operation"); break; @@ -1488,6 +1542,9 @@ bool FactorAddMulsOpnds(uint32_t factor0_0, uint32_t factor0_1, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* new_add_inst = ir_builder.AddBinaryOp( inst->type_id(), inst->opcode(), factor0_1, factor1_1); + if (!new_add_inst) { + return false; + } inst->SetOpcode(inst->opcode() == spv::Op::OpFAdd ? spv::Op::OpFMul : spv::Op::OpIMul); inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {factor0_0}}, @@ -1998,6 +2055,15 @@ FoldingRule FMixFeedingExtract() { bool use_x = false; assert(a_const->type()->AsFloat()); + + const analysis::Type* type = + context->get_type_mgr()->GetType(inst->type_id()); + uint32_t width = ElementWidth(type); + if (width != 32 && width != 64) { + // We won't support folding half float values. + return false; + } + double element_value = a_const->GetValueAsDouble(); if (element_value == 0.0) { use_x = true; @@ -2230,6 +2296,48 @@ FoldingRule BitCastScalarOrVector() { }; } +FoldingRule BitReverseScalarOrVector() { + return [](IRContext* context, Instruction* inst, + const std::vector& constants) { + assert(inst->opcode() == spv::Op::OpBitReverse && constants.size() == 1); + if (constants[0] == nullptr) return false; + + const analysis::Type* type = + context->get_type_mgr()->GetType(inst->type_id()); + assert(!HasFloatingPoint(type) && + "BitReverse cannot be applied to floating point types."); + assert((type->AsInteger() || type->AsVector()) && + "BitReverse can only be applied to integer scalars or vectors."); + assert((ElementWidth(type) == 32) && + "BitReverse can only be applied to integer types of width 32"); + + analysis::ConstantManager* const_mgr = context->get_constant_mgr(); + std::vector words = + GetWordsFromNumericScalarOrVectorConstant(const_mgr, constants[0]); + if (words.size() == 0) return false; + + for (uint32_t& word : words) { + // Reverse the bits in each word. + word = ((word & 0x55555555) << 1) | ((word >> 1) & 0x55555555); + word = ((word & 0x33333333) << 2) | ((word >> 2) & 0x33333333); + word = ((word & 0x0F0F0F0F) << 4) | ((word >> 4) & 0x0F0F0F0F); + word = ((word & 0x00FF00FF) << 8) | ((word >> 8) & 0x00FF00FF); + word = (word << 16) | (word >> 16); + } + + const analysis::Constant* bitreversed_constant = + ConvertWordsToNumericScalarOrVectorConstant(const_mgr, words, type); + if (!bitreversed_constant) return false; + + auto new_feeder_id = + const_mgr->GetDefiningInstruction(bitreversed_constant, inst->type_id()) + ->result_id(); + inst->SetOpcode(spv::Op::OpCopyObject); + inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {new_feeder_id}}}); + return true; + }; +} + FoldingRule RedundantSelect() { // An OpSelect instruction where both values are the same or the condition is // constant can be replaced by one of the values @@ -2601,6 +2709,56 @@ FoldingRule RedundantBinaryLhs0To0(spv::Op op) { return RedundantBinaryOpWithZeroOperand(0, 0); } +FoldingRule ReassociateCommutiveOp() { + return [](IRContext* context, Instruction* inst, + const std::vector& constants) { + const analysis::Type* type = + context->get_type_mgr()->GetType(inst->type_id()); + uint32_t width = ElementWidth(type); + if (width != 32) return false; + + analysis::ConstantManager* const_mgr = context->get_constant_mgr(); + const analysis::Constant* const_input1 = ConstInput(constants); + if (!const_input1) return false; + Instruction* other_inst = NonConstInput(context, constants[0], inst); + + if (other_inst->opcode() == inst->opcode()) { + std::vector other_constants = + const_mgr->GetOperandConstants(other_inst); + const analysis::Constant* const_input2 = ConstInput(other_constants); + if (!const_input2) return false; + + Instruction* non_const_input = + NonConstInput(context, other_constants[0], other_inst); + uint32_t merged_id = PerformOperation(const_mgr, inst->opcode(), + const_input1, const_input2); + + if (merged_id == 0) return false; + inst->SetInOperands( + {{SPV_OPERAND_TYPE_ID, {non_const_input->result_id()}}, + {SPV_OPERAND_TYPE_ID, {merged_id}}}); + return true; + } + + return false; + }; +} + +// A | (b | C) = b | (A | C) +// A ^ (b ^ C) = b ^ (A ^ C) +// A & (b & C) = b & (A & C) +// Where A and C are constants +static const constexpr spv::Op ReassociateCommutiveBitwiseOps[] = { + spv::Op::OpBitwiseOr, spv::Op::OpBitwiseXor, spv::Op::OpBitwiseAnd}; +FoldingRule ReassociateCommutiveBitwise(spv::Op op) { + assert(std::find(std::begin(ReassociateCommutiveBitwiseOps), + std::end(ReassociateCommutiveBitwiseOps), + op) != std::end(ReassociateCommutiveBitwiseOps) && + "Wrong opcode."); + (void)op; + return ReassociateCommutiveOp(); +} + // Returns true if all elements in |c| are 1. bool IsAllInt1(const analysis::Constant* c) { if (auto composite = c->AsCompositeConstant()) { @@ -3004,12 +3162,15 @@ void FoldingRules::AddFoldingRules() { rules_[op].push_back(RedundantBinaryLhs0(op)); for (auto op : RedundantBinaryLhs0To0Ops) rules_[op].push_back(RedundantBinaryLhs0To0(op)); + for (auto op : ReassociateCommutiveBitwiseOps) + rules_[op].push_back(ReassociateCommutiveBitwise(op)); rules_[spv::Op::OpSDiv].push_back(RedundantSUDiv()); rules_[spv::Op::OpUDiv].push_back(RedundantSUDiv()); rules_[spv::Op::OpSMod].push_back(RedundantSUMod()); rules_[spv::Op::OpUMod].push_back(RedundantSUMod()); rules_[spv::Op::OpBitcast].push_back(BitCastScalarOrVector()); + rules_[spv::Op::OpBitReverse].push_back(BitReverseScalarOrVector()); rules_[spv::Op::OpCompositeConstruct].push_back( CompositeExtractFeedingConstruct); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/function.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/function.cpp index 2ee88ec..560953b 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/function.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/function.cpp @@ -40,6 +40,10 @@ Function* Function::Clone(IRContext* ctx) const { clone->blocks_.reserve(blocks_.size()); for (const auto& b : blocks_) { std::unique_ptr bb(b->Clone(ctx)); + if (!bb) { + delete clone; + return nullptr; + } clone->AddBasicBlock(std::move(bb)); } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/function.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/function.h index 45a0b23..39ecd59 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/function.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/function.h @@ -48,7 +48,7 @@ class Function { explicit Function(const Function& f) = delete; - // Creates a clone of the instruction in the given |context| + // Creates a clone of the function in the given |context| // // The parent module will default to null and needs to be explicitly set by // the user. diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/graph.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/graph.cpp new file mode 100644 index 0000000..ba1030d --- /dev/null +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/graph.cpp @@ -0,0 +1,90 @@ +// Copyright (c) 2022-2025 Arm Ltd. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "source/opt/graph.h" + +namespace spvtools { +namespace opt { + +Graph* Graph::Clone(IRContext* ctx) const { + Graph* clone = new Graph(std::unique_ptr(DefInst().Clone(ctx))); + + clone->inputs_.reserve(inputs_.size()); + for (const auto& i : inputs()) { + clone->AddInput(std::unique_ptr(i->Clone(ctx))); + } + + clone->insts_.reserve(insts_.size()); + for (const auto& i : instructions()) { + clone->AddInstruction(std::unique_ptr(i->Clone(ctx))); + } + + clone->outputs_.reserve(outputs_.size()); + for (const auto& i : outputs()) { + clone->AddOutput(std::unique_ptr(i->Clone(ctx))); + } + + clone->SetGraphEnd(std::unique_ptr(EndInst()->Clone(ctx))); + + return clone; +} + +void Graph::ForEachInst(const std::function& f, + bool run_on_debug_line_insts, + bool run_on_non_semantic_insts) { + (void)run_on_debug_line_insts; + (void)run_on_non_semantic_insts; + + f(def_inst_.get()); + + for (auto& inst : inputs_) { + f(inst.get()); + } + + for (auto& inst : insts_) { + f(inst.get()); + } + + for (auto& inst : outputs_) { + f(inst.get()); + } + + f(end_inst_.get()); +} + +void Graph::ForEachInst(const std::function& f, + bool run_on_debug_line_insts, + bool run_on_non_semantic_insts) const { + (void)run_on_debug_line_insts; + (void)run_on_non_semantic_insts; + + f(def_inst_.get()); + + for (auto& inst : inputs_) { + f(inst.get()); + } + + for (auto& inst : insts_) { + f(inst.get()); + } + + for (auto& inst : outputs_) { + f(inst.get()); + } + + f(end_inst_.get()); +} + +} // namespace opt +} // namespace spvtools diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/graph.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/graph.h new file mode 100644 index 0000000..3b533b2 --- /dev/null +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/graph.h @@ -0,0 +1,124 @@ +// Copyright (c) 2022-2025 Arm Ltd. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef SOURCE_OPT_GRAPH_H_ +#define SOURCE_OPT_GRAPH_H_ + +#include "source/opt/instruction.h" + +namespace spvtools { +namespace opt { + +struct Graph { + // Creates a graph instance declared by the given OpGraph instruction + // |def_inst|. + inline explicit Graph(std::unique_ptr def_inst); + explicit Graph(const Graph& f) = delete; + + // Creates a clone of the graph in the given |context| + // + // The parent module will default to null and needs to be explicitly set by + // the user. + Graph* Clone(IRContext*) const; + + // The OpGraph instruction that begins the definition of this graph. + Instruction& DefInst() { return *def_inst_; } + const Instruction& DefInst() const { return *def_inst_; } + + // Appends an input to this graph. + inline void AddInput(std::unique_ptr inst); + + // Appends an instruction to this graph. + inline void AddInstruction(std::unique_ptr inst); + + // Appends an output to this graph. + inline void AddOutput(std::unique_ptr inst); + + // Saves the given graph end instruction. + void SetGraphEnd(std::unique_ptr end_inst); + + // Returns the given graph end instruction. + inline Instruction* EndInst() { return end_inst_.get(); } + inline const Instruction* EndInst() const { return end_inst_.get(); } + + // Returns graph's id + inline uint32_t result_id() const { return def_inst_->result_id(); } + + // Returns graph's return type id + inline uint32_t type_id() const { return def_inst_->type_id(); } + + // Return a read-only reference to the instructions that define the body of + // the graph. + const std::vector>& instructions() const { + return insts_; + } + + // Return a read-only reference to the instructions that define the inputs + // of the graph. + const std::vector>& inputs() const { + return inputs_; + } + + // Return a read-only reference to the instructions that define the outputs + // of the graph. + const std::vector>& outputs() const { + return outputs_; + } + + // Runs the given function |f| on instructions in this graph, in order, + // and optionally on debug line instructions that might precede them and + // non-semantic instructions that succceed the function. + void ForEachInst(const std::function& f, + bool run_on_debug_line_insts = false, + bool run_on_non_semantic_insts = false); + void ForEachInst(const std::function& f, + bool run_on_debug_line_insts = false, + bool run_on_non_semantic_insts = false) const; + + private: + // The OpGraph instruction that begins the definition of this graph. + std::unique_ptr def_inst_; + // All inputs to this graph. + std::vector> inputs_; + // All instructions describing this graph + std::vector> insts_; + // All outputs of this graph. + std::vector> outputs_; + // The OpGraphEnd instruction. + std::unique_ptr end_inst_; +}; + +inline Graph::Graph(std::unique_ptr def_inst) + : def_inst_(std::move(def_inst)) {} + +inline void Graph::AddInput(std::unique_ptr inst) { + inputs_.emplace_back(std::move(inst)); +} + +inline void Graph::AddInstruction(std::unique_ptr inst) { + insts_.emplace_back(std::move(inst)); +} + +inline void Graph::AddOutput(std::unique_ptr inst) { + outputs_.emplace_back(std::move(inst)); +} + +inline void Graph::SetGraphEnd(std::unique_ptr end_inst) { + end_inst_ = std::move(end_inst); +} + +} // namespace opt +} // namespace spvtools + +#endif // SOURCE_OPT_GRAPH_H_ diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/graphics_robust_access_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/graphics_robust_access_pass.cpp index e765c39..15076ec 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/graphics_robust_access_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/graphics_robust_access_pass.cpp @@ -283,9 +283,14 @@ void GraphicsRobustAccessPass::ClampIndicesForAccessChain( // use 0 for %min_value). auto clamp_index = [&inst, type_mgr, this, &replace_index]( uint32_t operand_index, Instruction* old_value, - Instruction* min_value, Instruction* max_value) { + Instruction* min_value, + Instruction* max_value) -> spv_result_t { auto* clamp_inst = MakeSClampInst(*type_mgr, old_value, min_value, max_value, &inst); + if (clamp_inst == nullptr) { + Fail(); + return SPV_ERROR_INTERNAL; + } return replace_index(operand_index, clamp_inst); }; @@ -304,7 +309,11 @@ void GraphicsRobustAccessPass::ClampIndicesForAccessChain( if (count <= 1) { // Replace the index with 0. - return replace_index(operand_index, GetValueForType(0, index_type)); + Instruction* new_value = GetValueForType(0, index_type); + if (new_value == nullptr) { + return Fail(); + } + return replace_index(operand_index, new_value); } uint64_t maxval = count - 1; @@ -318,8 +327,15 @@ void GraphicsRobustAccessPass::ClampIndicesForAccessChain( // Determine the type for |maxval|. uint32_t next_id = context()->module()->IdBound(); analysis::Integer signed_type_for_query(maxval_width, true); - auto* maxval_type = - type_mgr->GetRegisteredType(&signed_type_for_query)->AsInteger(); + auto* maxval_type_registered = + type_mgr->GetRegisteredType(&signed_type_for_query); + if (maxval_type_registered == nullptr) { + return Fail(); + } + auto* maxval_type = maxval_type_registered->AsInteger(); + if (maxval_type == nullptr) { + return Fail(); + } if (next_id != context()->module()->IdBound()) { module_status_.modified = true; } @@ -352,15 +368,22 @@ void GraphicsRobustAccessPass::ClampIndicesForAccessChain( value = int_index_constant->GetS64BitValue(); } if (value < 0) { - return replace_index(operand_index, GetValueForType(0, index_type)); + Instruction* new_value = GetValueForType(0, index_type); + if (new_value == nullptr) { + return Fail(); + } + return replace_index(operand_index, new_value); } else if (uint64_t(value) <= maxval) { // Nothing to do. return SPV_SUCCESS; } else { // Replace with maxval. assert(count > 0); // Already took care of this case above. - return replace_index(operand_index, - GetValueForType(maxval, maxval_type)); + Instruction* new_value = GetValueForType(maxval, maxval_type); + if (new_value == nullptr) { + return Fail(); + } + return replace_index(operand_index, new_value); } } else { // Generate a clamp instruction. @@ -389,6 +412,9 @@ void GraphicsRobustAccessPass::ClampIndicesForAccessChain( } index_inst = WidenInteger(index_type->IsSigned(), maxval_width, index_inst, &inst); + if (index_inst == nullptr) { + return Fail(); + } } // Finally, clamp the index. @@ -438,28 +464,51 @@ void GraphicsRobustAccessPass::ClampIndicesForAccessChain( if (index_type->width() < target_width) { // Access chain indices are treated as signed integers. index_inst = WidenInteger(true, target_width, index_inst, &inst); + if (index_inst == nullptr) { + return Fail(); + } } else if (count_type->width() < target_width) { // Assume type sizes are treated as unsigned. count_inst = WidenInteger(false, target_width, count_inst, &inst); + if (count_inst == nullptr) { + return Fail(); + } } // Compute count - 1. // It doesn't matter if 1 is signed or unsigned. auto* one = GetValueForType(1, wider_type); - auto* count_minus_1 = InsertInst( - &inst, spv::Op::OpISub, type_mgr->GetId(wider_type), TakeNextId(), - {{SPV_OPERAND_TYPE_ID, {count_inst->result_id()}}, - {SPV_OPERAND_TYPE_ID, {one->result_id()}}}); + if (!one) { + return Fail(); + } + auto* count_minus_1 = + InsertInst(&inst, spv::Op::OpISub, type_mgr->GetId(wider_type), + context()->TakeNextId(), + {{SPV_OPERAND_TYPE_ID, {count_inst->result_id()}}, + {SPV_OPERAND_TYPE_ID, {one->result_id()}}}); + if (count_minus_1 == nullptr) { + return Fail(); + } auto* zero = GetValueForType(0, wider_type); + if (!zero) { + return Fail(); + } // Make sure we clamp to an upper bound that is at most the signed max // for the target type. const uint64_t max_signed_value = ((uint64_t(1) << (target_width - 1)) - 1); + Instruction* max_signed_inst = + GetValueForType(max_signed_value, wider_type); + if (!max_signed_inst) { + return Fail(); + } // Use unsigned-min to ensure that the result is always non-negative. // That ensures we satisfy the invariant for SClamp, where the "min" // argument we give it (zero), is no larger than the third argument. auto* upper_bound = - MakeUMinInst(*type_mgr, count_minus_1, - GetValueForType(max_signed_value, wider_type), &inst); + MakeUMinInst(*type_mgr, count_minus_1, max_signed_inst, &inst); + if (upper_bound == nullptr) { + return Fail(); + } // Now clamp the index to this upper bound. return clamp_index(operand_index, index_inst, zero, upper_bound); } @@ -485,7 +534,7 @@ void GraphicsRobustAccessPass::ClampIndicesForAccessChain( case spv::Op::OpTypeVector: // Use component count { const uint32_t count = pointee_type->GetSingleWordOperand(2); - clamp_to_literal_count(idx, count); + if (clamp_to_literal_count(idx, count) != SPV_SUCCESS) return; pointee_type = GetDef(pointee_type->GetSingleWordOperand(1)); } break; @@ -493,7 +542,7 @@ void GraphicsRobustAccessPass::ClampIndicesForAccessChain( // The array length can be a spec constant, so go through the general // case. Instruction* array_len = GetDef(pointee_type->GetSingleWordOperand(2)); - clamp_to_count(idx, array_len); + if (clamp_to_count(idx, array_len) != SPV_SUCCESS) return; pointee_type = GetDef(pointee_type->GetSingleWordOperand(1)); } break; @@ -537,7 +586,7 @@ void GraphicsRobustAccessPass::ClampIndicesForAccessChain( if (!array_len) { // We've already signaled an error. return; } - clamp_to_count(idx, array_len); + if (clamp_to_count(idx, array_len) != SPV_SUCCESS) return; if (module_status_.failed) return; pointee_type = GetDef(pointee_type->GetSingleWordOperand(1)); } break; @@ -563,7 +612,10 @@ uint32_t GraphicsRobustAccessPass::GetGlslInsts() { } if (module_status_.glsl_insts_id == 0) { // Make a new import instruction. - module_status_.glsl_insts_id = TakeNextId(); + module_status_.glsl_insts_id = context()->TakeNextId(); + if (module_status_.glsl_insts_id == 0) { + return 0; + } std::vector words = spvtools::utils::MakeVector(glsl); auto import_inst = MakeUnique( context(), spv::Op::OpExtInstImport, 0, module_status_.glsl_insts_id, @@ -602,7 +654,10 @@ opt::Instruction* opt::GraphicsRobustAccessPass::WidenInteger( auto* type_mgr = context()->get_type_mgr(); auto* unsigned_type = type_mgr->GetRegisteredType(&unsigned_type_for_query); auto type_id = context()->get_type_mgr()->GetId(unsigned_type); - auto conversion_id = TakeNextId(); + auto conversion_id = context()->TakeNextId(); + if (conversion_id == 0) { + return nullptr; + } auto* conversion = InsertInst( before_inst, (sign_extend ? spv::Op::OpSConvert : spv::Op::OpUConvert), type_id, conversion_id, {{SPV_OPERAND_TYPE_ID, {value->result_id()}}}); @@ -616,7 +671,13 @@ Instruction* GraphicsRobustAccessPass::MakeUMinInst( // the function so we force a deterministic ordering in case both of them need // to take a new ID. const uint32_t glsl_insts_id = GetGlslInsts(); - uint32_t smin_id = TakeNextId(); + if (glsl_insts_id == 0) { + return nullptr; + } + uint32_t smin_id = context()->TakeNextId(); + if (smin_id == 0) { + return nullptr; + } const auto xwidth = tm.GetType(x->type_id())->AsInteger()->width(); const auto ywidth = tm.GetType(y->type_id())->AsInteger()->width(); assert(xwidth == ywidth); @@ -640,7 +701,13 @@ Instruction* GraphicsRobustAccessPass::MakeSClampInst( // the function so we force a deterministic ordering in case both of them need // to take a new ID. const uint32_t glsl_insts_id = GetGlslInsts(); - uint32_t clamp_id = TakeNextId(); + if (glsl_insts_id == 0) { + return nullptr; + } + uint32_t clamp_id = context()->TakeNextId(); + if (clamp_id == 0) { + return nullptr; + } const auto xwidth = tm.GetType(x->type_id())->AsInteger()->width(); const auto minwidth = tm.GetType(min->type_id())->AsInteger()->width(); const auto maxwidth = tm.GetType(max->type_id())->AsInteger()->width(); @@ -755,7 +822,11 @@ Instruction* GraphicsRobustAccessPass::MakeRuntimeArrayLengthInst( base_ptr_type->storage_class()); // Create the instruction and insert it. - const auto new_access_chain_id = TakeNextId(); + const auto new_access_chain_id = context()->TakeNextId(); + if (new_access_chain_id == 0) { + Fail(); + return nullptr; + } auto* new_access_chain = InsertInst(current_access_chain, current_access_chain->opcode(), new_access_chain_type_id, new_access_chain_id, ops); @@ -784,7 +855,11 @@ Instruction* GraphicsRobustAccessPass::MakeRuntimeArrayLengthInst( uint32_t(struct_type->element_types().size() - 1); // Create the length-of-array instruction before the original access chain, // but after the generation of the pointer to the struct. - const auto array_len_id = TakeNextId(); + const auto array_len_id = context()->TakeNextId(); + if (array_len_id == 0) { + Fail(); + return nullptr; + } analysis::Integer uint_type_for_query(32, false); auto* uint_type = type_mgr->GetRegisteredType(&uint_type_for_query); auto* array_len = InsertInst( @@ -935,12 +1010,18 @@ spv_result_t GraphicsRobustAccessPass::ClampCoordinateForImageTexelPointer( return type_mgr->GetRegisteredType(&proposed); }(); - const uint32_t image_id = TakeNextId(); + const uint32_t image_id = context()->TakeNextId(); + if (image_id == 0) { + return Fail(); + } auto* image = InsertInst(image_texel_pointer, spv::Op::OpLoad, image_type_id, image_id, {{SPV_OPERAND_TYPE_ID, {image_ptr->result_id()}}}); - const uint32_t query_size_id = TakeNextId(); + const uint32_t query_size_id = context()->TakeNextId(); + if (query_size_id == 0) { + return Fail(); + } auto* query_size = InsertInst(image_texel_pointer, spv::Op::OpImageQuerySize, type_mgr->GetTypeInstruction(query_size_type), query_size_id, @@ -968,7 +1049,10 @@ spv_result_t GraphicsRobustAccessPass::ClampCoordinateForImageTexelPointer( query_size_type, {component_1_id, component_1_id, component_6_id}); auto* multiplicand_inst = constant_mgr->GetDefiningInstruction(multiplicand); - const auto query_size_including_faces_id = TakeNextId(); + const auto query_size_including_faces_id = context()->TakeNextId(); + if (query_size_including_faces_id == 0) { + return Fail(); + } query_size_including_faces = InsertInst( image_texel_pointer, spv::Op::OpIMul, type_mgr->GetTypeInstruction(query_size_type), @@ -992,7 +1076,10 @@ spv_result_t GraphicsRobustAccessPass::ClampCoordinateForImageTexelPointer( query_size_type, std::vector(query_num_components, component_0_id)); - const uint32_t query_max_including_faces_id = TakeNextId(); + const uint32_t query_max_including_faces_id = context()->TakeNextId(); + if (query_max_including_faces_id == 0) { + return Fail(); + } auto* query_max_including_faces = InsertInst( image_texel_pointer, spv::Op::OpISub, type_mgr->GetTypeInstruction(query_size_type), @@ -1005,18 +1092,27 @@ spv_result_t GraphicsRobustAccessPass::ClampCoordinateForImageTexelPointer( auto* clamp_coord = MakeSClampInst( *type_mgr, coord, constant_mgr->GetDefiningInstruction(coordinate_0), query_max_including_faces, image_texel_pointer); + if (clamp_coord == nullptr) { + return Fail(); + } image_texel_pointer->SetInOperand(1, {clamp_coord->result_id()}); // Clamp the sample index if (multisampled) { // Get the sample count via OpImageQuerySamples - const auto query_samples_id = TakeNextId(); + const auto query_samples_id = context()->TakeNextId(); + if (query_samples_id == 0) { + return Fail(); + } auto* query_samples = InsertInst( image_texel_pointer, spv::Op::OpImageQuerySamples, constant_mgr->GetDefiningInstruction(component_0)->type_id(), query_samples_id, {{SPV_OPERAND_TYPE_ID, {image->result_id()}}}); - const auto max_samples_id = TakeNextId(); + const auto max_samples_id = context()->TakeNextId(); + if (max_samples_id == 0) { + return Fail(); + } auto* max_samples = InsertInst(image_texel_pointer, spv::Op::OpImageQuerySamples, query_samples->type_id(), max_samples_id, {{SPV_OPERAND_TYPE_ID, {query_samples_id}}, @@ -1025,6 +1121,9 @@ spv_result_t GraphicsRobustAccessPass::ClampCoordinateForImageTexelPointer( auto* clamp_samples = MakeSClampInst( *type_mgr, samples, constant_mgr->GetDefiningInstruction(coordinate_0), max_samples, image_texel_pointer); + if (clamp_samples == nullptr) { + return Fail(); + } image_texel_pointer->SetInOperand(2, {clamp_samples->result_id()}); } else { @@ -1041,6 +1140,9 @@ spv_result_t GraphicsRobustAccessPass::ClampCoordinateForImageTexelPointer( opt::Instruction* GraphicsRobustAccessPass::InsertInst( opt::Instruction* where_inst, spv::Op opcode, uint32_t type_id, uint32_t result_id, const Instruction::OperandList& operands) { + if (result_id == 0) { + return nullptr; + } module_status_.modified = true; auto* result = where_inst->InsertBefore( MakeUnique(context(), opcode, type_id, result_id, operands)); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/if_conversion.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/if_conversion.cpp index 5912cf1..2b71626 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/if_conversion.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/if_conversion.cpp @@ -126,6 +126,7 @@ Pass::Status IfConversion::Process() { condition = SplatCondition(vec_data_ty, condition, &builder); } + // TODO(1841): Handle id overflow. Instruction* select = builder.AddSelect(phi->type_id(), condition, true_value->result_id(), false_value->result_id()); @@ -205,6 +206,7 @@ uint32_t IfConversion::SplatCondition(analysis::Vector* vec_data_ty, uint32_t bool_vec_id = context()->get_type_mgr()->GetTypeInstruction(&bool_vec_ty); std::vector ids(vec_data_ty->element_count(), cond); + // TODO(1841): Handle id overflow. return builder->AddCompositeConstruct(bool_vec_id, ids)->result_id(); } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/instruction.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/instruction.cpp index 883e47f..05cf18f 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/instruction.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/instruction.cpp @@ -168,7 +168,13 @@ Instruction* Instruction::Clone(IRContext* c) const { clone->dbg_line_insts_ = dbg_line_insts_; for (auto& i : clone->dbg_line_insts_) { i.unique_id_ = c->TakeNextUniqueId(); - if (i.IsDebugLineInst()) i.SetResultId(c->TakeNextId()); + if (i.IsDebugLineInst()) { + uint32_t new_id = c->TakeNextId(); + if (new_id == 0) { + return nullptr; + } + i.SetResultId(new_id); + } } clone->dbg_scope_ = dbg_scope_; return clone; @@ -546,25 +552,37 @@ void Instruction::ClearDbgLineInsts() { clear_dbg_line_insts(); } -void Instruction::UpdateDebugInfoFrom(const Instruction* from) { - if (from == nullptr) return; +bool Instruction::UpdateDebugInfoFrom(const Instruction* from, + const Instruction* line) { + if (from == nullptr) return true; ClearDbgLineInsts(); - if (!from->dbg_line_insts().empty()) - AddDebugLine(&from->dbg_line_insts().back()); + const Instruction* fromLine = line != nullptr ? line : from; + if (!fromLine->dbg_line_insts().empty()) { + if (!AddDebugLine(&fromLine->dbg_line_insts().back())) { + return false; + } + } SetDebugScope(from->GetDebugScope()); if (!IsLineInst() && context()->AreAnalysesValid(IRContext::kAnalysisDebugInfo)) { context()->get_debug_info_mgr()->AnalyzeDebugInst(this); } + return true; } -void Instruction::AddDebugLine(const Instruction* inst) { +bool Instruction::AddDebugLine(const Instruction* inst) { dbg_line_insts_.push_back(*inst); dbg_line_insts_.back().unique_id_ = context()->TakeNextUniqueId(); - if (inst->IsDebugLineInst()) - dbg_line_insts_.back().SetResultId(context_->TakeNextId()); + if (inst->IsDebugLineInst()) { + uint32_t new_id = context()->TakeNextId(); + if (new_id == 0) { + return false; + } + dbg_line_insts_.back().SetResultId(new_id); + } if (context()->AreAnalysesValid(IRContext::kAnalysisDefUse)) context()->get_def_use_mgr()->AnalyzeInstDefUse(&dbg_line_insts_.back()); + return true; } bool Instruction::IsDebugLineInst() const { @@ -768,7 +786,7 @@ bool Instruction::IsFoldableByFoldScalar() const { // Even if the type of the instruction is foldable, its operands may not be // foldable (e.g., comparisons of 64bit types). Check that all operand types // are foldable before accepting the instruction. - return WhileEachInOperand([&folder, this](const uint32_t* op_id) { + return WhileEachInId([&folder, this](const uint32_t* op_id) { Instruction* def_inst = context()->get_def_use_mgr()->GetDef(*op_id); Instruction* def_inst_type = context()->get_def_use_mgr()->GetDef(def_inst->type_id()); @@ -790,7 +808,7 @@ bool Instruction::IsFoldableByFoldVector() const { // Even if the type of the instruction is foldable, its operands may not be // foldable (e.g., comparisons of 64bit types). Check that all operand types // are foldable before accepting the instruction. - return WhileEachInOperand([&folder, this](const uint32_t* op_id) { + return WhileEachInId([&folder, this](const uint32_t* op_id) { Instruction* def_inst = context()->get_def_use_mgr()->GetDef(*op_id); Instruction* def_inst_type = context()->get_def_use_mgr()->GetDef(def_inst->type_id()); @@ -1033,6 +1051,12 @@ bool Instruction::IsOpcodeSafeToDelete() const { return true; } + if (IsNonSemanticInstruction() && + (GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugDeclare || + GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugValue)) { + return true; + } + switch (opcode()) { case spv::Op::OpDPdx: case spv::Op::OpDPdy: diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/instruction.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/instruction.h index c2617fb..2e1ef35 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/instruction.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/instruction.h @@ -318,7 +318,7 @@ class Instruction : public utils::IntrusiveNodeBase { inline void SetDebugScope(const DebugScope& scope); inline const DebugScope& GetDebugScope() const { return dbg_scope_; } // Add debug line inst. Renew result id if Debug[No]Line - void AddDebugLine(const Instruction* inst); + bool AddDebugLine(const Instruction* inst); // Updates DebugInlinedAt of DebugScope and OpLine. void UpdateDebugInlinedAt(uint32_t new_inlined_at); // Clear line-related debug instructions attached to this instruction @@ -338,7 +338,8 @@ class Instruction : public utils::IntrusiveNodeBase { // Updates lexical scope of DebugScope and OpLine. void UpdateLexicalScope(uint32_t scope); // Updates OpLine and DebugScope based on the information of |from|. - void UpdateDebugInfoFrom(const Instruction* from); + bool UpdateDebugInfoFrom(const Instruction* from, + const Instruction* line = nullptr); // Remove the |index|-th operand void RemoveOperand(uint32_t index) { operands_.erase(operands_.begin() + index); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/interface_var_sroa.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/interface_var_sroa.cpp index 08477cb..8c0b91f 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/interface_var_sroa.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/interface_var_sroa.cpp @@ -239,28 +239,34 @@ void InterfaceVariableScalarReplacement::KillLocationAndComponentDecorations( }); } -bool InterfaceVariableScalarReplacement::ReplaceInterfaceVariableWithScalars( +Pass::Status +InterfaceVariableScalarReplacement::ReplaceInterfaceVariableWithScalars( Instruction* interface_var, Instruction* interface_var_type, uint32_t location, uint32_t component, uint32_t extra_array_length) { - NestedCompositeComponents scalar_interface_vars = + std::optional scalar_interface_vars = CreateScalarInterfaceVarsForReplacement(interface_var_type, GetStorageClass(interface_var), extra_array_length); - AddLocationAndComponentDecorations(scalar_interface_vars, &location, + if (!scalar_interface_vars) { + return Status::Failure; + } + + AddLocationAndComponentDecorations(*scalar_interface_vars, &location, component); KillLocationAndComponentDecorations(interface_var->result_id()); - if (!ReplaceInterfaceVarWith(interface_var, extra_array_length, - scalar_interface_vars)) { - return false; + Status status = ReplaceInterfaceVarWith(interface_var, extra_array_length, + *scalar_interface_vars); + if (status == Status::Failure) { + return status; } context()->KillInst(interface_var); - return true; + return status; } -bool InterfaceVariableScalarReplacement::ReplaceInterfaceVarWith( +Pass::Status InterfaceVariableScalarReplacement::ReplaceInterfaceVarWith( Instruction* interface_var, uint32_t extra_array_length, const NestedCompositeComponents& scalar_interface_vars) { std::vector users; @@ -276,21 +282,24 @@ bool InterfaceVariableScalarReplacement::ReplaceInterfaceVarWith( // interface variable. for (uint32_t index = 0; index < extra_array_length; ++index) { std::unordered_map loads_to_component_values; - if (!ReplaceComponentsOfInterfaceVarWith( - interface_var, users, scalar_interface_vars, - interface_var_component_indices, &index, - &loads_to_component_values, - &loads_for_access_chain_to_composites)) { - return false; + Status status = ReplaceComponentsOfInterfaceVarWith( + interface_var, users, scalar_interface_vars, + interface_var_component_indices, &index, &loads_to_component_values, + &loads_for_access_chain_to_composites); + if (status == Status::Failure) { + return Status::Failure; } AddComponentsToCompositesForLoads(loads_to_component_values, &loads_to_composites, 0); } - } else if (!ReplaceComponentsOfInterfaceVarWith( - interface_var, users, scalar_interface_vars, - interface_var_component_indices, nullptr, &loads_to_composites, - &loads_for_access_chain_to_composites)) { - return false; + } else { + Status status = ReplaceComponentsOfInterfaceVarWith( + interface_var, users, scalar_interface_vars, + interface_var_component_indices, nullptr, &loads_to_composites, + &loads_for_access_chain_to_composites); + if (status == Status::Failure) { + return Status::Failure; + } } ReplaceLoadWithCompositeConstruct(context(), loads_to_composites); @@ -298,7 +307,7 @@ bool InterfaceVariableScalarReplacement::ReplaceInterfaceVarWith( loads_for_access_chain_to_composites); KillInstructionsAndUsers(users); - return true; + return Status::SuccessWithChange; } void InterfaceVariableScalarReplacement::AddLocationAndComponentDecorations( @@ -318,7 +327,8 @@ void InterfaceVariableScalarReplacement::AddLocationAndComponentDecorations( } } -bool InterfaceVariableScalarReplacement::ReplaceComponentsOfInterfaceVarWith( +Pass::Status +InterfaceVariableScalarReplacement::ReplaceComponentsOfInterfaceVarWith( Instruction* interface_var, const std::vector& interface_var_users, const NestedCompositeComponents& scalar_interface_vars, @@ -329,15 +339,16 @@ bool InterfaceVariableScalarReplacement::ReplaceComponentsOfInterfaceVarWith( loads_for_access_chain_to_composites) { if (!scalar_interface_vars.HasMultipleComponents()) { for (Instruction* interface_var_user : interface_var_users) { - if (!ReplaceComponentOfInterfaceVarWith( - interface_var, interface_var_user, - scalar_interface_vars.GetComponentVariable(), - interface_var_component_indices, extra_array_index, - loads_to_composites, loads_for_access_chain_to_composites)) { - return false; + Status status = ReplaceComponentOfInterfaceVarWith( + interface_var, interface_var_user, + scalar_interface_vars.GetComponentVariable(), + interface_var_component_indices, extra_array_index, + loads_to_composites, loads_for_access_chain_to_composites); + if (status == Status::Failure) { + return Status::Failure; } } - return true; + return Status::SuccessWithChange; } return ReplaceMultipleComponentsOfInterfaceVarWith( interface_var, interface_var_users, scalar_interface_vars.GetComponents(), @@ -345,27 +356,28 @@ bool InterfaceVariableScalarReplacement::ReplaceComponentsOfInterfaceVarWith( loads_for_access_chain_to_composites); } -bool InterfaceVariableScalarReplacement:: - ReplaceMultipleComponentsOfInterfaceVarWith( - Instruction* interface_var, - const std::vector& interface_var_users, - const std::vector& components, - std::vector& interface_var_component_indices, - const uint32_t* extra_array_index, - std::unordered_map* loads_to_composites, - std::unordered_map* - loads_for_access_chain_to_composites) { +Pass::Status +InterfaceVariableScalarReplacement::ReplaceMultipleComponentsOfInterfaceVarWith( + Instruction* interface_var, + const std::vector& interface_var_users, + const std::vector& components, + std::vector& interface_var_component_indices, + const uint32_t* extra_array_index, + std::unordered_map* loads_to_composites, + std::unordered_map* + loads_for_access_chain_to_composites) { for (uint32_t i = 0; i < components.size(); ++i) { interface_var_component_indices.push_back(i); std::unordered_map loads_to_component_values; std::unordered_map loads_for_access_chain_to_component_values; - if (!ReplaceComponentsOfInterfaceVarWith( - interface_var, interface_var_users, components[i], - interface_var_component_indices, extra_array_index, - &loads_to_component_values, - &loads_for_access_chain_to_component_values)) { - return false; + Status status = ReplaceComponentsOfInterfaceVarWith( + interface_var, interface_var_users, components[i], + interface_var_component_indices, extra_array_index, + &loads_to_component_values, + &loads_for_access_chain_to_component_values); + if (status == Status::Failure) { + return Status::Failure; } interface_var_component_indices.pop_back(); @@ -378,10 +390,11 @@ bool InterfaceVariableScalarReplacement:: AddComponentsToCompositesForLoads(loads_to_component_values, loads_to_composites, depth_to_component); } - return true; + return Status::SuccessWithChange; } -bool InterfaceVariableScalarReplacement::ReplaceComponentOfInterfaceVarWith( +Pass::Status +InterfaceVariableScalarReplacement::ReplaceComponentOfInterfaceVarWith( Instruction* interface_var, Instruction* interface_var_user, Instruction* scalar_var, const std::vector& interface_var_component_indices, @@ -395,42 +408,49 @@ bool InterfaceVariableScalarReplacement::ReplaceComponentOfInterfaceVarWith( StoreComponentOfValueToScalarVar(value_id, interface_var_component_indices, scalar_var, extra_array_index, interface_var_user); - return true; + return Status::SuccessWithChange; } if (opcode == spv::Op::OpLoad) { Instruction* scalar_load = LoadScalarVar(scalar_var, extra_array_index, interface_var_user); + if (scalar_load == nullptr) { + return Status::Failure; + } loads_to_component_values->insert({interface_var_user, scalar_load}); - return true; + return Status::SuccessWithChange; } // Copy OpName and annotation instructions only once. Therefore, we create // them only for the first element of the extra array. - if (extra_array_index && *extra_array_index != 0) return true; + if (extra_array_index && *extra_array_index != 0) + return Status::SuccessWithChange; if (opcode == spv::Op::OpDecorateId || opcode == spv::Op::OpDecorateString || opcode == spv::Op::OpDecorate) { CloneAnnotationForVariable(interface_var_user, scalar_var->result_id()); - return true; + return Status::SuccessWithChange; } if (opcode == spv::Op::OpName) { std::unique_ptr new_inst(interface_var_user->Clone(context())); new_inst->SetInOperand(0, {scalar_var->result_id()}); context()->AddDebug2Inst(std::move(new_inst)); - return true; + return Status::SuccessWithChange; } if (opcode == spv::Op::OpEntryPoint) { - return ReplaceInterfaceVarInEntryPoint(interface_var, interface_var_user, - scalar_var->result_id()); + if (ReplaceInterfaceVarInEntryPoint(interface_var, interface_var_user, + scalar_var->result_id())) { + return Status::SuccessWithChange; + } + return Status::Failure; } if (opcode == spv::Op::OpAccessChain) { ReplaceAccessChainWith(interface_var_user, interface_var_component_indices, scalar_var, loads_for_access_chain_to_component_values); - return true; + return Status::SuccessWithChange; } std::string message("Unhandled instruction"); @@ -440,7 +460,7 @@ bool InterfaceVariableScalarReplacement::ReplaceComponentOfInterfaceVarWith( "\nfor interface variable scalar replacement\n " + interface_var->PrettyPrint(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES); context()->consumer()(SPV_MSG_ERROR, "", {0, 0, 0}, message.c_str()); - return false; + return Status::Failure; } void InterfaceVariableScalarReplacement::UseBaseAccessChainForAccessChain( @@ -470,10 +490,14 @@ Instruction* InterfaceVariableScalarReplacement::CreateAccessChainToVar( uint32_t ptr_type_id = GetPointerType(*component_type_id, GetStorageClass(var)); - std::unique_ptr new_access_chain(new Instruction( - context(), spv::Op::OpAccessChain, ptr_type_id, TakeNextId(), - std::initializer_list{ - {SPV_OPERAND_TYPE_ID, {var->result_id()}}})); + uint32_t new_id = TakeNextId(); + if (new_id == 0) { + return nullptr; + } + std::unique_ptr new_access_chain( + new Instruction(context(), spv::Op::OpAccessChain, ptr_type_id, new_id, + std::initializer_list{ + {SPV_OPERAND_TYPE_ID, {var->result_id()}}})); for (uint32_t index_id : index_ids) { new_access_chain->AddOperand({SPV_OPERAND_TYPE_ID, {index_id}}); } @@ -490,12 +514,16 @@ Instruction* InterfaceVariableScalarReplacement::CreateAccessChainWithIndex( uint32_t ptr_type_id = GetPointerType(component_type_id, GetStorageClass(var)); uint32_t index_id = context()->get_constant_mgr()->GetUIntConstId(index); - std::unique_ptr new_access_chain(new Instruction( - context(), spv::Op::OpAccessChain, ptr_type_id, TakeNextId(), - std::initializer_list{ - {SPV_OPERAND_TYPE_ID, {var->result_id()}}, - {SPV_OPERAND_TYPE_ID, {index_id}}, - })); + uint32_t new_id = TakeNextId(); + if (new_id == 0) { + return nullptr; + } + std::unique_ptr new_access_chain( + new Instruction(context(), spv::Op::OpAccessChain, ptr_type_id, new_id, + std::initializer_list{ + {SPV_OPERAND_TYPE_ID, {var->result_id()}}, + {SPV_OPERAND_TYPE_ID, {index_id}}, + })); Instruction* inst = new_access_chain.get(); context()->get_def_use_mgr()->AnalyzeInstDefUse(inst); insert_before->InsertBefore(std::move(new_access_chain)); @@ -617,6 +645,9 @@ void InterfaceVariableScalarReplacement::StoreComponentOfValueToScalarVar( component_type_id = ty_mgr->GetTypeInstruction(array_type->element_type()); ptr = CreateAccessChainWithIndex(component_type_id, scalar_var, *extra_array_index, insert_before); + if (ptr == nullptr) { + return; + } } StoreComponentOfValueTo(component_type_id, value_id, component_indices, ptr, @@ -635,6 +666,9 @@ Instruction* InterfaceVariableScalarReplacement::LoadScalarVar( component_type_id = ty_mgr->GetTypeInstruction(array_type->element_type()); ptr = CreateAccessChainWithIndex(component_type_id, scalar_var, *extra_array_index, insert_before); + if (ptr == nullptr) { + return nullptr; + } } return CreateLoad(component_type_id, ptr, insert_before); @@ -642,8 +676,12 @@ Instruction* InterfaceVariableScalarReplacement::LoadScalarVar( Instruction* InterfaceVariableScalarReplacement::CreateLoad( uint32_t type_id, Instruction* ptr, Instruction* insert_before) { + uint32_t new_id = TakeNextId(); + if (new_id == 0) { + return nullptr; + } std::unique_ptr load( - new Instruction(context(), spv::Op::OpLoad, type_id, TakeNextId(), + new Instruction(context(), spv::Op::OpLoad, type_id, new_id, std::initializer_list{ {SPV_OPERAND_TYPE_ID, {ptr->result_id()}}})); Instruction* load_inst = load.get(); @@ -658,6 +696,9 @@ void InterfaceVariableScalarReplacement::StoreComponentOfValueTo( const uint32_t* extra_array_index, Instruction* insert_before) { std::unique_ptr composite_extract(CreateCompositeExtract( component_type_id, value_id, component_indices, extra_array_index)); + if (composite_extract == nullptr) { + return; + } std::unique_ptr new_store( new Instruction(context(), spv::Op::OpStore)); @@ -677,6 +718,9 @@ Instruction* InterfaceVariableScalarReplacement::CreateCompositeExtract( uint32_t type_id, uint32_t composite_id, const std::vector& indexes, const uint32_t* extra_first_index) { uint32_t component_id = TakeNextId(); + if (component_id == 0) { + return nullptr; + } Instruction* composite_extract = new Instruction( context(), spv::Op::OpCompositeExtract, type_id, component_id, std::initializer_list{{SPV_OPERAND_TYPE_ID, {composite_id}}}); @@ -716,6 +760,9 @@ Instruction* InterfaceVariableScalarReplacement::LoadAccessChainToVar( if (!indexes.empty()) { ptr = CreateAccessChainToVar(component_type_id, var, indexes, insert_before, &component_type_id); + if (ptr == nullptr) { + return nullptr; + } } return CreateLoad(component_type_id, ptr, insert_before); @@ -730,7 +777,10 @@ InterfaceVariableScalarReplacement::CreateCompositeConstructForComponentOfLoad( type_id = GetComponentTypeOfArrayMatrix(def_use_mgr, load->type_id(), depth_to_component); } - uint32_t new_id = context()->TakeNextId(); + uint32_t new_id = TakeNextId(); + if (new_id == 0) { + return nullptr; + } std::unique_ptr new_composite_construct(new Instruction( context(), spv::Op::OpCompositeConstruct, type_id, new_id, {})); Instruction* composite_construct = new_composite_construct.get(); @@ -767,6 +817,10 @@ void InterfaceVariableScalarReplacement::AddComponentsToCompositesForLoads( if (itr == loads_to_composites->end()) { composite_construct = CreateCompositeConstructForComponentOfLoad(load, depth_to_component); + if (composite_construct == nullptr) { + assert(false && "Could not create composite construct"); + return; + } loads_to_composites->insert({load, composite_construct}); } else { composite_construct = itr->second; @@ -795,7 +849,7 @@ uint32_t InterfaceVariableScalarReplacement::GetPointerType( return context()->get_type_mgr()->GetTypeInstruction(&ptr_type); } -InterfaceVariableScalarReplacement::NestedCompositeComponents +std::optional InterfaceVariableScalarReplacement::CreateScalarInterfaceVarsForArray( Instruction* interface_var_type, spv::StorageClass storage_class, uint32_t extra_array_length) { @@ -807,16 +861,19 @@ InterfaceVariableScalarReplacement::CreateScalarInterfaceVarsForArray( NestedCompositeComponents scalar_vars; while (array_length > 0) { - NestedCompositeComponents scalar_vars_for_element = + std::optional scalar_vars_for_element = CreateScalarInterfaceVarsForReplacement(elem_type, storage_class, extra_array_length); - scalar_vars.AddComponent(scalar_vars_for_element); + if (!scalar_vars_for_element) { + return std::nullopt; + } + scalar_vars.AddComponent(*scalar_vars_for_element); --array_length; } return scalar_vars; } -InterfaceVariableScalarReplacement::NestedCompositeComponents +std::optional InterfaceVariableScalarReplacement::CreateScalarInterfaceVarsForMatrix( Instruction* interface_var_type, spv::StorageClass storage_class, uint32_t extra_array_length) { @@ -830,16 +887,19 @@ InterfaceVariableScalarReplacement::CreateScalarInterfaceVarsForMatrix( NestedCompositeComponents scalar_vars; while (column_count > 0) { - NestedCompositeComponents scalar_vars_for_column = + std::optional scalar_vars_for_column = CreateScalarInterfaceVarsForReplacement(column_type, storage_class, extra_array_length); - scalar_vars.AddComponent(scalar_vars_for_column); + if (!scalar_vars_for_column) { + return std::nullopt; + } + scalar_vars.AddComponent(*scalar_vars_for_column); --column_count; } return scalar_vars; } -InterfaceVariableScalarReplacement::NestedCompositeComponents +std::optional InterfaceVariableScalarReplacement::CreateScalarInterfaceVarsForReplacement( Instruction* interface_var_type, spv::StorageClass storage_class, uint32_t extra_array_length) { @@ -864,6 +924,9 @@ InterfaceVariableScalarReplacement::CreateScalarInterfaceVarsForReplacement( uint32_t ptr_type_id = context()->get_type_mgr()->FindPointerToType(type_id, storage_class); uint32_t id = TakeNextId(); + if (id == 0) { + return std::nullopt; + } std::unique_ptr variable( new Instruction(context(), spv::Op::OpVariable, ptr_type_id, id, std::initializer_list{ @@ -953,9 +1016,9 @@ InterfaceVariableScalarReplacement::ReplaceInterfaceVarsWithScalars( continue; } - if (!ReplaceInterfaceVariableWithScalars(interface_var, interface_var_type, - location, component, - extra_array_length)) { + if (ReplaceInterfaceVariableWithScalars( + interface_var, interface_var_type, location, component, + extra_array_length) == Pass::Status::Failure) { return Pass::Status::Failure; } status = Pass::Status::SuccessWithChange; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/interface_var_sroa.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/interface_var_sroa.h index 45ed371..743cdfb 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/interface_var_sroa.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/interface_var_sroa.h @@ -15,6 +15,7 @@ #ifndef SOURCE_OPT_INTERFACE_VAR_SROA_H_ #define SOURCE_OPT_INTERFACE_VAR_SROA_H_ +#include #include #include "source/opt/pass.h" @@ -100,25 +101,26 @@ class InterfaceVariableScalarReplacement : public Pass { // If |extra_array_length| is 0, it means |interface_var| has a Patch // decoration. Otherwise, |extra_array_length| denotes the length of the extra // array of |interface_var|. - bool ReplaceInterfaceVariableWithScalars(Instruction* interface_var, - Instruction* interface_var_type, - uint32_t location, - uint32_t component, - uint32_t extra_array_length); + Status ReplaceInterfaceVariableWithScalars(Instruction* interface_var, + Instruction* interface_var_type, + uint32_t location, + uint32_t component, + uint32_t extra_array_length); // Creates scalar variables with the storage classe |storage_class| to replace // an interface variable whose type is |interface_var_type|. If // |extra_array_length| is not zero, adds the extra arrayness to the created // scalar variables. - NestedCompositeComponents CreateScalarInterfaceVarsForReplacement( - Instruction* interface_var_type, spv::StorageClass storage_class, - uint32_t extra_array_length); + std::optional + CreateScalarInterfaceVarsForReplacement(Instruction* interface_var_type, + spv::StorageClass storage_class, + uint32_t extra_array_length); // Creates scalar variables with the storage classe |storage_class| to replace // the interface variable whose type is OpTypeArray |interface_var_type| with. // If |extra_array_length| is not zero, adds the extra arrayness to all the // scalar variables. - NestedCompositeComponents CreateScalarInterfaceVarsForArray( + std::optional CreateScalarInterfaceVarsForArray( Instruction* interface_var_type, spv::StorageClass storage_class, uint32_t extra_array_length); @@ -126,7 +128,7 @@ class InterfaceVariableScalarReplacement : public Pass { // the interface variable whose type is OpTypeMatrix |interface_var_type| // with. If |extra_array_length| is not zero, adds the extra arrayness to all // the scalar variables. - NestedCompositeComponents CreateScalarInterfaceVarsForMatrix( + std::optional CreateScalarInterfaceVarsForMatrix( Instruction* interface_var_type, spv::StorageClass storage_class, uint32_t extra_array_length); @@ -142,7 +144,7 @@ class InterfaceVariableScalarReplacement : public Pass { // |extra_arrayness| is the extra arrayness of the interface variable. // |scalar_interface_vars| contains the nested variables to replace the // interface variable with. - bool ReplaceInterfaceVarWith( + Status ReplaceInterfaceVarWith( Instruction* interface_var, uint32_t extra_arrayness, const NestedCompositeComponents& scalar_interface_vars); @@ -155,7 +157,7 @@ class InterfaceVariableScalarReplacement : public Pass { // construct instructions to be replaced with load instructions of access // chain instructions in |interface_var_users| via // |loads_for_access_chain_to_composites|. - bool ReplaceComponentsOfInterfaceVarWith( + Status ReplaceComponentsOfInterfaceVarWith( Instruction* interface_var, const std::vector& interface_var_users, const NestedCompositeComponents& scalar_interface_vars, @@ -174,7 +176,7 @@ class InterfaceVariableScalarReplacement : public Pass { // via |loads_to_composites|. Returns composite construct instructions to be // replaced with load instructions of access chain instructions in // |interface_var_users| via |loads_for_access_chain_to_composites|. - bool ReplaceMultipleComponentsOfInterfaceVarWith( + Status ReplaceMultipleComponentsOfInterfaceVarWith( Instruction* interface_var, const std::vector& interface_var_users, const std::vector& components, @@ -192,7 +194,7 @@ class InterfaceVariableScalarReplacement : public Pass { // |loads_to_component_values|. If |interface_var_user| is an access chain, // returns the component value for loads of |interface_var_user| via // |loads_for_access_chain_to_component_values|. - bool ReplaceComponentOfInterfaceVarWith( + Status ReplaceComponentOfInterfaceVarWith( Instruction* interface_var, Instruction* interface_var_user, Instruction* scalar_var, const std::vector& interface_var_component_indices, @@ -389,6 +391,9 @@ class InterfaceVariableScalarReplacement : public Pass { // A set of interface variables without the extra arrayness for any of the // entry points. std::unordered_set vars_without_extra_arrayness; + + // Returns the next available id, or 0 if the id overflows. + uint32_t TakeNextId() { return context()->TakeNextId(); } }; } // namespace opt diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/invocation_interlock_placement_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/invocation_interlock_placement_pass.cpp index f25f554..b31697c 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/invocation_interlock_placement_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/invocation_interlock_placement_pass.cpp @@ -294,8 +294,12 @@ bool InvocationInterlockPlacementPass::removeUnneededInstructions( BasicBlock* InvocationInterlockPlacementPass::splitEdge(BasicBlock* block, uint32_t succ_id) { // Create a new block to replace the critical edge. + uint32_t new_id = context()->TakeNextId(); + if (new_id == 0) { + return nullptr; + } auto new_succ_temp = MakeUnique( - MakeUnique(context(), spv::Op::OpLabel, 0, TakeNextId(), + MakeUnique(context(), spv::Op::OpLabel, 0, new_id, std::initializer_list{})); auto* new_succ = new_succ_temp.get(); @@ -325,7 +329,7 @@ BasicBlock* InvocationInterlockPlacementPass::splitEdge(BasicBlock* block, return new_succ; } -bool InvocationInterlockPlacementPass::placeInstructionsForEdge( +Pass::Status InvocationInterlockPlacementPass::placeInstructionsForEdge( BasicBlock* block, uint32_t next_id, BlockSet& inside, BlockSet& previous_inside, spv::Op opcode, bool reverse_cfg) { bool modified = false; @@ -372,31 +376,45 @@ bool InvocationInterlockPlacementPass::placeInstructionsForEdge( new_branch = splitEdge(cfg()->block(next_id), block->id()); } + if (!new_branch) { + return Status::Failure; + } + auto inst = new Instruction(context(), opcode); inst->InsertBefore(&*new_branch->tail()); } } - return modified; + return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } -bool InvocationInterlockPlacementPass::placeInstructions(BasicBlock* block) { - bool modified = false; +Pass::Status InvocationInterlockPlacementPass::placeInstructions( + BasicBlock* block) { + Status status = Status::SuccessWithoutChange; - block->ForEachSuccessorLabel([this, block, &modified](uint32_t succ_id) { - modified |= placeInstructionsForEdge( + block->ForEachSuccessorLabel([this, block, &status](uint32_t succ_id) { + if (status == Status::Failure) { + return; + } + Status edge_status = placeInstructionsForEdge( block, succ_id, after_begin_, predecessors_after_begin_, spv::Op::OpBeginInvocationInterlockEXT, /* reverse_cfg= */ true); - modified |= placeInstructionsForEdge(cfg()->block(succ_id), block->id(), - before_end_, successors_before_end_, - spv::Op::OpEndInvocationInterlockEXT, - /* reverse_cfg= */ false); + status = CombineStatus(status, edge_status); + if (status == Status::Failure) { + return; + } + + edge_status = placeInstructionsForEdge(cfg()->block(succ_id), block->id(), + before_end_, successors_before_end_, + spv::Op::OpEndInvocationInterlockEXT, + /* reverse_cfg= */ false); + status = CombineStatus(status, edge_status); }); - return modified; + return status; } -bool InvocationInterlockPlacementPass::processFragmentShaderEntry( +Pass::Status InvocationInterlockPlacementPass::processFragmentShaderEntry( Function* entry_func) { bool modified = false; @@ -417,9 +435,15 @@ bool InvocationInterlockPlacementPass::processFragmentShaderEntry( for (BasicBlock* block : original_blocks) { modified |= removeUnneededInstructions(block); - modified |= placeInstructions(block); + Status place_status = placeInstructions(block); + if (place_status == Status::Failure) { + return Status::Failure; + } + if (place_status == Status::SuccessWithChange) { + modified = true; + } } - return modified; + return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } bool InvocationInterlockPlacementPass::isFragmentShaderInterlockEnabled() { @@ -452,7 +476,7 @@ Pass::Status InvocationInterlockPlacementPass::Process() { return Status::SuccessWithoutChange; } - bool modified = false; + Status status = Status::SuccessWithoutChange; std::unordered_set entry_points; for (Instruction& entry_inst : context()->module()->entry_points()) { @@ -466,7 +490,9 @@ Pass::Status InvocationInterlockPlacementPass::Process() { Function* func = &*fi; recordBeginOrEndInFunction(func); if (!entry_points.count(func) && extracted_functions_.count(func)) { - modified |= removeBeginAndEndInstructionsFromFunction(func); + if (removeBeginAndEndInstructionsFromFunction(func)) { + status = Status::SuccessWithChange; + } } } @@ -482,11 +508,14 @@ Pass::Status InvocationInterlockPlacementPass::Process() { continue; } - modified |= processFragmentShaderEntry(entry_func); + Status frag_status = processFragmentShaderEntry(entry_func); + if (frag_status == Status::Failure) { + return Status::Failure; + } + status = CombineStatus(status, frag_status); } - return modified ? Pass::Status::SuccessWithChange - : Pass::Status::SuccessWithoutChange; + return status; } } // namespace opt diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/invocation_interlock_placement_pass.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/invocation_interlock_placement_pass.h index 4e85be8..497af28 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/invocation_interlock_placement_pass.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/invocation_interlock_placement_pass.h @@ -120,14 +120,14 @@ class InvocationInterlockPlacementPass : public Pass { // For the edge from block to next_id, places a begin or end instruction on // the edge, based on the direction we are walking the CFG, specified in // reverse_cfg. - bool placeInstructionsForEdge(BasicBlock* block, uint32_t next_id, - BlockSet& inside, BlockSet& previous_inside, - spv::Op opcode, bool reverse_cfg); + Status placeInstructionsForEdge(BasicBlock* block, uint32_t next_id, + BlockSet& inside, BlockSet& previous_inside, + spv::Op opcode, bool reverse_cfg); // Calls placeInstructionsForEdge for each edge in block. - bool placeInstructions(BasicBlock* block); + Status placeInstructions(BasicBlock* block); // Processes a single fragment shader entry function. - bool processFragmentShaderEntry(Function* entry_func); + Status processFragmentShaderEntry(Function* entry_func); // Returns whether the module has the SPV_EXT_fragment_shader_interlock // extension and one of the FragmentShader*InterlockEXT capabilities. diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_builder.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_builder.h index f7ac692..529bd8f 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_builder.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_builder.h @@ -166,10 +166,14 @@ class InstructionBuilder { for (size_t i = 0; i < operands.size(); i++) { ops.push_back({SPV_OPERAND_TYPE_ID, {operands[i]}}); } - // TODO(1841): Handle id overflow. - std::unique_ptr new_inst(new Instruction( - GetContext(), opcode, type_id, - result != 0 ? result : GetContext()->TakeNextId(), ops)); + if (result == 0) { + result = GetContext()->TakeNextId(); + if (result == 0) { + return nullptr; + } + } + std::unique_ptr new_inst( + new Instruction(GetContext(), opcode, type_id, result, ops)); return AddInstruction(std::move(new_inst)); } @@ -297,9 +301,12 @@ class InstructionBuilder { // The id |op1| is the left hand side of the operation. // The id |op2| is the right hand side of the operation. Instruction* AddIAdd(uint32_t type, uint32_t op1, uint32_t op2) { - // TODO(1841): Handle id overflow. + uint32_t result_id = GetContext()->TakeNextId(); + if (result_id == 0) { + return nullptr; + } std::unique_ptr inst(new Instruction( - GetContext(), spv::Op::OpIAdd, type, GetContext()->TakeNextId(), + GetContext(), spv::Op::OpIAdd, type, result_id, {{SPV_OPERAND_TYPE_ID, {op1}}, {SPV_OPERAND_TYPE_ID, {op2}}})); return AddInstruction(std::move(inst)); } @@ -311,9 +318,12 @@ class InstructionBuilder { Instruction* AddULessThan(uint32_t op1, uint32_t op2) { analysis::Bool bool_type; uint32_t type = GetContext()->get_type_mgr()->GetId(&bool_type); - // TODO(1841): Handle id overflow. + uint32_t result_id = GetContext()->TakeNextId(); + if (result_id == 0) { + return nullptr; + } std::unique_ptr inst(new Instruction( - GetContext(), spv::Op::OpULessThan, type, GetContext()->TakeNextId(), + GetContext(), spv::Op::OpULessThan, type, result_id, {{SPV_OPERAND_TYPE_ID, {op1}}, {SPV_OPERAND_TYPE_ID, {op2}}})); return AddInstruction(std::move(inst)); } @@ -325,9 +335,12 @@ class InstructionBuilder { Instruction* AddSLessThan(uint32_t op1, uint32_t op2) { analysis::Bool bool_type; uint32_t type = GetContext()->get_type_mgr()->GetId(&bool_type); - // TODO(1841): Handle id overflow. + uint32_t result_id = GetContext()->TakeNextId(); + if (result_id == 0) { + return nullptr; + } std::unique_ptr inst(new Instruction( - GetContext(), spv::Op::OpSLessThan, type, GetContext()->TakeNextId(), + GetContext(), spv::Op::OpSLessThan, type, result_id, {{SPV_OPERAND_TYPE_ID, {op1}}, {SPV_OPERAND_TYPE_ID, {op2}}})); return AddInstruction(std::move(inst)); } @@ -355,9 +368,12 @@ class InstructionBuilder { // bool) for |type|. Instruction* AddSelect(uint32_t type, uint32_t cond, uint32_t true_value, uint32_t false_value) { - // TODO(1841): Handle id overflow. + uint32_t result_id = GetContext()->TakeNextId(); + if (result_id == 0) { + return nullptr; + } std::unique_ptr select(new Instruction( - GetContext(), spv::Op::OpSelect, type, GetContext()->TakeNextId(), + GetContext(), spv::Op::OpSelect, type, result_id, std::initializer_list{{SPV_OPERAND_TYPE_ID, {cond}}, {SPV_OPERAND_TYPE_ID, {true_value}}, {SPV_OPERAND_TYPE_ID, {false_value}}})); @@ -381,10 +397,12 @@ class InstructionBuilder { ops.emplace_back(SPV_OPERAND_TYPE_ID, std::initializer_list{id}); } - // TODO(1841): Handle id overflow. - std::unique_ptr construct( - new Instruction(GetContext(), spv::Op::OpCompositeConstruct, type, - GetContext()->TakeNextId(), ops)); + uint32_t result_id = GetContext()->TakeNextId(); + if (result_id == 0) { + return nullptr; + } + std::unique_ptr construct(new Instruction( + GetContext(), spv::Op::OpCompositeConstruct, type, result_id, ops)); return AddInstruction(std::move(construct)); } @@ -466,10 +484,12 @@ class InstructionBuilder { operands.push_back({SPV_OPERAND_TYPE_LITERAL_INTEGER, {index}}); } - // TODO(1841): Handle id overflow. - std::unique_ptr new_inst( - new Instruction(GetContext(), spv::Op::OpCompositeExtract, type, - GetContext()->TakeNextId(), operands)); + uint32_t result_id = GetContext()->TakeNextId(); + if (result_id == 0) { + return nullptr; + } + std::unique_ptr new_inst(new Instruction( + GetContext(), spv::Op::OpCompositeExtract, type, result_id, operands)); return AddInstruction(std::move(new_inst)); } @@ -493,9 +513,12 @@ class InstructionBuilder { operands.push_back({SPV_OPERAND_TYPE_ID, {index_id}}); } - // TODO(1841): Handle id overflow. - std::unique_ptr new_inst(new Instruction( - GetContext(), opcode, type_id, GetContext()->TakeNextId(), operands)); + uint32_t result_id = GetContext()->TakeNextId(); + if (result_id == 0) { + return nullptr; + } + std::unique_ptr new_inst( + new Instruction(GetContext(), opcode, type_id, result_id, operands)); return AddInstruction(std::move(new_inst)); } @@ -521,29 +544,36 @@ class InstructionBuilder { operands.push_back({SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER, {alignment}}); } - // TODO(1841): Handle id overflow. - std::unique_ptr new_inst( - new Instruction(GetContext(), spv::Op::OpLoad, type_id, - GetContext()->TakeNextId(), operands)); + uint32_t result_id = GetContext()->TakeNextId(); + if (result_id == 0) { + return nullptr; + } + std::unique_ptr new_inst(new Instruction( + GetContext(), spv::Op::OpLoad, type_id, result_id, operands)); return AddInstruction(std::move(new_inst)); } Instruction* AddCopyObject(uint32_t type_id, uint32_t value_id) { std::vector operands{{SPV_OPERAND_TYPE_ID, {value_id}}}; - // TODO(1841): Handle id overflow. - std::unique_ptr new_inst( - new Instruction(GetContext(), spv::Op::OpCopyObject, type_id, - GetContext()->TakeNextId(), operands)); + uint32_t result_id = GetContext()->TakeNextId(); + if (result_id == 0) { + return nullptr; + } + std::unique_ptr new_inst(new Instruction( + GetContext(), spv::Op::OpCopyObject, type_id, result_id, operands)); return AddInstruction(std::move(new_inst)); } Instruction* AddVariable(uint32_t type_id, uint32_t storage_class) { std::vector operands; operands.push_back({SPV_OPERAND_TYPE_STORAGE_CLASS, {storage_class}}); - std::unique_ptr new_inst( - new Instruction(GetContext(), spv::Op::OpVariable, type_id, - GetContext()->TakeNextId(), operands)); + uint32_t result_id = GetContext()->TakeNextId(); + if (result_id == 0) { + return nullptr; + } + std::unique_ptr new_inst(new Instruction( + GetContext(), spv::Op::OpVariable, type_id, result_id, operands)); return AddInstruction(std::move(new_inst)); } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_context.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_context.cpp index 3f41965..73d6eea 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_context.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_context.cpp @@ -93,6 +93,9 @@ void IRContext::BuildInvalidAnalyses(IRContext::Analysis set) { if (set & kAnalysisLiveness) { BuildLivenessManager(); } + if (set & kAnalysisIdToGraphMapping) { + BuildIdToGraphMapping(); + } } void IRContext::InvalidateAnalysesExceptFor( @@ -164,6 +167,9 @@ void IRContext::InvalidateAnalyses(IRContext::Analysis analyses_to_invalidate) { if (analyses_to_invalidate & kAnalysisDebugInfo) { debug_info_mgr_.reset(nullptr); } + if (analyses_to_invalidate & kAnalysisIdToGraphMapping) { + id_to_graph_.clear(); + } valid_analyses_ = Analysis(valid_analyses_ & ~analyses_to_invalidate); } @@ -201,7 +207,9 @@ Instruction* IRContext::KillInst(Instruction* inst) { constant_mgr_->RemoveId(inst->result_id()); } if (inst->opcode() == spv::Op::OpCapability || - inst->opcode() == spv::Op::OpExtension) { + inst->opcode() == spv::Op::OpConditionalCapabilityINTEL || + inst->opcode() == spv::Op::OpExtension || + inst->opcode() == spv::Op::OpConditionalExtensionINTEL) { // We reset the feature manager, instead of updating it, because it is just // as much work. We would have to remove all capabilities implied by this // capability that are not also implied by the remaining OpCapability @@ -382,6 +390,7 @@ bool IRContext::IsConsistent() { } } + return true; if (AreAnalysesValid(kAnalysisIdToFuncMapping)) { for (auto& fn : *module_) { if (id_to_func_[fn.result_id()] != &fn) { @@ -390,6 +399,14 @@ bool IRContext::IsConsistent() { } } + if (AreAnalysesValid(kAnalysisIdToGraphMapping)) { + for (auto& g : module_->graphs()) { + if (id_to_graph_[g->DefInst().result_id()] != g.get()) { + return false; + } + } + } + if (AreAnalysesValid(kAnalysisInstrToBlockMapping)) { for (auto& func : *module()) { for (auto& block : func) { @@ -398,8 +415,9 @@ bool IRContext::IsConsistent() { return false; } return true; - })) + })) { return false; + } } } } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_context.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_context.h index d2b2092..89e8cb0 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_context.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_context.h @@ -84,7 +84,8 @@ class IRContext { kAnalysisTypes = 1 << 15, kAnalysisDebugInfo = 1 << 16, kAnalysisLiveness = 1 << 17, - kAnalysisEnd = 1 << 18 + kAnalysisIdToGraphMapping = 1 << 18, + kAnalysisEnd = 1 << 19 }; using ProcessFunction = std::function; @@ -109,7 +110,8 @@ class IRContext { id_to_name_(nullptr), max_id_bound_(kDefaultMaxIdBound), preserve_bindings_(false), - preserve_spec_constants_(false) { + preserve_spec_constants_(false), + id_overflow_(false) { SetContextMessageConsumer(syntax_context_, consumer_); module_->SetContext(this); } @@ -127,7 +129,8 @@ class IRContext { id_to_name_(nullptr), max_id_bound_(kDefaultMaxIdBound), preserve_bindings_(false), - preserve_spec_constants_(false) { + preserve_spec_constants_(false), + id_overflow_(false) { SetContextMessageConsumer(syntax_context_, consumer_); module_->SetContext(this); InitializeCombinators(); @@ -563,6 +566,7 @@ class IRContext { inline uint32_t TakeNextId() { uint32_t next_id = module()->TakeNextIdBound(); if (next_id == 0) { + id_overflow_ = true; if (consumer()) { std::string message = "ID overflow. Try running compact-ids."; consumer()(SPV_MSG_ERROR, "", {0, 0, 0}, message.c_str()); @@ -583,6 +587,13 @@ class IRContext { return next_id; } + // Returns true if an ID overflow has occurred since the last time the flag + // was cleared. + bool id_overflow() const { return id_overflow_; } + + // Clears the ID overflow flag. + void clear_id_overflow() { id_overflow_ = false; } + FeatureManager* get_feature_mgr() { if (!feature_mgr_.get()) { AnalyzeFeatures(); @@ -641,6 +652,23 @@ class IRContext { return GetFunction(inst->result_id()); } + // Returns the graph whose id is |id|, if one exists. Returns |nullptr| + // otherwise. + Graph* GetGraph(uint32_t id) { + if (!AreAnalysesValid(kAnalysisIdToGraphMapping)) { + BuildIdToGraphMapping(); + } + auto entry = id_to_graph_.find(id); + return (entry != id_to_graph_.end()) ? entry->second : nullptr; + } + + Graph* GetGraph(Instruction* inst) { + if (inst->opcode() != spv::Op::OpGraphARM) { + return nullptr; + } + return GetGraph(inst->result_id()); + } + // Add to |todo| all ids of functions called directly from |func|. void AddCalls(const Function* func, std::queue* todo); @@ -719,6 +747,15 @@ class IRContext { valid_analyses_ = valid_analyses_ | kAnalysisIdToFuncMapping; } + // Builds the instruction-graph map for the whole module. + void BuildIdToGraphMapping() { + id_to_graph_.clear(); + for (auto& g : module_->graphs()) { + id_to_graph_[g->DefInst().result_id()] = g.get(); + } + valid_analyses_ = valid_analyses_ | kAnalysisIdToGraphMapping; + } + void BuildDecorationManager() { decoration_mgr_ = MakeUnique(module()); valid_analyses_ = valid_analyses_ | kAnalysisDecorations; @@ -872,6 +909,13 @@ class IRContext { // iterators to traverse instructions. std::unordered_map id_to_func_; + // A map from ids to the graph they define. This mapping is + // built on-demand when GetGraph() is called. + // + // NOTE: Do not traverse this map. Ever. Use the graph iterators to + // traverse instructions. + std::unordered_map id_to_graph_; + // A bitset indicating which analyzes are currently valid. Analysis valid_analyses_; @@ -930,6 +974,9 @@ class IRContext { // Whether all specialization constants within |module_| // should be preserved. bool preserve_spec_constants_; + + // Set to true if TakeNextId() fails. + bool id_overflow_; }; inline IRContext::Analysis operator|(IRContext::Analysis lhs, diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_loader.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_loader.cpp index 567b180..2d52ee2 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_loader.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_loader.cpp @@ -178,12 +178,48 @@ bool IrLoader::AddInstruction(const spv_parsed_instruction_t* inst) { last_dbg_scope_ = DebugScope(kNoDebugScope, kNoInlinedAt); last_line_inst_.reset(); dbg_line_info_.clear(); + } else if (opcode == spv::Op::OpGraphARM) { + if (graph_ != nullptr) { + Error(consumer_, src, loc, "graph inside graph"); + return false; + } + graph_ = MakeUnique(std::move(spv_inst)); + } else if (opcode == spv::Op::OpGraphEndARM) { + if (graph_ == nullptr) { + Error(consumer_, src, loc, + "OpGraphEndARM without corresponding OpGraphARM"); + return false; + } + graph_->SetGraphEnd(std::move(spv_inst)); + module_->AddGraph(std::move(graph_)); + graph_ = nullptr; + } else if (opcode == spv::Op::OpGraphConstantARM) { + module_->AddGlobalValue(std::move(spv_inst)); + } else if (graph_ != nullptr) { + if (opcode == spv::Op::OpGraphInputARM) { + graph_->AddInput(std::move(spv_inst)); + } else if (opcode == spv::Op::OpGraphSetOutputARM) { + graph_->AddOutput(std::move(spv_inst)); + } else { + switch (opcode) { + case spv::Op::OpExtInst: + case spv::Op::OpCompositeExtract: + graph_->AddInstruction(std::move(spv_inst)); + break; + default: + Errorf(consumer_, src, loc, + "unhandled instruction (opcode %d) inside graph", opcode); + return false; + } + } } else { if (function_ == nullptr) { // Outside function definition SPIRV_ASSERT(consumer_, block_ == nullptr); - if (opcode == spv::Op::OpCapability) { + if (opcode == spv::Op::OpCapability || + opcode == spv::Op::OpConditionalCapabilityINTEL) { module_->AddCapability(std::move(spv_inst)); - } else if (opcode == spv::Op::OpExtension) { + } else if (opcode == spv::Op::OpExtension || + opcode == spv::Op::OpConditionalExtensionINTEL) { module_->AddExtension(std::move(spv_inst)); } else if (opcode == spv::Op::OpExtInstImport) { module_->AddExtInstImport(std::move(spv_inst)); @@ -193,6 +229,8 @@ bool IrLoader::AddInstruction(const spv_parsed_instruction_t* inst) { module_->SetSampledImageAddressMode(std::move(spv_inst)); } else if (opcode == spv::Op::OpEntryPoint) { module_->AddEntryPoint(std::move(spv_inst)); + } else if (opcode == spv::Op::OpGraphEntryPointARM) { + module_->AddGraphEntryPoint(std::move(spv_inst)); } else if (opcode == spv::Op::OpExecutionMode || opcode == spv::Op::OpExecutionModeId) { module_->AddExecutionMode(std::move(spv_inst)); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_loader.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_loader.h index 16bc2c7..a8d2119 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_loader.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/ir_loader.h @@ -20,6 +20,7 @@ #include #include "source/opt/basic_block.h" +#include "source/opt/graph.h" #include "source/opt/instruction.h" #include "source/opt/module.h" #include "spirv-tools/libspirv.hpp" @@ -80,6 +81,8 @@ class IrLoader { std::unique_ptr function_; // The current BasicBlock under construction. std::unique_ptr block_; + // The current Graph under construction. + std::unique_ptr graph_; // Line related debug instructions accumulated thus far. std::vector dbg_line_info_; // If doing extra line tracking, this is the line instruction that should be diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/licm_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/licm_pass.cpp index f2a6e4d..996762b 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/licm_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/licm_pass.cpp @@ -118,7 +118,6 @@ bool LICMPass::IsImmediatelyContainedInLoop(Loop* loop, Function* f, } bool LICMPass::HoistInstruction(Loop* loop, Instruction* inst) { - // TODO(1841): Handle failure to create pre-header. BasicBlock* pre_header_bb = loop->GetOrCreatePreHeaderBlock(); if (!pre_header_bb) { return false; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_descriptor.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_descriptor.cpp index cbfc2e7..5caec41 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_descriptor.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_descriptor.cpp @@ -25,6 +25,7 @@ #include "source/opt/dominator_tree.h" #include "source/opt/ir_context.h" #include "source/opt/iterator.h" +#include "source/opt/pass.h" #include "source/opt/tree_iterator.h" #include "source/util/make_unique.h" @@ -278,6 +279,9 @@ BasicBlock* Loop::GetOrCreatePreHeaderBlock() { CFG* cfg = context_->cfg(); loop_header_ = cfg->SplitLoopHeader(loop_header_); + if (loop_header_ == nullptr) { + return nullptr; + } return loop_preheader_; } @@ -920,18 +924,19 @@ Instruction* Loop::FindConditionVariable( return induction; } -bool LoopDescriptor::CreatePreHeaderBlocksIfMissing() { - auto modified = false; +LoopDescriptor::Status LoopDescriptor::CreatePreHeaderBlocksIfMissing() { + bool modified = false; for (auto& loop : *this) { if (!loop.GetPreHeaderBlock()) { + if (!loop.GetOrCreatePreHeaderBlock()) { + return Status::kFailure; + } modified = true; - // TODO(1841): Handle failure to create pre-header. - loop.GetOrCreatePreHeaderBlock(); } } - return modified; + return modified ? Status::kSuccessWithChange : Status::kSuccessWithoutChange; } // Add and remove loops which have been marked for addition and removal to diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_descriptor.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_descriptor.h index d451496..f0775f0 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_descriptor.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_descriptor.h @@ -425,6 +425,9 @@ class LoopDescriptor { using pre_iterator = TreeDFIterator; using const_pre_iterator = TreeDFIterator; + // The status of processing a module. + enum class Status { kSuccessWithChange, kSuccessWithoutChange, kFailure }; + // Creates a loop object for all loops found in |f|. LoopDescriptor(IRContext* context, const Function* f); @@ -506,9 +509,11 @@ class LoopDescriptor { loops_to_add_.emplace_back(std::make_pair(parent, std::move(loop_to_add))); } - // Checks all loops in |this| and will create pre-headers for all loops - // that don't have one. Returns |true| if any blocks were created. - bool CreatePreHeaderBlocksIfMissing(); + // Creates pre-header blocks for all loops in the function that do not have + // one. Returns `LoopDescriptor::Status::kSuccessWithChange` if any change is + // made, `LoopDescriptor::Status::kSuccessWithoutChange` if no change is made, + // and `LoopDescriptor::Status::kFailure` if it fails to create a pre-header. + Status CreatePreHeaderBlocksIfMissing(); // Should be called to preserve the LoopAnalysis after loops have been marked // for addition with AddLoop or MarkLoopForRemoval. diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_fission.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_fission.cpp index 1bbe4ba..fbbee11 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_fission.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_fission.cpp @@ -362,14 +362,19 @@ Loop* LoopFissionImpl::SplitLoop() { LoopUtils util{context_, loop_}; LoopUtils::LoopCloningResult clone_results; Loop* cloned_loop = util.CloneAndAttachLoopToHeader(&clone_results); + if (!cloned_loop) { + return nullptr; + } // Update the OpLoopMerge in the cloned loop. cloned_loop->UpdateLoopMergeInst(); // Add the loop_ to the module. - // TODO(1841): Handle failure to create pre-header. - Function::iterator it = - util.GetFunction()->FindBlock(loop_->GetOrCreatePreHeaderBlock()->id()); + BasicBlock* pre_header = loop_->GetOrCreatePreHeaderBlock(); + if (!pre_header) { + return nullptr; + } + Function::iterator it = util.GetFunction()->FindBlock(pre_header->id()); util.GetFunction()->AddBasicBlocks(clone_results.cloned_bb_.begin(), clone_results.cloned_bb_.end(), ++it); loop_->SetPreHeaderBlock(cloned_loop->GetMergeBlock()); @@ -478,6 +483,9 @@ Pass::Status LoopFissionPass::Process() { if (impl.CanPerformSplit()) { Loop* second_loop = impl.SplitLoop(); + if (!second_loop) { + return Status::Failure; + } changed = true; context()->InvalidateAnalysesExceptFor( IRContext::kAnalysisLoopAnalysis); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_fusion_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_fusion_pass.cpp index 097430f..67dddc0 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_fusion_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_fusion_pass.cpp @@ -22,23 +22,27 @@ namespace spvtools { namespace opt { Pass::Status LoopFusionPass::Process() { - bool modified = false; + Status status = Status::SuccessWithoutChange; Module* module = context()->module(); // Process each function in the module for (Function& f : *module) { - modified |= ProcessFunction(&f); + status = CombineStatus(status, ProcessFunction(&f)); + if (status == Status::Failure) return Status::Failure; } - return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; + return status; } -bool LoopFusionPass::ProcessFunction(Function* function) { +Pass::Status LoopFusionPass::ProcessFunction(Function* function) { LoopDescriptor& ld = *context()->GetLoopDescriptor(function); // If a loop doesn't have a preheader needs then it needs to be created. Make // sure to return Status::SuccessWithChange in that case. - auto modified = ld.CreatePreHeaderBlocksIfMissing(); + bool modified = false; + auto status = ld.CreatePreHeaderBlocksIfMissing(); + if (status == LoopDescriptor::Status::kFailure) return Status::Failure; + modified = status == LoopDescriptor::Status::kSuccessWithChange; // TODO(tremmelg): Could the only loop that |loop| could possibly be fused be // picked out so don't have to check every loop @@ -55,13 +59,13 @@ bool LoopFusionPass::ProcessFunction(Function* function) { fusion.Fuse(); // Recurse, as the current iterators will have been invalidated. ProcessFunction(function); - return true; + return Status::SuccessWithChange; } } } } - return modified; + return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_fusion_pass.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_fusion_pass.h index 9d5b7cc..9c1f567 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_fusion_pass.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_fusion_pass.h @@ -39,7 +39,7 @@ class LoopFusionPass : public Pass { private: // Fuse loops in |function| if compatible, legal and the fused loop won't use // too many registers. - bool ProcessFunction(Function* function); + Status ProcessFunction(Function* function); // The maximum number of registers a fused loop is allowed to use. size_t max_registers_per_loop_; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_peeling.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_peeling.cpp index 25c6db1..e7f3876 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_peeling.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_peeling.cpp @@ -45,7 +45,7 @@ void GetBlocksInPath(uint32_t block, uint32_t entry, size_t LoopPeelingPass::code_grow_threshold_ = 1000; -void LoopPeeling::DuplicateAndConnectLoop( +bool LoopPeeling::DuplicateAndConnectLoop( LoopUtils::LoopCloningResult* clone_results) { CFG& cfg = *context_->cfg(); analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); @@ -53,12 +53,17 @@ void LoopPeeling::DuplicateAndConnectLoop( assert(CanPeelLoop() && "Cannot peel loop!"); std::vector ordered_loop_blocks; - // TODO(1841): Handle failure to create pre-header. BasicBlock* pre_header = loop_->GetOrCreatePreHeaderBlock(); + if (!pre_header) { + return false; + } loop_->ComputeLoopStructuredOrder(&ordered_loop_blocks); cloned_loop_ = loop_utils_.CloneLoop(clone_results, ordered_loop_blocks); + if (!cloned_loop_) { + return false; + } // Add the basic block to the function. Function::iterator it = @@ -146,17 +151,21 @@ void LoopPeeling::DuplicateAndConnectLoop( // Force the creation of a new preheader for the original loop and set it as // the merge block for the cloned loop. - // TODO(1841): Handle failure to create pre-header. - cloned_loop_->SetMergeBlock(loop_->GetOrCreatePreHeaderBlock()); + BasicBlock* new_pre_header = loop_->GetOrCreatePreHeaderBlock(); + if (!new_pre_header) { + return false; + } + cloned_loop_->SetMergeBlock(new_pre_header); + return true; } -void LoopPeeling::InsertCanonicalInductionVariable( +bool LoopPeeling::InsertCanonicalInductionVariable( LoopUtils::LoopCloningResult* clone_results) { if (original_loop_canonical_induction_variable_) { canonical_induction_variable_ = context_->get_def_use_mgr()->GetDef(clone_results->value_map_.at( original_loop_canonical_induction_variable_->result_id())); - return; + return true; } BasicBlock::iterator insert_point = GetClonedLoop()->GetLatchBlock()->tail(); @@ -168,19 +177,25 @@ void LoopPeeling::InsertCanonicalInductionVariable( IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* uint_1_cst = builder.GetIntConstant(1, int_type_->IsSigned()); + if (!uint_1_cst) return false; // Create the increment. // Note that we do "1 + 1" here, one of the operand should the phi // value but we don't have it yet. The operand will be set latter. Instruction* iv_inc = builder.AddIAdd( uint_1_cst->type_id(), uint_1_cst->result_id(), uint_1_cst->result_id()); + if (!iv_inc) return false; builder.SetInsertPoint(&*GetClonedLoop()->GetHeaderBlock()->begin()); + Instruction* initial_value = + builder.GetIntConstant(0, int_type_->IsSigned()); + if (!initial_value) return false; + canonical_induction_variable_ = builder.AddPhi( uint_1_cst->type_id(), - {builder.GetIntConstant(0, int_type_->IsSigned())->result_id(), - GetClonedLoop()->GetPreHeaderBlock()->id(), iv_inc->result_id(), - GetClonedLoop()->GetLatchBlock()->id()}); + {initial_value->result_id(), GetClonedLoop()->GetPreHeaderBlock()->id(), + iv_inc->result_id(), GetClonedLoop()->GetLatchBlock()->id()}); + if (!canonical_induction_variable_) return false; // Connect everything. iv_inc->SetInOperand(0, {canonical_induction_variable_->result_id()}); @@ -191,6 +206,7 @@ void LoopPeeling::InsertCanonicalInductionVariable( if (do_while_form_) { canonical_induction_variable_ = iv_inc; } + return true; } void LoopPeeling::GetIteratorUpdateOperations( @@ -308,7 +324,7 @@ void LoopPeeling::GetIteratingExitValues() { } } -void LoopPeeling::FixExitCondition( +bool LoopPeeling::FixExitCondition( const std::function& condition_builder) { CFG& cfg = *context_->cfg(); @@ -329,7 +345,11 @@ void LoopPeeling::FixExitCondition( --insert_point; } - exit_condition->SetInOperand(0, {condition_builder(&*insert_point)}); + uint32_t new_cond_id = condition_builder(&*insert_point); + if (new_cond_id == 0) { + return false; + } + exit_condition->SetInOperand(0, {new_cond_id}); uint32_t to_continue_block_idx = GetClonedLoop()->IsInsideLoop(exit_condition->GetSingleWordInOperand(1)) @@ -341,6 +361,7 @@ void LoopPeeling::FixExitCondition( // Update def/use manager. context_->get_def_use_mgr()->AnalyzeInstUse(exit_condition); + return true; } BasicBlock* LoopPeeling::CreateBlockBefore(BasicBlock* bb) { @@ -348,10 +369,13 @@ BasicBlock* LoopPeeling::CreateBlockBefore(BasicBlock* bb) { CFG& cfg = *context_->cfg(); assert(cfg.preds(bb->id()).size() == 1 && "More than one predecessor"); - // TODO(1841): Handle id overflow. + uint32_t new_id = context_->TakeNextId(); + if (new_id == 0) { + return nullptr; + } std::unique_ptr new_bb = - MakeUnique(std::unique_ptr(new Instruction( - context_, spv::Op::OpLabel, 0, context_->TakeNextId(), {}))); + MakeUnique(std::unique_ptr( + new Instruction(context_, spv::Op::OpLabel, 0, new_id, {}))); // Update the loop descriptor. Loop* in_loop = (*loop_utils_.GetLoopDescriptor())[bb]; if (in_loop) { @@ -394,8 +418,10 @@ BasicBlock* LoopPeeling::CreateBlockBefore(BasicBlock* bb) { BasicBlock* LoopPeeling::ProtectLoop(Loop* loop, Instruction* condition, BasicBlock* if_merge) { - // TODO(1841): Handle failure to create pre-header. BasicBlock* if_block = loop->GetOrCreatePreHeaderBlock(); + if (!if_block) { + return nullptr; + } // Will no longer be a pre-header because of the if. loop->SetPreHeaderBlock(nullptr); // Kill the branch to the header. @@ -411,48 +437,63 @@ BasicBlock* LoopPeeling::ProtectLoop(Loop* loop, Instruction* condition, return if_block; } -void LoopPeeling::PeelBefore(uint32_t peel_factor) { +bool LoopPeeling::PeelBefore(uint32_t peel_factor) { assert(CanPeelLoop() && "Cannot peel loop"); LoopUtils::LoopCloningResult clone_results; // Clone the loop and insert the cloned one before the loop. - DuplicateAndConnectLoop(&clone_results); + if (!DuplicateAndConnectLoop(&clone_results)) { + return false; + } // Add a canonical induction variable "canonical_induction_variable_". - InsertCanonicalInductionVariable(&clone_results); + if (!InsertCanonicalInductionVariable(&clone_results)) { + return false; + } InstructionBuilder builder( context_, &*cloned_loop_->GetPreHeaderBlock()->tail(), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* factor = builder.GetIntConstant(peel_factor, int_type_->IsSigned()); + if (!factor) return false; Instruction* has_remaining_iteration = builder.AddLessThan( factor->result_id(), loop_iteration_count_->result_id()); + if (!has_remaining_iteration) return false; Instruction* max_iteration = builder.AddSelect( factor->type_id(), has_remaining_iteration->result_id(), factor->result_id(), loop_iteration_count_->result_id()); + if (!max_iteration) return false; // Change the exit condition of the cloned loop to be (exit when become // false): // "canonical_induction_variable_" < min("factor", "loop_iteration_count_") - FixExitCondition([max_iteration, this](Instruction* insert_before_point) { - return InstructionBuilder(context_, insert_before_point, - IRContext::kAnalysisDefUse | - IRContext::kAnalysisInstrToBlockMapping) - .AddLessThan(canonical_induction_variable_->result_id(), - max_iteration->result_id()) - ->result_id(); - }); + if (!FixExitCondition( + [max_iteration, this](Instruction* insert_before_point) { + Instruction* new_cond = + InstructionBuilder(context_, insert_before_point, + IRContext::kAnalysisDefUse | + IRContext::kAnalysisInstrToBlockMapping) + .AddLessThan(canonical_induction_variable_->result_id(), + max_iteration->result_id()); + return new_cond ? new_cond->result_id() : 0; + })) { + return false; + } // "Protect" the second loop: the second loop can only be executed if // |has_remaining_iteration| is true (i.e. factor < loop_iteration_count_). BasicBlock* if_merge_block = loop_->GetMergeBlock(); - loop_->SetMergeBlock(CreateBlockBefore(loop_->GetMergeBlock())); + BasicBlock* new_merge_block = CreateBlockBefore(loop_->GetMergeBlock()); + if (!new_merge_block) return false; + loop_->SetMergeBlock(new_merge_block); // Prevent the second loop from being executed if we already executed all the // required iterations. BasicBlock* if_block = ProtectLoop(loop_, has_remaining_iteration, if_merge_block); + if (!if_block) return false; + // Patch the phi of the merge block. if_merge_block->ForEachPhiInst( [&clone_results, if_block, this](Instruction* phi) { @@ -471,14 +512,17 @@ void LoopPeeling::PeelBefore(uint32_t peel_factor) { context_->InvalidateAnalysesExceptFor( IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisCFG); + return true; } -void LoopPeeling::PeelAfter(uint32_t peel_factor) { +bool LoopPeeling::PeelAfter(uint32_t peel_factor) { assert(CanPeelLoop() && "Cannot peel loop"); LoopUtils::LoopCloningResult clone_results; // Clone the loop and insert the cloned one before the loop. - DuplicateAndConnectLoop(&clone_results); + if (!DuplicateAndConnectLoop(&clone_results)) { + return false; + } // Add a canonical induction variable "canonical_induction_variable_". InsertCanonicalInductionVariable(&clone_results); @@ -488,40 +532,55 @@ void LoopPeeling::PeelAfter(uint32_t peel_factor) { IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); Instruction* factor = builder.GetIntConstant(peel_factor, int_type_->IsSigned()); + if (!factor) return false; Instruction* has_remaining_iteration = builder.AddLessThan( factor->result_id(), loop_iteration_count_->result_id()); + if (!has_remaining_iteration) return false; // Change the exit condition of the cloned loop to be (exit when become // false): // "canonical_induction_variable_" + "factor" < "loop_iteration_count_" - FixExitCondition([factor, this](Instruction* insert_before_point) { - InstructionBuilder cond_builder( - context_, insert_before_point, - IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); - // Build the following check: canonical_induction_variable_ + factor < - // iteration_count - return cond_builder - .AddLessThan(cond_builder - .AddIAdd(canonical_induction_variable_->type_id(), - canonical_induction_variable_->result_id(), - factor->result_id()) - ->result_id(), - loop_iteration_count_->result_id()) - ->result_id(); - }); + if (!FixExitCondition([factor, + this](Instruction* insert_before_point) -> uint32_t { + InstructionBuilder cond_builder( + context_, insert_before_point, + IRContext::kAnalysisDefUse | + IRContext::kAnalysisInstrToBlockMapping); + // Build the following check: canonical_induction_variable_ + factor < + // iteration_count + Instruction* add = cond_builder.AddIAdd( + canonical_induction_variable_->type_id(), + canonical_induction_variable_->result_id(), factor->result_id()); + if (!add) return 0; + Instruction* new_cond = cond_builder.AddLessThan( + add->result_id(), loop_iteration_count_->result_id()); + return new_cond ? new_cond->result_id() : 0; + })) { + return false; + } // "Protect" the first loop: the first loop can only be executed if // factor < loop_iteration_count_. // The original loop's pre-header was the cloned loop merge block. - GetClonedLoop()->SetMergeBlock( - CreateBlockBefore(GetOriginalLoop()->GetPreHeaderBlock())); + BasicBlock* pre_header = GetOriginalLoop()->GetPreHeaderBlock(); + if (!pre_header) { + return false; + } + BasicBlock* new_merge_block = CreateBlockBefore(pre_header); + if (!new_merge_block) { + return false; + } + GetClonedLoop()->SetMergeBlock(new_merge_block); // Use the second loop preheader as if merge block. // Prevent the first loop if only the peeled loop needs it. BasicBlock* if_block = ProtectLoop(cloned_loop_, has_remaining_iteration, GetOriginalLoop()->GetPreHeaderBlock()); + if (!if_block) { + return false; + } // Patch the phi of the header block. // We added an if to enclose the first loop and because the phi node are @@ -529,8 +588,10 @@ void LoopPeeling::PeelAfter(uint32_t peel_factor) { // dominate the preheader. // We had to the preheader (our if merge block) the required phi instruction // and patch the header phi. + bool ok = true; GetOriginalLoop()->GetHeaderBlock()->ForEachPhiInst( - [&clone_results, if_block, this](Instruction* phi) { + [&clone_results, if_block, &ok, this](Instruction* phi) { + if (!ok) return; analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); auto find_value_idx = [](Instruction* phi_inst, Loop* loop) { @@ -554,15 +615,21 @@ void LoopPeeling::PeelAfter(uint32_t peel_factor) { find_value_idx(phi, GetOriginalLoop())), GetClonedLoop()->GetMergeBlock()->id(), cloned_preheader_value, if_block->id()}); + if (!new_phi) { + ok = false; + return; + } phi->SetInOperand(find_value_idx(phi, GetOriginalLoop()), {new_phi->result_id()}); def_use_mgr->AnalyzeInstUse(phi); }); + if (!ok) return false; context_->InvalidateAnalysesExceptFor( IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping | IRContext::kAnalysisLoopAnalysis | IRContext::kAnalysisCFG); + return true; } Pass::Status LoopPeelingPass::Process() { @@ -571,13 +638,19 @@ Pass::Status LoopPeelingPass::Process() { // Process each function in the module for (Function& f : *module) { - modified |= ProcessFunction(&f); + Pass::Status status = ProcessFunction(&f); + if (status == Status::Failure) { + return Status::Failure; + } + if (status == Status::SuccessWithChange) { + modified = true; + } } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } -bool LoopPeelingPass::ProcessFunction(Function* f) { +Pass::Status LoopPeelingPass::ProcessFunction(Function* f) { bool modified = false; LoopDescriptor& loop_descriptor = *context()->GetLoopDescriptor(f); @@ -593,41 +666,56 @@ bool LoopPeelingPass::ProcessFunction(Function* f) { CodeMetrics loop_size; loop_size.Analyze(*loop); - auto try_peel = [&loop_size, &modified, this](Loop* loop_to_peel) -> Loop* { + auto try_peel = [&loop_size, &modified, this]( + Loop* loop_to_peel) -> std::pair { if (!loop_to_peel->IsLCSSA()) { - LoopUtils(context(), loop_to_peel).MakeLoopClosedSSA(); + if (!LoopUtils(context(), loop_to_peel).MakeLoopClosedSSA()) { + return {Pass::Status::Failure, nullptr}; + } } - bool peeled_loop; + Pass::Status status; Loop* still_peelable_loop; - std::tie(peeled_loop, still_peelable_loop) = + std::tie(status, still_peelable_loop) = ProcessLoop(loop_to_peel, &loop_size); - if (peeled_loop) { + if (status == Pass::Status::SuccessWithChange) { modified = true; } - return still_peelable_loop; + return {status, still_peelable_loop}; }; - Loop* still_peelable_loop = try_peel(loop); + Pass::Status status; + Loop* still_peelable_loop; + std::tie(status, still_peelable_loop) = try_peel(loop); + + if (status == Pass::Status::Failure) { + return Pass::Status::Failure; + } + // The pass is working out the maximum factor by which a loop can be peeled. // If the loop can potentially be peeled again, then there is only one // possible direction, so only one call is still needed. if (still_peelable_loop) { - try_peel(loop); + std::tie(status, still_peelable_loop) = try_peel(still_peelable_loop); + if (status == Pass::Status::Failure) { + return Pass::Status::Failure; + } } } - return modified; + return modified ? Pass::Status::SuccessWithChange + : Pass::Status::SuccessWithoutChange; } -std::pair LoopPeelingPass::ProcessLoop(Loop* loop, - CodeMetrics* loop_size) { +std::tuple LoopPeelingPass::ProcessLoop( + Loop* loop, CodeMetrics* loop_size) { ScalarEvolutionAnalysis* scev_analysis = context()->GetScalarEvolutionAnalysis(); // Default values for bailing out. - std::pair bail_out{false, nullptr}; + std::tuple bail_out{Pass::Status::SuccessWithoutChange, + nullptr}; BasicBlock* exit_block = loop->FindConditionBlock(); if (!exit_block) { @@ -744,7 +832,9 @@ std::pair LoopPeelingPass::ProcessLoop(Loop* loop, Loop* extra_opportunity = nullptr; if (direction == PeelDirection::kBefore) { - peeler.PeelBefore(factor); + if (!peeler.PeelBefore(factor)) { + return {Pass::Status::Failure, nullptr}; + } if (stats_) { stats_->peeled_loops_.emplace_back(loop, PeelDirection::kBefore, factor); } @@ -753,7 +843,9 @@ std::pair LoopPeelingPass::ProcessLoop(Loop* loop, extra_opportunity = peeler.GetOriginalLoop(); } } else { - peeler.PeelAfter(factor); + if (!peeler.PeelAfter(factor)) { + return {Pass::Status::Failure, nullptr}; + } if (stats_) { stats_->peeled_loops_.emplace_back(loop, PeelDirection::kAfter, factor); } @@ -763,7 +855,7 @@ std::pair LoopPeelingPass::ProcessLoop(Loop* loop, } } - return {true, extra_opportunity}; + return {Pass::Status::SuccessWithChange, extra_opportunity}; } uint32_t LoopPeelingPass::LoopPeelingInfo::GetFirstLoopInvariantOperand( diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_peeling.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_peeling.h index 2a55fe4..a794793 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_peeling.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_peeling.h @@ -148,11 +148,11 @@ class LoopPeeling { // Moves the execution of the |factor| first iterations of the loop into a // dedicated loop. - void PeelBefore(uint32_t factor); + bool PeelBefore(uint32_t factor); // Moves the execution of the |factor| last iterations of the loop into a // dedicated loop. - void PeelAfter(uint32_t factor); + bool PeelAfter(uint32_t factor); // Returns the cloned loop. Loop* GetClonedLoop() { return cloned_loop_; } @@ -184,19 +184,19 @@ class LoopPeeling { // Duplicate |loop_| and place the new loop before the cloned loop. Iterating // values from the cloned loop are then connected to the original loop as // initializer. - void DuplicateAndConnectLoop(LoopUtils::LoopCloningResult* clone_results); + bool DuplicateAndConnectLoop(LoopUtils::LoopCloningResult* clone_results); // Insert the canonical induction variable into the first loop as a simplified - // counter. - void InsertCanonicalInductionVariable( + // counter. Returns true on success. + bool InsertCanonicalInductionVariable( LoopUtils::LoopCloningResult* clone_results); // Fixes the exit condition of the before loop. The function calls // |condition_builder| to get the condition to use in the conditional branch // of the loop exit. The loop will be exited if the condition evaluate to // true. |condition_builder| takes an Instruction* that represent the - // insertion point. - void FixExitCondition( + // insertion point. Returns true on success. + bool FixExitCondition( const std::function& condition_builder); // Gathers all operations involved in the update of |iterator| into @@ -321,10 +321,14 @@ class LoopPeelingPass : public Pass { ScalarEvolutionAnalysis* scev_analysis_; size_t loop_max_iterations_; }; - // Peel profitable loops in |f|. - bool ProcessFunction(Function* f); - // Peel |loop| if profitable. - std::pair ProcessLoop(Loop* loop, CodeMetrics* loop_size); + // Peel profitable loops in |f|. Returns Pass::Status::Failure if an error + // occurs. + Pass::Status ProcessFunction(Function* f); + // Peel |loop| if profitable. Returns Pass::Status::Failure if an error + // occurs. Returns {Pass::Status::SuccessWithChange, Loop*} if the loop is + // peeled and there is another peeling opportunity. + std::tuple ProcessLoop(Loop* loop, + CodeMetrics* loop_size); static size_t code_grow_threshold_; LoopPeelingStats* stats_; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_unroller.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_unroller.cpp index 2e279a7..468b2ae 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_unroller.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_unroller.cpp @@ -178,7 +178,7 @@ class LoopUnrollerUtilsImpl { // Unroll the |loop| by given |factor| by copying the whole body |factor| // times. The resulting basicblock structure will remain a loop. - void PartiallyUnroll(Loop*, size_t factor); + bool PartiallyUnroll(Loop*, size_t factor); // If partially unrolling the |loop| would leave the loop with too many bodies // for its number of iterations then this method should be used. This method @@ -186,12 +186,12 @@ class LoopUnrollerUtilsImpl { // successor of the original's merge block. The original loop will have its // condition changed to loop over the residual part and the duplicate will be // partially unrolled. The resulting structure will be two loops. - void PartiallyUnrollResidualFactor(Loop* loop, size_t factor); + bool PartiallyUnrollResidualFactor(Loop* loop, size_t factor); // Fully unroll the |loop| by copying the full body by the total number of // loop iterations, folding all conditions, and removing the backedge from the // continue block to the header. - void FullyUnroll(Loop* loop); + bool FullyUnroll(Loop* loop); // Get the ID of the variable in the |phi| paired with |label|. uint32_t GetPhiDefID(const Instruction* phi, uint32_t label) const; @@ -203,7 +203,7 @@ class LoopUnrollerUtilsImpl { // Remove the OpConditionalBranch instruction inside |conditional_block| used // to branch to either exit or continue the loop and replace it with an // unconditional OpBranch to block |new_target|. - void FoldConditionBlock(BasicBlock* condtion_block, uint32_t new_target); + bool FoldConditionBlock(BasicBlock* condtion_block, uint32_t new_target); // Add all blocks_to_add_ to function_ at the |insert_point|. void AddBlocksToFunction(const BasicBlock* insert_point); @@ -211,7 +211,7 @@ class LoopUnrollerUtilsImpl { // Duplicates the |old_loop|, cloning each body and remapping the ids without // removing instructions or changing relative structure. Result will be stored // in |new_loop|. - void DuplicateLoop(Loop* old_loop, Loop* new_loop); + bool DuplicateLoop(Loop* old_loop, Loop* new_loop); inline size_t GetLoopIterationCount() const { return number_of_loop_iterations_; @@ -241,7 +241,7 @@ class LoopUnrollerUtilsImpl { // to old // ids. |loop| is used to identify special loop blocks (header, continue, // etc). - void AssignNewResultIds(BasicBlock* basic_block); + bool AssignNewResultIds(BasicBlock* basic_block); // Using the map built by AssignNewResultIds, replace the uses in |inst| // by the id that the use maps to. @@ -258,18 +258,18 @@ class LoopUnrollerUtilsImpl { // the old |loop| continue block and the new body will link to the |loop| // header via the new continue block. |eliminate_conditions| is used to decide // whether or not to fold all the condition blocks other than the last one. - void CopyBody(Loop* loop, bool eliminate_conditions); + bool CopyBody(Loop* loop, bool eliminate_conditions); // Copy a given |block_to_copy| in the |loop| and record the mapping of the // old/new ids. |preserve_instructions| determines whether or not the method // will modify (other than result_id) instructions which are copied. - void CopyBasicBlock(Loop* loop, const BasicBlock* block_to_copy, + bool CopyBasicBlock(Loop* loop, const BasicBlock* block_to_copy, bool preserve_instructions); // The actual implementation of the unroll step. Unrolls |loop| by given // |factor| by copying the body by |factor| times. Also propagates the // induction variable value throughout the copies. - void Unroll(Loop* loop, size_t factor); + bool Unroll(Loop* loop, size_t factor); // Fills the loop_blocks_inorder_ field with the ordered list of basic blocks // as computed by the method ComputeLoopOrderedBlocks. @@ -376,11 +376,12 @@ void LoopUnrollerUtilsImpl::Init(Loop* loop) { // loop it creates two loops and unrolls one and adjusts the condition on the // other. The end result being that the new loop pair iterates over the correct // number of bodies. -void LoopUnrollerUtilsImpl::PartiallyUnrollResidualFactor(Loop* loop, +bool LoopUnrollerUtilsImpl::PartiallyUnrollResidualFactor(Loop* loop, size_t factor) { - // TODO(1841): Handle id overflow. - std::unique_ptr new_label{new Instruction( - context_, spv::Op::OpLabel, 0, context_->TakeNextId(), {})}; + uint32_t new_label_id = context_->TakeNextId(); + if (new_label_id == 0) return false; + std::unique_ptr new_label{ + new Instruction(context_, spv::Op::OpLabel, 0, new_label_id, {})}; std::unique_ptr new_exit_bb{new BasicBlock(std::move(new_label))}; new_exit_bb->SetParent(&function_); @@ -401,7 +402,9 @@ void LoopUnrollerUtilsImpl::PartiallyUnrollResidualFactor(Loop* loop, // Clear the basic blocks of the new loop. new_loop->ClearBlocks(); - DuplicateLoop(loop, new_loop.get()); + if (!DuplicateLoop(loop, new_loop.get())) { + return false; + } // Add the blocks to the function. AddBlocksToFunction(loop->GetMergeBlock()); @@ -416,7 +419,9 @@ void LoopUnrollerUtilsImpl::PartiallyUnrollResidualFactor(Loop* loop, loop_induction_variable_ = state_.new_phi; // Unroll the new loop by the factor with the usual -1 to account for the // existing block iteration. - Unroll(new_loop.get(), factor); + if (!Unroll(new_loop.get(), factor)) { + return false; + } LinkLastPhisToStart(new_loop.get()); AddBlocksToLoop(new_loop.get()); @@ -460,6 +465,10 @@ void LoopUnrollerUtilsImpl::PartiallyUnrollResidualFactor(Loop* loop, new_constant = builder.GetUintConstant(static_cast(remainder)); } + if (!new_constant) { + return false; + } + uint32_t constant_id = new_constant->result_id(); // Update the condition check. @@ -477,6 +486,9 @@ void LoopUnrollerUtilsImpl::PartiallyUnrollResidualFactor(Loop* loop, for (size_t index = 0; index < new_inductions.size(); ++index) { Instruction* new_induction = new_inductions[index]; Instruction* old_induction = old_inductions[index]; + if (!new_induction || !old_induction) { + return false; + } // Get the index of the loop initalizer, the value coming in from the // preheader. uint32_t initalizer_index = @@ -512,6 +524,7 @@ void LoopUnrollerUtilsImpl::PartiallyUnrollResidualFactor(Loop* loop, loop_descriptor.AddLoop(std::move(new_loop), loop->GetParent()); RemoveDeadInstructions(); + return true; } // Mark this loop as DontUnroll as it will already be unrolled and it may not @@ -528,7 +541,7 @@ void LoopUnrollerUtilsImpl::MarkLoopControlAsDontUnroll(Loop* loop) const { // Duplicate the |loop| body |factor| - 1 number of times while keeping the loop // backedge intact. This will leave the loop with |factor| number of bodies // after accounting for the initial body. -void LoopUnrollerUtilsImpl::Unroll(Loop* loop, size_t factor) { +bool LoopUnrollerUtilsImpl::Unroll(Loop* loop, size_t factor) { // If we unroll a loop partially it will not be safe to unroll it further. // This is due to the current method of calculating the number of loop // iterations. @@ -539,8 +552,11 @@ void LoopUnrollerUtilsImpl::Unroll(Loop* loop, size_t factor) { state_ = LoopUnrollState{loop_induction_variable_, loop->GetLatchBlock(), loop_condition_block_, std::move(inductions)}; for (size_t i = 0; i < factor - 1; ++i) { - CopyBody(loop, true); + if (!CopyBody(loop, true)) { + return false; + } } + return true; } void LoopUnrollerUtilsImpl::RemoveDeadInstructions() { @@ -573,12 +589,16 @@ void LoopUnrollerUtilsImpl::ReplaceInductionUseWithFinalValue(Loop* loop) { // Fully unroll the loop by partially unrolling it by the number of loop // iterations minus one for the body already accounted for. -void LoopUnrollerUtilsImpl::FullyUnroll(Loop* loop) { +bool LoopUnrollerUtilsImpl::FullyUnroll(Loop* loop) { // We unroll the loop by number of iterations in the loop. - Unroll(loop, number_of_loop_iterations_); + if (!Unroll(loop, number_of_loop_iterations_)) { + return false; + } // The first condition block is preserved until now so it can be copied. - FoldConditionBlock(loop_condition_block_, 1); + if (!FoldConditionBlock(loop_condition_block_, 1)) { + return false; + } // Delete the OpLoopMerge and remove the backedge to the header. CloseUnrolledLoop(loop); @@ -602,6 +622,7 @@ void LoopUnrollerUtilsImpl::FullyUnroll(Loop* loop) { context_->InvalidateAnalysesExceptFor( IRContext::Analysis::kAnalysisLoopAnalysis | IRContext::Analysis::kAnalysisDefUse); + return true; } void LoopUnrollerUtilsImpl::KillDebugDeclares(BasicBlock* bb) { @@ -622,10 +643,11 @@ void LoopUnrollerUtilsImpl::KillDebugDeclares(BasicBlock* bb) { // and the id mapping in the state. |preserve_instructions| is used to determine // whether or not this function should edit instructions other than the // |result_id|. -void LoopUnrollerUtilsImpl::CopyBasicBlock(Loop* loop, const BasicBlock* itr, +bool LoopUnrollerUtilsImpl::CopyBasicBlock(Loop* loop, const BasicBlock* itr, bool preserve_instructions) { // Clone the block exactly, including the IDs. BasicBlock* basic_block = itr->Clone(context_); + if (!basic_block) return false; basic_block->SetParent(itr->GetParent()); // We do not want to duplicate DebugDeclare. @@ -633,7 +655,9 @@ void LoopUnrollerUtilsImpl::CopyBasicBlock(Loop* loop, const BasicBlock* itr, // Assign each result a new unique ID and keep a mapping of the old ids to // the new ones. - AssignNewResultIds(basic_block); + if (!AssignNewResultIds(basic_block)) { + return false; + } // If this is the continue block we are copying. if (itr == loop->GetContinueBlock()) { @@ -672,13 +696,16 @@ void LoopUnrollerUtilsImpl::CopyBasicBlock(Loop* loop, const BasicBlock* itr, // Keep tracking the old block via a map. state_.new_blocks[itr->id()] = basic_block; + return true; } -void LoopUnrollerUtilsImpl::CopyBody(Loop* loop, bool eliminate_conditions) { +bool LoopUnrollerUtilsImpl::CopyBody(Loop* loop, bool eliminate_conditions) { // Copy each basic block in the loop, give them new ids, and save state // information. for (const BasicBlock* itr : loop_blocks_inorder_) { - CopyBasicBlock(loop, itr, false); + if (!CopyBasicBlock(loop, itr, false)) { + return false; + } } // Set the previous latch block to point to the new header. @@ -717,7 +744,9 @@ void LoopUnrollerUtilsImpl::CopyBody(Loop* loop, bool eliminate_conditions) { if (eliminate_conditions && state_.new_condition_block != loop_condition_block_) { - FoldConditionBlock(state_.new_condition_block, 1); + if (!FoldConditionBlock(state_.new_condition_block, 1)) { + return false; + } } // Only reference to the header block is the backedge in the latch block, @@ -733,6 +762,7 @@ void LoopUnrollerUtilsImpl::CopyBody(Loop* loop, bool eliminate_conditions) { // Swap the state so the new is now the previous. state_.NextIterationState(); + return true; } uint32_t LoopUnrollerUtilsImpl::GetPhiDefID(const Instruction* phi, @@ -746,7 +776,7 @@ uint32_t LoopUnrollerUtilsImpl::GetPhiDefID(const Instruction* phi, return 0; } -void LoopUnrollerUtilsImpl::FoldConditionBlock(BasicBlock* condition_block, +bool LoopUnrollerUtilsImpl::FoldConditionBlock(BasicBlock* condition_block, uint32_t operand_label) { // Remove the old conditional branch to the merge and continue blocks. Instruction& old_branch = *condition_block->tail(); @@ -763,8 +793,13 @@ void LoopUnrollerUtilsImpl::FoldConditionBlock(BasicBlock* condition_block, IRContext::Analysis::kAnalysisInstrToBlockMapping); Instruction* new_branch = builder.AddBranch(new_target); - if (!lines.empty()) new_branch->AddDebugLine(&lines.back()); + if (!lines.empty()) { + if (!new_branch->AddDebugLine(&lines.back())) { + return false; + } + } new_branch->SetDebugScope(scope); + return true; } void LoopUnrollerUtilsImpl::CloseUnrolledLoop(Loop* loop) { @@ -811,19 +846,24 @@ void LoopUnrollerUtilsImpl::CloseUnrolledLoop(Loop* loop) { } // Uses the first loop to create a copy of the loop with new IDs. -void LoopUnrollerUtilsImpl::DuplicateLoop(Loop* old_loop, Loop* new_loop) { +bool LoopUnrollerUtilsImpl::DuplicateLoop(Loop* old_loop, Loop* new_loop) { std::vector new_block_order; // Copy every block in the old loop. for (const BasicBlock* itr : loop_blocks_inorder_) { - CopyBasicBlock(old_loop, itr, true); + if (!CopyBasicBlock(old_loop, itr, true)) { + return false; + } new_block_order.push_back(blocks_to_add_.back().get()); } // Clone the merge block, give it a new id and record it in the state. BasicBlock* new_merge = old_loop->GetMergeBlock()->Clone(context_); + if (!new_merge) return false; new_merge->SetParent(old_loop->GetMergeBlock()->GetParent()); - AssignNewResultIds(new_merge); + if (!AssignNewResultIds(new_merge)) { + return false; + } state_.new_blocks[old_loop->GetMergeBlock()->id()] = new_merge; // Remap the operands of every instruction in the loop to point to the new @@ -840,6 +880,7 @@ void LoopUnrollerUtilsImpl::DuplicateLoop(Loop* old_loop, Loop* new_loop) { new_loop->SetContinueBlock(state_.new_continue_block); new_loop->SetLatchBlock(state_.new_latch_block); new_loop->SetMergeBlock(new_merge); + return true; } // Whenever the utility copies a block it stores it in a temporary buffer, this @@ -862,13 +903,15 @@ void LoopUnrollerUtilsImpl::AddBlocksToFunction( // Assign all result_ids in |basic_block| instructions to new IDs and preserve // the mapping of new ids to old ones. -void LoopUnrollerUtilsImpl::AssignNewResultIds(BasicBlock* basic_block) { +bool LoopUnrollerUtilsImpl::AssignNewResultIds(BasicBlock* basic_block) { analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); // Label instructions aren't covered by normal traversal of the // instructions. - // TODO(1841): Handle id overflow. uint32_t new_label_id = context_->TakeNextId(); + if (new_label_id == 0) { + return false; + } // Assign a new id to the label. state_.new_inst[basic_block->GetLabelInst()->result_id()] = new_label_id; @@ -888,8 +931,11 @@ void LoopUnrollerUtilsImpl::AssignNewResultIds(BasicBlock* basic_block) { } // Give the instruction a new id. - // TODO(1841): Handle id overflow. - inst.SetResultId(context_->TakeNextId()); + uint32_t new_id = context_->TakeNextId(); + if (new_id == 0) { + return false; + } + inst.SetResultId(new_id); def_use_mgr->AnalyzeInstDef(&inst); // Save the mapping of old_id -> new_id. @@ -901,6 +947,7 @@ void LoopUnrollerUtilsImpl::AssignNewResultIds(BasicBlock* basic_block) { } state_.ids_to_new_inst[inst.result_id()] = &inst; } + return true; } void LoopUnrollerUtilsImpl::RemapOperands(Instruction* inst) { @@ -961,12 +1008,13 @@ void LoopUnrollerUtilsImpl::LinkLastPhisToStart(Loop* loop) const { // Duplicate the |loop| body |factor| number of times while keeping the loop // backedge intact. -void LoopUnrollerUtilsImpl::PartiallyUnroll(Loop* loop, size_t factor) { - Unroll(loop, factor); +bool LoopUnrollerUtilsImpl::PartiallyUnroll(Loop* loop, size_t factor) { + if (!Unroll(loop, factor)) return false; LinkLastPhisToStart(loop); AddBlocksToLoop(loop); AddBlocksToFunction(loop->GetMergeBlock()); RemoveDeadInstructions(); + return true; } /* @@ -1071,7 +1119,9 @@ bool LoopUtils::PartiallyUnroll(size_t factor) { // If the unrolling factor is larger than or the same size as the loop just // fully unroll the loop. if (factor >= unroller.GetLoopIterationCount()) { - unroller.FullyUnroll(loop_); + if (!unroller.FullyUnroll(loop_)) { + return false; + } return true; } @@ -1080,9 +1130,13 @@ bool LoopUtils::PartiallyUnroll(size_t factor) { // remaining part. We add one when calucating the remainder to take into // account the one iteration already in the loop. if (unroller.GetLoopIterationCount() % factor != 0) { - unroller.PartiallyUnrollResidualFactor(loop_, factor); + if (!unroller.PartiallyUnrollResidualFactor(loop_, factor)) { + return false; + } } else { - unroller.PartiallyUnroll(loop_, factor); + if (!unroller.PartiallyUnroll(loop_, factor)) { + return false; + } } return true; @@ -1098,7 +1152,9 @@ bool LoopUtils::FullyUnroll() { loop_->GetHeaderBlock()->GetParent()}; unroller.Init(loop_); - unroller.FullyUnroll(loop_); + if (!unroller.FullyUnroll(loop_)) { + return false; + } return true; } @@ -1131,15 +1187,25 @@ Pass::Status LoopUnroller::Process() { } if (fully_unroll_) { - loop_utils.FullyUnroll(); + if (!loop_utils.FullyUnroll()) { + return Status::Failure; + } + changed = true; } else { - loop_utils.PartiallyUnroll(unroll_factor_); + if (!loop_utils.PartiallyUnroll(unroll_factor_)) { + return Status::Failure; + } + changed = true; } - changed = true; } LD->PostModificationCleanup(); } + if (changed) { + context()->InvalidateAnalysesExceptFor( + IRContext::Analysis::kAnalysisLoopAnalysis); + } + return changed ? Status::SuccessWithChange : Status::SuccessWithoutChange; } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_unswitch_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_unswitch_pass.cpp index 41f1a80..b49f243 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_unswitch_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_unswitch_pass.cpp @@ -92,12 +92,16 @@ class LoopUnswitch { // position |ip|. This function preserves the def/use and instr to block // managers. BasicBlock* CreateBasicBlock(Function::iterator ip) { + uint32_t new_label_id = TakeNextId(); + if (new_label_id == 0) { + return nullptr; + } + analysis::DefUseManager* def_use_mgr = context_->get_def_use_mgr(); - // TODO(1841): Handle id overflow. BasicBlock* bb = &*ip.InsertBefore(std::unique_ptr( new BasicBlock(std::unique_ptr(new Instruction( - context_, spv::Op::OpLabel, 0, context_->TakeNextId(), {}))))); + context_, spv::Op::OpLabel, 0, new_label_id, {}))))); bb->SetParent(function_); def_use_mgr->AnalyzeInstDef(bb->GetLabelInst()); context_->set_instr_block(bb->GetLabelInst(), bb); @@ -135,7 +139,7 @@ class LoopUnswitch { } // Unswitches |loop_|. - void PerformUnswitch() { + bool PerformUnswitch() { assert(CanUnswitchLoop() && "Cannot unswitch if there is not constant condition"); assert(loop_->GetPreHeaderBlock() && "This loop has no pre-header block"); @@ -165,6 +169,9 @@ class LoopUnswitch { if_merge_block ? CreateBasicBlock(FindBasicBlockPosition(if_merge_block)) : nullptr; + if (if_merge_block && !loop_merge_block) { + return false; + } if (loop_merge_block) { // Add the instruction and update managers. InstructionBuilder builder( @@ -174,17 +181,24 @@ class LoopUnswitch { builder.SetInsertPoint(&*loop_merge_block->begin()); cfg.RegisterBlock(loop_merge_block); def_use_mgr->AnalyzeInstDef(loop_merge_block->GetLabelInst()); - // Update CFG. + bool ok = true; if_merge_block->ForEachPhiInst( - [loop_merge_block, &builder, this](Instruction* phi) { + [loop_merge_block, &ok, &builder, this](Instruction* phi) -> bool { Instruction* cloned = phi->Clone(context_); - cloned->SetResultId(TakeNextId()); + uint32_t new_id = TakeNextId(); + if (new_id == 0) { + ok = false; + return false; + } + cloned->SetResultId(new_id); builder.AddInstruction(std::unique_ptr(cloned)); phi->SetInOperand(0, {cloned->result_id()}); phi->SetInOperand(1, {loop_merge_block->id()}); for (uint32_t j = phi->NumInOperands() - 1; j > 1; j--) phi->RemoveInOperand(j); + return true; }); + if (!ok) return false; // Copy the predecessor list (will get invalidated otherwise). std::vector preds = cfg.preds(if_merge_block->id()); for (uint32_t pid : preds) { @@ -227,6 +241,9 @@ class LoopUnswitch { // we need to create a dedicated block for the if. BasicBlock* loop_pre_header = CreateBasicBlock(++FindBasicBlockPosition(if_block)); + if (!loop_pre_header) { + return false; + } InstructionBuilder( context_, loop_pre_header, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping) @@ -308,6 +325,12 @@ class LoopUnswitch { // specific value. original_loop_constant_value = GetValueForDefaultPathForSwitch(iv_condition); + if (!original_loop_constant_value) { + return false; + } + if (!original_loop_constant_value) { + return false; + } for (uint32_t i = 2; i < iv_condition->NumInOperands(); i += 2) { constant_branch.emplace_back( @@ -341,6 +364,9 @@ class LoopUnswitch { Loop* cloned_loop = loop_utils.CloneLoop(&clone_result, ordered_loop_blocks_); + if (!cloned_loop) { + return false; + } specialisation_pair.second = cloned_loop->GetPreHeaderBlock(); //////////////////////////////////// @@ -416,6 +442,7 @@ class LoopUnswitch { context_->InvalidateAnalysesExceptFor( IRContext::Analysis::kAnalysisLoopAnalysis); + return true; } private: @@ -434,10 +461,7 @@ class LoopUnswitch { std::vector ordered_loop_blocks_; // Returns the next usable id for the context. - uint32_t TakeNextId() { - // TODO(1841): Handle id overflow. - return context_->TakeNextId(); - } + uint32_t TakeNextId() { return context_->TakeNextId(); } // Simplifies |loop| assuming the instruction |to_version_insn| takes the // value |cst_value|. |block_range| is an iterator range returning the loop @@ -573,13 +597,15 @@ Pass::Status LoopUnswitchPass::Process() { // Process each function in the module for (Function& f : *module) { - modified |= ProcessFunction(&f); + Pass::Status status = ProcessFunction(&f); + if (status == Status::Failure) return Status::Failure; + if (status == Status::SuccessWithChange) modified = true; } return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } -bool LoopUnswitchPass::ProcessFunction(Function* f) { +Pass::Status LoopUnswitchPass::ProcessFunction(Function* f) { bool modified = false; std::unordered_set processed_loop; @@ -597,17 +623,21 @@ bool LoopUnswitchPass::ProcessFunction(Function* f) { LoopUnswitch unswitcher(context(), f, &loop, &loop_descriptor); while (unswitcher.CanUnswitchLoop()) { if (!loop.IsLCSSA()) { - LoopUtils(context(), &loop).MakeLoopClosedSSA(); + if (!LoopUtils(context(), &loop).MakeLoopClosedSSA()) { + return Status::Failure; + } + } + if (!unswitcher.PerformUnswitch()) { + return Status::Failure; } modified = true; loop_changed = true; - unswitcher.PerformUnswitch(); } if (loop_changed) break; } } - return modified; + return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_unswitch_pass.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_unswitch_pass.h index 4f7295d..66a757f 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_unswitch_pass.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_unswitch_pass.h @@ -34,7 +34,8 @@ class LoopUnswitchPass : public Pass { Pass::Status Process() override; private: - bool ProcessFunction(Function* f); + // Process the given function. + Pass::Status ProcessFunction(Function* f); }; } // namespace opt diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_utils.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_utils.cpp index 20494e1..ced68de 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_utils.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_utils.cpp @@ -68,7 +68,7 @@ class LCSSARewriter { // block. This operation does not update the def/use manager, instead it // records what needs to be updated. The actual update is performed by // UpdateManagers. - void RewriteUse(BasicBlock* bb, Instruction* user, uint32_t operand_index) { + bool RewriteUse(BasicBlock* bb, Instruction* user, uint32_t operand_index) { assert( (user->opcode() != spv::Op::OpPhi || bb != GetParent(user)) && "The root basic block must be the incoming edge if |user| is a phi " @@ -79,9 +79,13 @@ class LCSSARewriter { "phi instruction"); Instruction* new_def = GetOrBuildIncoming(bb->id()); + if (!new_def) { + return false; + } user->SetOperand(operand_index, {new_def->result_id()}); rewritten_.insert(user); + return true; } // In-place update of some managers (avoid full invalidation). @@ -120,6 +124,9 @@ class LCSSARewriter { IRContext::kAnalysisInstrToBlockMapping); Instruction* incoming_phi = builder.AddPhi(def_insn_.type_id(), incomings); + if (!incoming_phi) { + return nullptr; + } rewritten_.insert(incoming_phi); return incoming_phi; @@ -139,6 +146,9 @@ class LCSSARewriter { IRContext::kAnalysisInstrToBlockMapping); Instruction* incoming_phi = builder.AddPhi(def_insn_.type_id(), incomings); + if (!incoming_phi) { + return nullptr; + } rewritten_.insert(incoming_phi); return incoming_phi; @@ -270,7 +280,7 @@ class LCSSARewriter { // Make the set |blocks| closed SSA. The set is closed SSA if all the uses // outside the set are phi instructions in exiting basic block set (hold by // |lcssa_rewriter|). -inline void MakeSetClosedSSA(IRContext* context, Function* function, +inline bool MakeSetClosedSSA(IRContext* context, Function* function, const std::unordered_set& blocks, const std::unordered_set& exit_bb, LCSSARewriter* lcssa_rewriter) { @@ -285,18 +295,18 @@ inline void MakeSetClosedSSA(IRContext* context, Function* function, if (!DominatesAnExit(bb, exit_bb, dom_tree)) continue; for (Instruction& inst : *bb) { LCSSARewriter::UseRewriter rewriter(lcssa_rewriter, inst); - def_use_manager->ForEachUse( + bool success = def_use_manager->WhileEachUse( &inst, [&blocks, &rewriter, &exit_bb, context]( Instruction* use, uint32_t operand_index) { BasicBlock* use_parent = context->get_instr_block(use); assert(use_parent); - if (blocks.count(use_parent->id())) return; + if (blocks.count(use_parent->id())) return true; if (use->opcode() == spv::Op::OpPhi) { // If the use is a Phi instruction and the incoming block is // coming from the loop, then that's consistent with LCSSA form. if (exit_bb.count(use_parent)) { - return; + return true; } else { // That's not an exit block, but the user is a phi instruction. // Consider the incoming branch only. @@ -306,16 +316,20 @@ inline void MakeSetClosedSSA(IRContext* context, Function* function, } // Rewrite the use. Note that this call does not invalidate the // def/use manager. So this operation is safe. - rewriter.RewriteUse(use_parent, use, operand_index); + return rewriter.RewriteUse(use_parent, use, operand_index); }); + if (!success) { + return false; + } rewriter.UpdateManagers(); } } + return true; } } // namespace -void LoopUtils::CreateLoopDedicatedExits() { +bool LoopUtils::CreateLoopDedicatedExits() { Function* function = loop_->GetHeaderBlock()->GetParent(); LoopDescriptor& loop_desc = *context_->GetLoopDescriptor(function); CFG& cfg = *context_->cfg(); @@ -351,10 +365,13 @@ void LoopUtils::CreateLoopDedicatedExits() { assert(insert_pt != function->end() && "Basic Block not found"); // Create the dedicate exit basic block. - // TODO(1841): Handle id overflow. - BasicBlock& exit = *insert_pt.InsertBefore(std::unique_ptr( - new BasicBlock(std::unique_ptr(new Instruction( - context_, spv::Op::OpLabel, 0, context_->TakeNextId(), {}))))); + uint32_t exit_id = context_->TakeNextId(); + if (exit_id == 0) { + return false; + } + BasicBlock& exit = *insert_pt.InsertBefore( + std::unique_ptr(new BasicBlock(std::unique_ptr( + new Instruction(context_, spv::Op::OpLabel, 0, exit_id, {}))))); exit.SetParent(function); // Redirect in loop predecessors to |exit| block. @@ -380,7 +397,7 @@ void LoopUtils::CreateLoopDedicatedExits() { // We also reset the insert point so all instructions are inserted before // the branch. builder.SetInsertPoint(builder.AddBranch(non_dedicate->id())); - non_dedicate->ForEachPhiInst( + bool succeeded = non_dedicate->WhileEachPhiInst( [&builder, &exit, def_use_mgr, this](Instruction* phi) { // New phi operands for this instruction. std::vector new_phi_op; @@ -400,6 +417,9 @@ void LoopUtils::CreateLoopDedicatedExits() { // Build the new phi instruction dedicated exit block. Instruction* exit_phi = builder.AddPhi(phi->type_id(), exit_phi_op); + if (!exit_phi) { + return false; + } // Build the new incoming branch. new_phi_op.push_back(exit_phi->result_id()); new_phi_op.push_back(exit.id()); @@ -412,7 +432,9 @@ void LoopUtils::CreateLoopDedicatedExits() { phi->RemoveInOperand(j); // Update the def/use manager for this |phi|. def_use_mgr->AnalyzeInstUse(phi); + return true; }); + if (!succeeded) return false; // Update the CFG. cfg.RegisterBlock(&exit); cfg.RemoveNonExistingEdges(non_dedicate->id()); @@ -431,10 +453,13 @@ void LoopUtils::CreateLoopDedicatedExits() { PreservedAnalyses | IRContext::kAnalysisCFG | IRContext::Analysis::kAnalysisLoopAnalysis); } + return true; } -void LoopUtils::MakeLoopClosedSSA() { - CreateLoopDedicatedExits(); +bool LoopUtils::MakeLoopClosedSSA() { + if (!CreateLoopDedicatedExits()) { + return false; + } Function* function = loop_->GetHeaderBlock()->GetParent(); CFG& cfg = *context_->cfg(); @@ -452,8 +477,10 @@ void LoopUtils::MakeLoopClosedSSA() { LCSSARewriter lcssa_rewriter(context_, dom_tree, exit_bb, loop_->GetMergeBlock()); - MakeSetClosedSSA(context_, function, loop_->GetBlocks(), exit_bb, - &lcssa_rewriter); + if (!MakeSetClosedSSA(context_, function, loop_->GetBlocks(), exit_bb, + &lcssa_rewriter)) { + return false; + } // Make sure all defs post-dominated by the merge block have their last use no // further than the merge block. @@ -466,14 +493,17 @@ void LoopUtils::MakeLoopClosedSSA() { exit_bb.insert(loop_->GetMergeBlock()); // LCSSARewriter is reusable here only because it forces the creation of a // phi instruction in the merge block. - MakeSetClosedSSA(context_, function, merging_bb_id, exit_bb, - &lcssa_rewriter); + if (!MakeSetClosedSSA(context_, function, merging_bb_id, exit_bb, + &lcssa_rewriter)) { + return false; + } } context_->InvalidateAnalysesExceptFor( IRContext::Analysis::kAnalysisCFG | IRContext::Analysis::kAnalysisDominatorAnalysis | IRContext::Analysis::kAnalysisLoopAnalysis); + return true; } Loop* LoopUtils::CloneLoop(LoopCloningResult* cloning_result) const { @@ -488,12 +518,18 @@ Loop* LoopUtils::CloneLoop(LoopCloningResult* cloning_result) const { Loop* LoopUtils::CloneAndAttachLoopToHeader(LoopCloningResult* cloning_result) { // Clone the loop. - Loop* new_loop = CloneLoop(cloning_result); + Loop* cloned_loop = CloneLoop(cloning_result); + if (!cloned_loop) { + return nullptr; + } // Create a new exit block/label for the new loop. - // TODO(1841): Handle id overflow. - std::unique_ptr new_label{new Instruction( - context_, spv::Op::OpLabel, 0, context_->TakeNextId(), {})}; + uint32_t new_label_id = context_->TakeNextId(); + if (new_label_id == 0) { + return nullptr; + } + std::unique_ptr new_label{ + new Instruction(context_, spv::Op::OpLabel, 0, new_label_id, {})}; std::unique_ptr new_exit_bb{new BasicBlock(std::move(new_label))}; new_exit_bb->SetParent(loop_->GetMergeBlock()->GetParent()); @@ -520,7 +556,7 @@ Loop* LoopUtils::CloneAndAttachLoopToHeader(LoopCloningResult* cloning_result) { } const uint32_t old_header = loop_->GetHeaderBlock()->id(); - const uint32_t new_header = new_loop->GetHeaderBlock()->id(); + const uint32_t new_header = cloned_loop->GetHeaderBlock()->id(); analysis::DefUseManager* def_use = context_->get_def_use_mgr(); def_use->ForEachUse(old_header, @@ -529,22 +565,24 @@ Loop* LoopUtils::CloneAndAttachLoopToHeader(LoopCloningResult* cloning_result) { inst->SetOperand(operand, {new_header}); }); - // TODO(1841): Handle failure to create pre-header. + BasicBlock* pre_header = loop_->GetOrCreatePreHeaderBlock(); + if (!pre_header) { + return nullptr; + } def_use->ForEachUse( - loop_->GetOrCreatePreHeaderBlock()->id(), + pre_header->id(), [new_merge_block, this](Instruction* inst, uint32_t operand) { if (this->loop_->IsInsideLoop(inst)) inst->SetOperand(operand, {new_merge_block}); - }); - new_loop->SetMergeBlock(new_exit_bb.get()); + cloned_loop->SetMergeBlock(new_exit_bb.get()); - new_loop->SetPreHeaderBlock(loop_->GetPreHeaderBlock()); + cloned_loop->SetPreHeaderBlock(loop_->GetPreHeaderBlock()); // Add the new block into the cloned instructions. cloning_result->cloned_bb_.push_back(std::move(new_exit_bb)); - return new_loop; + return cloned_loop; } Loop* LoopUtils::CloneLoop( @@ -561,9 +599,13 @@ Loop* LoopUtils::CloneLoop( // For each basic block in the loop, we clone it and register the mapping // between old and new ids. BasicBlock* new_bb = old_bb->Clone(context_); + if (!new_bb) return nullptr; new_bb->SetParent(&function_); - // TODO(1841): Handle id overflow. - new_bb->GetLabelInst()->SetResultId(context_->TakeNextId()); + uint32_t new_label_id = context_->TakeNextId(); + if (new_label_id == 0) { + return nullptr; + } + new_bb->GetLabelInst()->SetResultId(new_label_id); def_use_mgr->AnalyzeInstDef(new_bb->GetLabelInst()); context_->set_instr_block(new_bb->GetLabelInst(), new_bb); cloning_result->cloned_bb_.emplace_back(new_bb); @@ -578,8 +620,11 @@ Loop* LoopUtils::CloneLoop( new_inst != new_bb->end(); ++new_inst, ++old_inst) { cloning_result->ptr_map_[&*new_inst] = &*old_inst; if (new_inst->HasResultId()) { - // TODO(1841): Handle id overflow. - new_inst->SetResultId(context_->TakeNextId()); + uint32_t new_result_id = context_->TakeNextId(); + if (new_result_id == 0) { + return nullptr; + } + new_inst->SetResultId(new_result_id); cloning_result->value_map_[old_inst->result_id()] = new_inst->result_id(); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_utils.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_utils.h index 70060fc..2c96e9e 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_utils.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/loop_utils.h @@ -95,14 +95,14 @@ class LoopUtils { // // This makes some loop transformations (such as loop unswitch) simpler // (removes the needs to take care of exiting variables). - void MakeLoopClosedSSA(); + bool MakeLoopClosedSSA(); // Create dedicate exit basic block. This ensure all exit basic blocks has the // loop as sole predecessors. // By construction, structured control flow already has a dedicated exit // block. // Preserves: CFG, def/use and instruction to block mapping. - void CreateLoopDedicatedExits(); + bool CreateLoopDedicatedExits(); // Clone |loop_| and remap its instructions. Newly created blocks // will be added to the |cloning_result.cloned_bb_| list, correctly ordered to @@ -114,6 +114,7 @@ class LoopUtils { // The function preserves the def/use, cfg and instr to block analyses. // The cloned loop nest will be added to the loop descriptor and will have // ownership. + // Returns the cloned loop, or nullptr if the loop could not be cloned. Loop* CloneLoop(LoopCloningResult* cloning_result, const std::vector& ordered_loop_blocks) const; // Clone |loop_| and remap its instructions, as above. Overload to compute @@ -121,6 +122,7 @@ class LoopUtils { Loop* CloneLoop(LoopCloningResult* cloning_result) const; // Clone the |loop_| and make the new loop branch to the second loop on exit. + // Returns the cloned loop, or nullptr if the loop could not be cloned. Loop* CloneAndAttachLoopToHeader(LoopCloningResult* cloning_result); // Perform a partial unroll of |loop| by given |factor|. This will copy the diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/merge_return_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/merge_return_pass.cpp index c262ea0..47b0763 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/merge_return_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/merge_return_pass.cpp @@ -58,7 +58,9 @@ Pass::Status MergeReturnPass::Process() { failed = true; } } else { - MergeReturnBlocks(function, return_blocks); + if (!MergeReturnBlocks(function, return_blocks)) { + failed = true; + } } return true; }; @@ -132,7 +134,9 @@ bool MergeReturnPass::ProcessStructured( state_.pop_back(); } - ProcessStructuredBlock(block); + if (!ProcessStructuredBlock(block)) { + return false; + } // Generate state for next block if warranted GenerateState(block); @@ -167,14 +171,20 @@ bool MergeReturnPass::ProcessStructured( // We have not kept the dominator tree up-to-date. // Invalidate it at this point to make sure it will be rebuilt. context()->RemoveDominatorAnalysis(function); - AddNewPhiNodes(); + if (!AddNewPhiNodes()) { + return false; + } return true; } -void MergeReturnPass::CreateReturnBlock() { +bool MergeReturnPass::CreateReturnBlock() { // Create a label for the new return block + uint32_t label_id = TakeNextId(); + if (label_id == 0) { + return false; + } std::unique_ptr return_label( - new Instruction(context(), spv::Op::OpLabel, 0u, TakeNextId(), {})); + new Instruction(context(), spv::Op::OpLabel, 0u, label_id, {})); // Create the new basic block std::unique_ptr return_block( @@ -186,14 +196,20 @@ void MergeReturnPass::CreateReturnBlock() { final_return_block_); assert(final_return_block_->GetParent() == function_ && "The function should have been set when the block was created."); + return true; } -void MergeReturnPass::CreateReturn(BasicBlock* block) { - AddReturnValue(); +bool MergeReturnPass::CreateReturn(BasicBlock* block) { + if (!AddReturnValue()) { + return false; + } if (return_value_) { // Load and return the final return value uint32_t loadId = TakeNextId(); + if (loadId == 0) { + return false; + } block->AddInstruction(MakeUnique( context(), spv::Op::OpLoad, function_->type_id(), loadId, std::initializer_list{ @@ -216,14 +232,21 @@ void MergeReturnPass::CreateReturn(BasicBlock* block) { context()->AnalyzeDefUse(block->terminator()); context()->set_instr_block(block->terminator(), block); } + return true; } -void MergeReturnPass::ProcessStructuredBlock(BasicBlock* block) { +bool MergeReturnPass::ProcessStructuredBlock(BasicBlock* block) { + if (block->tail() == block->end()) { + return true; + } + spv::Op tail_opcode = block->tail()->opcode(); if (tail_opcode == spv::Op::OpReturn || tail_opcode == spv::Op::OpReturnValue) { if (!return_flag_) { - AddReturnFlag(); + if (!AddReturnFlag()) { + return false; + } } } @@ -232,15 +255,20 @@ void MergeReturnPass::ProcessStructuredBlock(BasicBlock* block) { tail_opcode == spv::Op::OpUnreachable) { assert(CurrentState().InBreakable() && "Should be in the placeholder construct."); - BranchToBlock(block, CurrentState().BreakMergeId()); + if (!BranchToBlock(block, CurrentState().BreakMergeId())) { + return false; + } return_blocks_.insert(block->id()); } + return true; } -void MergeReturnPass::BranchToBlock(BasicBlock* block, uint32_t target) { +bool MergeReturnPass::BranchToBlock(BasicBlock* block, uint32_t target) { if (block->tail()->opcode() == spv::Op::OpReturn || block->tail()->opcode() == spv::Op::OpReturnValue) { - RecordReturned(block); + if (!RecordReturned(block)) { + return false; + } RecordReturnValue(block); } @@ -248,7 +276,9 @@ void MergeReturnPass::BranchToBlock(BasicBlock* block, uint32_t target) { if (target_block->GetLoopMergeInst()) { cfg()->SplitLoopHeader(target_block); } - UpdatePhiNodes(block, target_block); + if (!UpdatePhiNodes(block, target_block)) { + return false; + } Instruction* return_inst = block->terminator(); return_inst->SetOpcode(spv::Op::OpBranch); @@ -256,19 +286,26 @@ void MergeReturnPass::BranchToBlock(BasicBlock* block, uint32_t target) { context()->get_def_use_mgr()->AnalyzeInstDefUse(return_inst); new_edges_[target_block].insert(block->id()); cfg()->AddEdge(block->id(), target); + return true; } -void MergeReturnPass::UpdatePhiNodes(BasicBlock* new_source, +bool MergeReturnPass::UpdatePhiNodes(BasicBlock* new_source, BasicBlock* target) { - target->ForEachPhiInst([this, new_source](Instruction* inst) { + bool succeeded = true; + target->ForEachPhiInst([this, new_source, &succeeded](Instruction* inst) { uint32_t undefId = Type2Undef(inst->type_id()); + if (undefId == 0) { + succeeded = false; + return; + } inst->AddOperand({SPV_OPERAND_TYPE_ID, {undefId}}); inst->AddOperand({SPV_OPERAND_TYPE_ID, {new_source->id()}}); context()->UpdateDefUse(inst); }); + return succeeded; } -void MergeReturnPass::CreatePhiNodesForInst(BasicBlock* merge_block, +bool MergeReturnPass::CreatePhiNodesForInst(BasicBlock* merge_block, Instruction& inst) { DominatorAnalysis* dom_tree = context()->GetDominatorAnalysis(merge_block->GetParent()); @@ -302,7 +339,7 @@ void MergeReturnPass::CreatePhiNodesForInst(BasicBlock* merge_block, }); if (users_to_update.empty()) { - return; + return true; } // There is at least one values that needs to be replaced. @@ -346,6 +383,9 @@ void MergeReturnPass::CreatePhiNodesForInst(BasicBlock* merge_block, if (regenerateInstruction) { std::unique_ptr regen_inst(inst.Clone(context())); uint32_t new_id = TakeNextId(); + if (new_id == 0) { + return false; + } regen_inst->SetResultId(new_id); Instruction* insert_pos = &*merge_block->begin(); while (insert_pos->opcode() == spv::Op::OpPhi) { @@ -355,18 +395,31 @@ void MergeReturnPass::CreatePhiNodesForInst(BasicBlock* merge_block, get_def_use_mgr()->AnalyzeInstDefUse(new_phi); context()->set_instr_block(new_phi, merge_block); - new_phi->ForEachInId([dom_tree, merge_block, this](uint32_t* use_id) { + bool succeeded = true; + new_phi->ForEachInId([dom_tree, merge_block, this, + &succeeded](uint32_t* use_id) { + if (!succeeded) { + return; + } Instruction* use = get_def_use_mgr()->GetDef(*use_id); BasicBlock* use_bb = context()->get_instr_block(use); if (use_bb != nullptr && !dom_tree->Dominates(use_bb, merge_block)) { - CreatePhiNodesForInst(merge_block, *use); + if (!CreatePhiNodesForInst(merge_block, *use)) { + succeeded = false; + } } }); + if (!succeeded) { + return false; + } } else { InstructionBuilder builder( context(), &*merge_block->begin(), IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); new_phi = builder.AddPhi(inst.type_id(), phi_operands); + if (new_phi == nullptr) { + return false; + } } uint32_t result_of_phi = new_phi->result_id(); @@ -380,6 +433,7 @@ void MergeReturnPass::CreatePhiNodesForInst(BasicBlock* merge_block, context()->AnalyzeUses(user); } } + return true; } bool MergeReturnPass::PredicateBlocks( @@ -472,6 +526,9 @@ bool MergeReturnPass::BreakFromConstruct( cfg()->RemoveSuccessorEdges(block); auto old_body_id = TakeNextId(); + if (old_body_id == 0) { + return false; + } BasicBlock* old_body = block->SplitBasicBlock(context(), old_body_id, iter); predicated->insert(old_body); @@ -508,8 +565,11 @@ bool MergeReturnPass::BreakFromConstruct( analysis::Bool bool_type; uint32_t bool_id = context()->get_type_mgr()->GetId(&bool_type); assert(bool_id != 0); - uint32_t load_id = - builder.AddLoad(bool_id, return_flag_->result_id())->result_id(); + Instruction* load_inst = builder.AddLoad(bool_id, return_flag_->result_id()); + if (load_inst == nullptr) { + return false; + } + uint32_t load_id = load_inst->result_id(); // 2. Branch to |merge_block| (true) or |old_body| (false) builder.AddConditionalBranch(load_id, merge_block->id(), old_body->id(), @@ -522,7 +582,9 @@ bool MergeReturnPass::BreakFromConstruct( } // 3. Update OpPhi instructions in |merge_block|. - UpdatePhiNodes(block, merge_block); + if (!UpdatePhiNodes(block, merge_block)) { + return false; + } // 4. Update the CFG. We do this after updating the OpPhi instructions // because |UpdatePhiNodes| assumes the edge from |block| has not been added @@ -535,10 +597,10 @@ bool MergeReturnPass::BreakFromConstruct( return true; } -void MergeReturnPass::RecordReturned(BasicBlock* block) { +bool MergeReturnPass::RecordReturned(BasicBlock* block) { if (block->tail()->opcode() != spv::Op::OpReturn && block->tail()->opcode() != spv::Op::OpReturnValue) - return; + return true; assert(return_flag_ && "Did not generate the return flag variable."); @@ -551,6 +613,9 @@ void MergeReturnPass::RecordReturned(BasicBlock* block) { const analysis::Constant* true_const = const_mgr->GetConstant(bool_type, {true}); constant_true_ = const_mgr->GetDefiningInstruction(true_const); + if (!constant_true_) { + return false; + } context()->UpdateDefUse(constant_true_); } @@ -564,6 +629,7 @@ void MergeReturnPass::RecordReturned(BasicBlock* block) { &*block->tail().InsertBefore(std::move(return_store)); context()->set_instr_block(store_inst, block); context()->AnalyzeDefUse(store_inst); + return true; } void MergeReturnPass::RecordReturnValue(BasicBlock* block) { @@ -587,18 +653,21 @@ void MergeReturnPass::RecordReturnValue(BasicBlock* block) { context()->AnalyzeDefUse(store_inst); } -void MergeReturnPass::AddReturnValue() { - if (return_value_) return; +bool MergeReturnPass::AddReturnValue() { + if (return_value_) return true; uint32_t return_type_id = function_->type_id(); if (get_def_use_mgr()->GetDef(return_type_id)->opcode() == spv::Op::OpTypeVoid) - return; + return true; uint32_t return_ptr_type = context()->get_type_mgr()->FindPointerToType( return_type_id, spv::StorageClass::Function); uint32_t var_id = TakeNextId(); + if (var_id == 0) { + return false; + } std::unique_ptr returnValue( new Instruction(context(), spv::Op::OpVariable, return_ptr_type, var_id, std::initializer_list{ @@ -614,27 +683,44 @@ void MergeReturnPass::AddReturnValue() { context()->get_decoration_mgr()->CloneDecorations( function_->result_id(), var_id, {spv::Decoration::RelaxedPrecision}); + return true; } -void MergeReturnPass::AddReturnFlag() { - if (return_flag_) return; +bool MergeReturnPass::AddReturnFlag() { + if (return_flag_) return true; analysis::TypeManager* type_mgr = context()->get_type_mgr(); analysis::ConstantManager* const_mgr = context()->get_constant_mgr(); analysis::Bool temp; uint32_t bool_id = type_mgr->GetTypeInstruction(&temp); + if (bool_id == 0) { + return false; + } analysis::Bool* bool_type = type_mgr->GetType(bool_id)->AsBool(); const analysis::Constant* false_const = const_mgr->GetConstant(bool_type, {false}); - uint32_t const_false_id = - const_mgr->GetDefiningInstruction(false_const)->result_id(); + Instruction* false_inst = const_mgr->GetDefiningInstruction(false_const); + if (false_inst == nullptr) { + return false; + } + uint32_t const_false_id = false_inst->result_id(); uint32_t bool_ptr_id = type_mgr->FindPointerToType(bool_id, spv::StorageClass::Function); + if (bool_ptr_id == 0) { + return false; + ; + } + uint32_t var_id = TakeNextId(); + + if (var_id == 0) { + return false; + } + std::unique_ptr returnFlag(new Instruction( context(), spv::Op::OpVariable, bool_ptr_id, var_id, std::initializer_list{{SPV_OPERAND_TYPE_STORAGE_CLASS, @@ -648,6 +734,7 @@ void MergeReturnPass::AddReturnFlag() { return_flag_ = &*entry_block->begin(); context()->AnalyzeDefUse(return_flag_); context()->set_instr_block(return_flag_, entry_block); + return true; } std::vector MergeReturnPass::CollectReturnBlocks( @@ -663,14 +750,16 @@ std::vector MergeReturnPass::CollectReturnBlocks( return return_blocks; } -void MergeReturnPass::MergeReturnBlocks( +bool MergeReturnPass::MergeReturnBlocks( Function* function, const std::vector& return_blocks) { if (return_blocks.size() <= 1) { // No work to do. - return; + return true; } - CreateReturnBlock(); + if (!CreateReturnBlock()) { + return false; + } uint32_t return_id = final_return_block_->id(); auto ret_block_iter = --function->end(); // Create the PHI for the merged block (if necessary). @@ -687,6 +776,9 @@ void MergeReturnPass::MergeReturnBlocks( if (!phi_ops.empty()) { // Need a PHI node to select the correct return value. uint32_t phi_result_id = TakeNextId(); + if (phi_result_id == 0) { + return false; + } uint32_t phi_type_id = function->type_id(); std::unique_ptr phi_inst(new Instruction( context(), spv::Op::OpPhi, phi_type_id, phi_result_id, phi_ops)); @@ -718,18 +810,22 @@ void MergeReturnPass::MergeReturnBlocks( } get_def_use_mgr()->AnalyzeInstDefUse(ret_block_iter->GetLabelInst()); + return true; } -void MergeReturnPass::AddNewPhiNodes() { +bool MergeReturnPass::AddNewPhiNodes() { std::list order; cfg()->ComputeStructuredOrder(function_, &*function_->begin(), &order); for (BasicBlock* bb : order) { - AddNewPhiNodes(bb); + if (!AddNewPhiNodes(bb)) { + return false; + } } + return true; } -void MergeReturnPass::AddNewPhiNodes(BasicBlock* bb) { +bool MergeReturnPass::AddNewPhiNodes(BasicBlock* bb) { // New phi nodes are needed for any id whose definition used to dominate |bb|, // but no longer dominates |bb|. These are found by walking the dominator // tree starting at the original immediate dominator of |bb| and ending at its @@ -747,16 +843,19 @@ void MergeReturnPass::AddNewPhiNodes(BasicBlock* bb) { BasicBlock* dominator = dom_tree->ImmediateDominator(bb); if (dominator == nullptr) { - return; + return true; } BasicBlock* current_bb = context()->get_instr_block(original_dominator_[bb]); while (current_bb != nullptr && current_bb != dominator) { for (Instruction& inst : *current_bb) { - CreatePhiNodesForInst(bb, inst); + if (!CreatePhiNodesForInst(bb, inst)) { + return false; + } } current_bb = dom_tree->ImmediateDominator(current_bb); } + return true; } void MergeReturnPass::RecordImmediateDominators(Function* function) { @@ -781,8 +880,12 @@ void MergeReturnPass::InsertAfterElement(BasicBlock* element, } bool MergeReturnPass::AddSingleCaseSwitchAroundFunction() { - CreateReturnBlock(); - CreateReturn(final_return_block_); + if (!CreateReturnBlock()) { + return false; + } + if (!CreateReturn(final_return_block_)) { + return false; + } if (context()->AreAnalysesValid(IRContext::kAnalysisCFG)) { cfg()->RegisterBlock(final_return_block_); @@ -828,15 +931,32 @@ BasicBlock* MergeReturnPass::CreateContinueTarget(uint32_t header_label_id) { bool MergeReturnPass::CreateSingleCaseSwitch(BasicBlock* merge_target) { // Insert the switch before any code is run. We have to split the entry - // block to make sure the OpVariable instructions remain in the entry block. + // block to make sure the OpVariable instructions and DebugFunctionDefinition + // instructions remain in the entry block. BasicBlock* start_block = &*function_->begin(); auto split_pos = start_block->begin(); while (split_pos->opcode() == spv::Op::OpVariable) { ++split_pos; } + uint32_t new_block_id = TakeNextId(); + if (new_block_id == 0) { + return false; + } BasicBlock* old_block = - start_block->SplitBasicBlock(context(), TakeNextId(), split_pos); + start_block->SplitBasicBlock(context(), new_block_id, split_pos); + + // Find DebugFunctionDefinition inst in the old block, and if we can find it, + // move it to the entry block. Since DebugFunctionDefinition is not necessary + // after OpVariable inst, we have to traverse the whole block to find it. + for (auto pos = old_block->begin(); pos != old_block->end(); ++pos) { + if (pos->GetShader100DebugOpcode() == + NonSemanticShaderDebugInfo100DebugFunctionDefinition) { + start_block->AddInstruction(MakeUnique(*pos)); + pos.Erase(); + break; + } + } // Add the switch to the end of the entry block. InstructionBuilder builder( diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/merge_return_pass.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/merge_return_pass.h index d15db2f..d83ffc3 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/merge_return_pass.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/merge_return_pass.h @@ -149,8 +149,9 @@ class MergeReturnPass : public MemPass { // Creates a new basic block with a single return. If |function| returns a // value, a phi node is created to select the correct value to return. - // Replaces old returns with an unconditional branch to the new block. - void MergeReturnBlocks(Function* function, + // Replaces old returns with an unconditional branch to the new block. Returns + // true if successful. + bool MergeReturnBlocks(Function* function, const std::vector& returnBlocks); // Generate and push new control flow state if |block| contains a merge. @@ -172,21 +173,22 @@ class MergeReturnPass : public MemPass { // // Note this will break the semantics. To fix this, PredicateBlock will have // to be called on the merge block the branch targets. - void ProcessStructuredBlock(BasicBlock* block); + bool ProcessStructuredBlock(BasicBlock* block); // Creates a variable used to store whether or not the control flow has // traversed a block that used to have a return. A pointer to the instruction - // declaring the variable is stored in |return_flag_|. - void AddReturnFlag(); + // declaring the variable is stored in |return_flag_|. Returns true if it + // succeeds. + bool AddReturnFlag(); // Creates the variable used to store the return value when passing through - // a block that use to contain an OpReturnValue. - void AddReturnValue(); + // a block that use to contain an OpReturnValue. Returns true if it succeeds. + bool AddReturnValue(); - // Adds a store that stores true to |return_flag_| immediately before the - // terminator of |block|. It is assumed that |AddReturnFlag| has already been - // called. - void RecordReturned(BasicBlock* block); + // Records that |block| used to be a return. This is done by adding an + // instruction to store true to the |return_flag_|. Returns true if it + // succeeds. + bool RecordReturned(BasicBlock* block); // Adds an instruction that stores the value being returned in the // OpReturnValue in |block|. The value is stored to |return_value_|, and the @@ -197,10 +199,10 @@ class MergeReturnPass : public MemPass { // have already been called to create the variable to store to. void RecordReturnValue(BasicBlock* block); - // Adds an unconditional branch in |block| that branches to |target|. It also - // adds stores to |return_flag_| and |return_value_| as needed. - // |AddReturnFlag| and |AddReturnValue| must have already been called. - void BranchToBlock(BasicBlock* block, uint32_t target); + // Replaces the terminator of |block| with a branch to |target|. If the + // terminator was a return, it will first call RecordReturned and + // RecordReturnValue. Returns true if it succeeds. + bool BranchToBlock(BasicBlock* block, uint32_t target); // For every basic block that is reachable from |return_block|, extra code is // added to jump around any code that should not be executed because the @@ -231,38 +233,35 @@ class MergeReturnPass : public MemPass { // Add an |OpReturn| or |OpReturnValue| to the end of |block|. If an // |OpReturnValue| is needed, the return value is loaded from |return_value_|. - void CreateReturn(BasicBlock* block); + // Returns true if successful. + bool CreateReturn(BasicBlock* block); // Creates a block at the end of the function that will become the single // return block at the end of the pass. - void CreateReturnBlock(); + bool CreateReturnBlock(); - // Creates a Phi node in |merge_block| for the result of |inst|. - // Any uses of the result of |inst| that are no longer - // dominated by |inst|, are replaced with the result of the new |OpPhi| - // instruction. - void CreatePhiNodesForInst(BasicBlock* merge_block, Instruction& inst); + // For each use of |inst| that is no longer dominated by |inst|, a phi node + // is created in |merge_block|. The original use is replaced by the result + // of the phi node. Returns true if it succeeds. + bool CreatePhiNodesForInst(BasicBlock* merge_block, Instruction& inst); - // Add new phi nodes for any id that no longer dominate all of it uses. A phi - // node is added to a block |bb| for an id if the id is defined between the - // original immediate dominator of |bb| and its new immediate dominator. It - // is assumed that at this point there are no unreachable blocks in the - // control flow graph. - void AddNewPhiNodes(); + // Adds new phi nodes as needed to the function. This is necessary because + // adding the predication code can change the dominator tree. Returns false + // if there is a failure. + bool AddNewPhiNodes(); - // Creates any new phi nodes that are needed in |bb|. |AddNewPhiNodes| must - // have already been called on the original dominators of |bb|. - void AddNewPhiNodes(BasicBlock* bb); + // Adds new phi nodes to |bb| as needed. This is necessary because adding + // the predication code can change the dominator tree. Returns false if + // there is a failure. + bool AddNewPhiNodes(BasicBlock* bb); // Records the terminator of immediate dominator for every basic block in // |function|. void RecordImmediateDominators(Function* function); - // Modifies existing OpPhi instruction in |target| block to account for the - // new edge from |new_source|. The value for that edge will be an Undef. - // - // The CFG must not include the edge from |new_source| to |target| yet. - void UpdatePhiNodes(BasicBlock* new_source, BasicBlock* target); + // For each OpPhi instruction in |target|, this function adds an operand for + // |new_source|. The value will be OpUndef. Returns true if it succeeds. + bool UpdatePhiNodes(BasicBlock* new_source, BasicBlock* target); StructuredControlState& CurrentState() { return state_.back(); } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/module.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/module.cpp index a9710c6..ba0bcce 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/module.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/module.cpp @@ -93,6 +93,7 @@ void Module::ForEachInst(const std::function& f, if (sampled_image_address_mode_) sampled_image_address_mode_->ForEachInst(f, run_on_debug_line_insts); DELEGATE(entry_points_); + DELEGATE(graph_entry_points_); DELEGATE(execution_modes_); DELEGATE(debugs1_); DELEGATE(debugs2_); @@ -104,6 +105,10 @@ void Module::ForEachInst(const std::function& f, i->ForEachInst(f, run_on_debug_line_insts, /* run_on_non_semantic_insts = */ true); } + for (auto& g : graphs_) { + g->ForEachInst(f, run_on_debug_line_insts, + /* run_on_non_semantic_insts = */ true); + } #undef DELEGATE } @@ -132,6 +137,12 @@ void Module::ForEachInst(const std::function& f, f, run_on_debug_line_insts, /* run_on_non_semantic_insts = */ true); } + for (auto& i : graph_entry_points_) DELEGATE(i); + for (auto& i : graphs_) { + static_cast(i.get())->ForEachInst( + f, run_on_debug_line_insts, + /* run_on_non_semantic_insts = */ true); + } if (run_on_debug_line_insts) { for (auto& i : trailing_dbg_line_info_) DELEGATE(i); } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/module.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/module.h index 98c16dc..1bb1c3c 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/module.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/module.h @@ -23,6 +23,7 @@ #include #include "source/opt/function.h" +#include "source/opt/graph.h" #include "source/opt/instruction.h" #include "source/opt/iterator.h" @@ -48,6 +49,8 @@ class Module { using const_iterator = UptrVectorIterator; using inst_iterator = InstructionList::iterator; using const_inst_iterator = InstructionList::const_iterator; + using graph_iterator = UptrVectorIterator; + using const_graph_iterator = UptrVectorIterator; // Creates an empty module with zero'd header. Module() : header_({}), contains_debug_info_(false) {} @@ -90,6 +93,9 @@ class Module { // Appends an entry point instruction to this module. inline void AddEntryPoint(std::unique_ptr e); + // Appends a graph entry point instruction to this module. + inline void AddGraphEntryPoint(std::unique_ptr e); + // Appends an execution mode instruction to this module. inline void AddExecutionMode(std::unique_ptr e); @@ -126,6 +132,9 @@ class Module { // Appends a function to this module. inline void AddFunction(std::unique_ptr f); + // Appends a graph to this module. + inline void AddGraph(std::unique_ptr g); + // Sets |contains_debug_info_| as true. inline void SetContainsDebugInfo(); inline bool ContainsDebugInfo() { return contains_debug_info_; } @@ -220,6 +229,10 @@ class Module { inline IteratorRange entry_points(); inline IteratorRange entry_points() const; + // Iterators for graph entry point instructions contained in this module + inline IteratorRange graph_entry_points(); + inline IteratorRange graph_entry_points() const; + // Iterators for execution_modes instructions contained in this module. inline inst_iterator execution_mode_begin(); inline inst_iterator execution_mode_end(); @@ -252,6 +265,9 @@ class Module { inline const_iterator cbegin() const; inline const_iterator cend() const; + // Iterators for graphs contained in this module. + inline const std::vector>& graphs() const; + // Invokes function |f| on all instructions in this module, and optionally on // the debug line instructions that precede them. void ForEachInst(const std::function& f, @@ -306,6 +322,7 @@ class Module { // A module can only have one optional sampled image addressing mode std::unique_ptr sampled_image_address_mode_; InstructionList entry_points_; + InstructionList graph_entry_points_; InstructionList execution_modes_; InstructionList debugs1_; InstructionList debugs2_; @@ -315,6 +332,7 @@ class Module { // Type declarations, constants, and global variable declarations. InstructionList types_values_; std::vector> functions_; + std::vector> graphs_; // If the module ends with Op*Line instruction, they will not be attached to // any instruction. We record them here, so they will not be lost. @@ -351,6 +369,10 @@ inline void Module::AddEntryPoint(std::unique_ptr e) { entry_points_.push_back(std::move(e)); } +inline void Module::AddGraphEntryPoint(std::unique_ptr e) { + graph_entry_points_.push_back(std::move(e)); +} + inline void Module::AddExecutionMode(std::unique_ptr e) { execution_modes_.push_back(std::move(e)); } @@ -392,6 +414,10 @@ inline void Module::AddFunction(std::unique_ptr f) { functions_.emplace_back(std::move(f)); } +inline void Module::AddGraph(std::unique_ptr g) { + graphs_.emplace_back(std::move(g)); +} + inline void Module::SetContainsDebugInfo() { contains_debug_info_ = true; } inline Module::inst_iterator Module::capability_begin() { @@ -482,6 +508,15 @@ inline IteratorRange Module::entry_points() const { return make_range(entry_points_.begin(), entry_points_.end()); } +inline IteratorRange Module::graph_entry_points() { + return make_range(graph_entry_points_.begin(), graph_entry_points_.end()); +} + +inline IteratorRange Module::graph_entry_points() + const { + return make_range(graph_entry_points_.begin(), graph_entry_points_.end()); +} + inline Module::inst_iterator Module::execution_mode_begin() { return execution_modes_.begin(); } @@ -544,6 +579,10 @@ inline IteratorRange Module::types_values() const { return make_range(types_values_.begin(), types_values_.end()); } +inline const std::vector>& Module::graphs() const { + return graphs_; +} + inline Module::const_iterator Module::cbegin() const { return const_iterator(&functions_, functions_.cbegin()); } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/optimizer.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/optimizer.cpp index aedca99..1380204 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/optimizer.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/optimizer.cpp @@ -641,6 +641,8 @@ bool Optimizer::RegisterPassFromFlag(const std::string& flag, RegisterPass(CreateSplitCombinedImageSamplerPass()); } else if (pass_name == "resolve-binding-conflicts") { RegisterPass(CreateResolveBindingConflictsPass()); + } else if (pass_name == "canonicalize-ids") { + RegisterPass(CreateCanonicalizeIdsPass()); } else { Errorf(consumer(), nullptr, {}, "Unknown flag '--%s'. Use --help for a list of valid flags", @@ -1202,6 +1204,11 @@ Optimizer::PassToken CreateResolveBindingConflictsPass() { MakeUnique()); } +Optimizer::PassToken CreateCanonicalizeIdsPass() { + return MakeUnique( + MakeUnique()); +} + } // namespace spvtools extern "C" { diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/pass.cpp index 0f260e2..08d76b5 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/pass.cpp @@ -114,6 +114,7 @@ uint32_t Pass::GenerateCopy(Instruction* object_to_copy, uint32_t new_type_id, assert(length_const->AsIntConstant()); uint32_t array_length = length_const->AsIntConstant()->GetU32(); for (uint32_t i = 0; i < array_length; i++) { + // TODO(1841): Handle id overflow. Instruction* extract = ir_builder.AddCompositeExtract( original_element_type_id, object_to_copy->result_id(), {i}); uint32_t new_id = @@ -132,6 +133,7 @@ uint32_t Pass::GenerateCopy(Instruction* object_to_copy, uint32_t new_type_id, for (uint32_t i = 0; i < original_type->NumInOperands(); i++) { uint32_t orig_member_type_id = original_type->GetSingleWordInOperand(i); uint32_t new_member_type_id = new_type->GetSingleWordInOperand(i); + // TODO(1841): Handle id overflow. Instruction* extract = ir_builder.AddCompositeExtract( orig_member_type_id, object_to_copy->result_id(), {i}); uint32_t new_id = diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/passes.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/passes.h index 6c32978..d005377 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/passes.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/passes.h @@ -21,6 +21,7 @@ #include "source/opt/amd_ext_to_khr.h" #include "source/opt/analyze_live_input_pass.h" #include "source/opt/block_merge_pass.h" +#include "source/opt/canonicalize_ids_pass.h" #include "source/opt/ccp_pass.h" #include "source/opt/cfg_cleanup_pass.h" #include "source/opt/code_sink.h" diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/propagator.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/propagator.cpp index 9cd6174..67f9132 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/propagator.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/propagator.cpp @@ -84,16 +84,19 @@ bool SSAPropagator::SetStatus(Instruction* inst, PropStatus status) { return status_changed; } -bool SSAPropagator::Simulate(Instruction* instr) { +Pass::Status SSAPropagator::Simulate(Instruction* instr) { bool changed = false; // Don't bother visiting instructions that should not be simulated again. if (!ShouldSimulateAgain(instr)) { - return changed; + return Pass::Status::SuccessWithoutChange; } BasicBlock* dest_bb = nullptr; PropStatus status = visit_fn_(instr, &dest_bb); + if (status == SSAPropagator::kFailed) { + return Pass::Status::Failure; + } bool status_changed = SetStatus(instr, status); if (status == kVarying) { @@ -112,7 +115,7 @@ bool SSAPropagator::Simulate(Instruction* instr) { AddControlEdge(e); } } - return false; + return Pass::Status::SuccessWithoutChange; } else if (status == kInteresting) { // Add the SSA edges coming out of this instruction if the propagation // status has changed. @@ -169,12 +172,13 @@ bool SSAPropagator::Simulate(Instruction* instr) { DontSimulateAgain(instr); } - return changed; + return changed ? Pass::Status::SuccessWithChange + : Pass::Status::SuccessWithoutChange; } -bool SSAPropagator::Simulate(BasicBlock* block) { +Pass::Status SSAPropagator::Simulate(BasicBlock* block) { if (block == ctx_->cfg()->pseudo_exit_block()) { - return false; + return Pass::Status::SuccessWithoutChange; } // Always simulate Phi instructions, even if we have simulated this block @@ -182,17 +186,29 @@ bool SSAPropagator::Simulate(BasicBlock* block) { // incoming edges. When those edges are marked executable, the corresponding // operand can be simulated. bool changed = false; - block->ForEachPhiInst( - [&changed, this](Instruction* instr) { changed |= Simulate(instr); }); + bool succeeded = + block->WhileEachPhiInst([&changed, this](Instruction* instr) { + auto Status = Simulate(instr); + if (Status == Pass::Status::Failure) return false; + changed |= Status == Pass::Status::SuccessWithChange; + return true; + }); + if (!succeeded) { + return Pass::Status::Failure; + } // If this is the first time this block is being simulated, simulate every // statement in it. if (!BlockHasBeenSimulated(block)) { - block->ForEachInst([this, &changed](Instruction* instr) { - if (instr->opcode() != spv::Op::OpPhi) { - changed |= Simulate(instr); - } + succeeded = block->WhileEachInst([&changed, this](Instruction* instr) { + auto Status = Simulate(instr); + if (Status == Pass::Status::Failure) return false; + changed |= Status == Pass::Status::SuccessWithChange; + return true; }); + if (!succeeded) { + return Pass::Status::Failure; + } MarkBlockSimulated(block); @@ -203,7 +219,8 @@ bool SSAPropagator::Simulate(BasicBlock* block) { } } - return changed; + return changed ? Pass::Status::SuccessWithChange + : Pass::Status::SuccessWithoutChange; } void SSAPropagator::Initialize(Function* fn) { @@ -245,7 +262,11 @@ bool SSAPropagator::Run(Function* fn) { // follow after all the blocks have been simulated. if (!blocks_.empty()) { auto block = blocks_.front(); - changed |= Simulate(block); + Pass::Status status = Simulate(block); + if (status == Pass::Status::Failure) { + return false; + } + changed |= status == Pass::Status::SuccessWithChange; blocks_.pop(); continue; } @@ -253,7 +274,11 @@ bool SSAPropagator::Run(Function* fn) { // Simulate edges from the SSA queue. if (!ssa_edge_uses_.empty()) { Instruction* instr = ssa_edge_uses_.front(); - changed |= Simulate(instr); + Pass::Status status = Simulate(instr); + if (status == Pass::Status::Failure) { + return changed; + } + changed |= status == Pass::Status::SuccessWithChange; ssa_edge_uses_.pop(); } } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/propagator.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/propagator.h index 71212c9..2727f24 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/propagator.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/propagator.h @@ -25,6 +25,7 @@ #include "source/opt/ir_context.h" #include "source/opt/module.h" +#include "source/opt/pass.h" namespace spvtools { namespace opt { @@ -182,7 +183,7 @@ class SSAPropagator { public: // Lattice values used for propagation. See class documentation for // a description. - enum PropStatus { kNotInteresting, kInteresting, kVarying }; + enum PropStatus { kNotInteresting, kInteresting, kVarying, kFailed }; using VisitFunction = std::function; @@ -190,7 +191,9 @@ class SSAPropagator { : ctx_(context), visit_fn_(visit_fn) {} // Runs the propagator on function |fn|. Returns true if changes were made to - // the function. Otherwise, it returns false. + // the function. Otherwise, it returns false. The user should check + // IRContext::id_overflow() to see if there was an error caused by reaching + // the max id. bool Run(Function* fn); // Returns true if the |i|th argument for |phi| comes through a CFG edge that @@ -218,13 +221,13 @@ class SSAPropagator { // Simulate the execution |block| by calling |visit_fn_| on every instruction // in it. - bool Simulate(BasicBlock* block); + Pass::Status Simulate(BasicBlock* block); // Simulate the execution of |instr| by replacing all the known values in // every operand and determining whether the result is interesting for // propagation. This invokes the callback function |visit_fn_| to determine // the value computed by |instr|. - bool Simulate(Instruction* instr); + Pass::Status Simulate(Instruction* instr); // Returns true if |instr| should be simulated again. bool ShouldSimulateAgain(Instruction* instr) const { diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/reduce_load_size.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/reduce_load_size.cpp index 73a90f0..3162d79 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/reduce_load_size.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/reduce_load_size.cpp @@ -108,6 +108,7 @@ bool ReduceLoadSize::ReplaceExtract(Instruction* inst) { Instruction* new_access_chain = ir_builder.AddAccessChain( pointer_to_result_type_id, composite_inst->GetSingleWordInOperand(kLoadPointerInIdx), ids); + // TODO(1841): Handle id overflow. Instruction* new_load = ir_builder.AddLoad(inst->type_id(), new_access_chain->result_id()); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/remove_duplicates_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/remove_duplicates_pass.cpp index 0df559b..a388155 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/remove_duplicates_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/remove_duplicates_pass.cpp @@ -29,6 +29,7 @@ namespace opt { Pass::Status RemoveDuplicatesPass::Process() { bool modified = RemoveDuplicateCapabilities(); + modified |= RemoveDuplicateExtensions(); modified |= RemoveDuplicatesExtInstImports(); modified |= RemoveDuplicateTypes(); modified |= RemoveDuplicateDecorations(); @@ -36,6 +37,41 @@ Pass::Status RemoveDuplicatesPass::Process() { return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } +bool RemoveDuplicatesPass::RemoveDuplicateExtensions() const { + bool modified = false; + + if (context()->extensions().empty()) { + return modified; + } + + // set of {condition ID, extension name} + // ID 0 means unconditional extension, ie., OpExtension, otherwise the ID is + // the condition operand of OpConditionalExtensionINTEL. + std::set> extensions; + for (auto* inst = &*context()->extension_begin(); inst;) { + uint32_t cond_id = 0; + uint32_t i_name = 0; + if (inst->opcode() == spv::Op::OpConditionalExtensionINTEL) { + cond_id = inst->GetOperand(0).AsId(); + i_name = 1; + } + + auto res = + extensions.insert({cond_id, inst->GetOperand(i_name).AsString()}); + + if (res.second) { + // Never seen before, keep it. + inst = inst->NextNode(); + } else { + // It's a duplicate, remove it. + inst = context()->KillInst(inst); + modified = true; + } + } + + return modified; +} + bool RemoveDuplicatesPass::RemoveDuplicateCapabilities() const { bool modified = false; @@ -43,16 +79,27 @@ bool RemoveDuplicatesPass::RemoveDuplicateCapabilities() const { return modified; } - std::unordered_set capabilities; - for (auto* i = &*context()->capability_begin(); i;) { - auto res = capabilities.insert(i->GetSingleWordOperand(0u)); + // set of {condition ID, capability} + // ID 0 means unconditional capability, ie., OpCapability, otherwise the ID is + // the condition operand of OpConditionalCapabilityINTEL. + std::set> capabilities; + for (auto* inst = &*context()->capability_begin(); inst;) { + uint32_t cond_id = 0; + uint32_t i_cap = 0; + if (inst->opcode() == spv::Op::OpConditionalCapabilityINTEL) { + cond_id = inst->GetOperand(0).AsId(); + i_cap = 1; + } + + auto res = + capabilities.insert({cond_id, inst->GetSingleWordOperand(i_cap)}); if (res.second) { // Never seen before, keep it. - i = i->NextNode(); + inst = inst->NextNode(); } else { // It's a duplicate, remove it. - i = context()->KillInst(i); + inst = context()->KillInst(inst); modified = true; } } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/remove_duplicates_pass.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/remove_duplicates_pass.h index 038caa8..e5b3925 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/remove_duplicates_pass.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/remove_duplicates_pass.h @@ -37,6 +37,10 @@ class RemoveDuplicatesPass : public Pass { Status Process() override; private: + // Remove duplicate extensions from the module + // + // Returns true if the module was modified, false otherwise. + bool RemoveDuplicateExtensions() const; // Remove duplicate capabilities from the module // // Returns true if the module was modified, false otherwise. diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/remove_unused_interface_variables_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/remove_unused_interface_variables_pass.cpp index c3a4b77..e52f072 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/remove_unused_interface_variables_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/remove_unused_interface_variables_pass.cpp @@ -13,6 +13,7 @@ // limitations under the License. #include "remove_unused_interface_variables_pass.h" + #include "source/spirv_constant.h" namespace spvtools { namespace opt { @@ -55,7 +56,9 @@ class RemoveUnusedInterfaceVariablesContext { void CollectUsedVariables() { std::queue roots; - roots.push(entry_.GetSingleWordInOperand(1)); + const int op_i = + entry_.opcode() == spv::Op::OpConditionalEntryPointINTEL ? 2 : 1; + roots.push(entry_.GetSingleWordInOperand(op_i)); parent_.context()->ProcessCallTreeFromRoots(pfn_, &roots); } @@ -73,7 +76,9 @@ class RemoveUnusedInterfaceVariablesContext { } void Modify() { - for (int i = entry_.NumInOperands() - 1; i >= 3; --i) + const int min_num_operands = + entry_.opcode() == spv::Op::OpConditionalEntryPointINTEL ? 4 : 3; + for (int i = entry_.NumInOperands() - 1; i >= min_num_operands; --i) entry_.RemoveInOperand(i); for (auto id : operands_to_add_) { entry_.AddOperand(Operand(SPV_OPERAND_TYPE_ID, {id})); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/replace_desc_array_access_using_var_index.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/replace_desc_array_access_using_var_index.cpp index 59745e1..619fa93 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/replace_desc_array_access_using_var_index.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/replace_desc_array_access_using_var_index.cpp @@ -41,14 +41,15 @@ Pass::Status ReplaceDescArrayAccessUsingVarIndex::Process() { Status status = Status::SuccessWithoutChange; for (Instruction& var : context()->types_values()) { if (descsroautil::IsDescriptorArray(context(), &var)) { - if (ReplaceVariableAccessesWithConstantElements(&var)) - status = Status::SuccessWithChange; + Status s = ReplaceVariableAccessesWithConstantElements(&var); + if (s == Status::Failure) return Status::Failure; + if (s == Status::SuccessWithChange) status = Status::SuccessWithChange; } } return status; } -bool ReplaceDescArrayAccessUsingVarIndex:: +Pass::Status ReplaceDescArrayAccessUsingVarIndex:: ReplaceVariableAccessesWithConstantElements(Instruction* var) const { std::vector work_list; get_def_use_mgr()->ForEachUser(var, [&work_list](Instruction* use) { @@ -66,16 +67,16 @@ bool ReplaceDescArrayAccessUsingVarIndex:: for (Instruction* access_chain : work_list) { if (descsroautil::GetAccessChainIndexAsConst(context(), access_chain) == nullptr) { - ReplaceAccessChain(var, access_chain); + if (!ReplaceAccessChain(var, access_chain)) return Status::Failure; updated = true; } } // Note that we do not consider OpLoad and OpCompositeExtract because // OpCompositeExtract always has constant literals for indices. - return updated; + return updated ? Status::SuccessWithChange : Status::SuccessWithoutChange; } -void ReplaceDescArrayAccessUsingVarIndex::ReplaceAccessChain( +bool ReplaceDescArrayAccessUsingVarIndex::ReplaceAccessChain( Instruction* var, Instruction* access_chain) const { uint32_t number_of_elements = descsroautil::GetNumberOfElementsForArrayOrStruct(context(), var); @@ -83,21 +84,23 @@ void ReplaceDescArrayAccessUsingVarIndex::ReplaceAccessChain( if (number_of_elements == 1) { UseConstIndexForAccessChain(access_chain, 0); get_def_use_mgr()->AnalyzeInstUse(access_chain); - return; + return true; } - ReplaceUsersOfAccessChain(access_chain, number_of_elements); + return ReplaceUsersOfAccessChain(access_chain, number_of_elements); } -void ReplaceDescArrayAccessUsingVarIndex::ReplaceUsersOfAccessChain( +bool ReplaceDescArrayAccessUsingVarIndex::ReplaceUsersOfAccessChain( Instruction* access_chain, uint32_t number_of_elements) const { std::vector final_users; CollectRecursiveUsersWithConcreteType(access_chain, &final_users); for (auto* inst : final_users) { std::deque insts_to_be_cloned = CollectRequiredImageAndAccessInsts(inst); - ReplaceNonUniformAccessWithSwitchCase( - inst, access_chain, number_of_elements, insts_to_be_cloned); + if (!ReplaceNonUniformAccessWithSwitchCase( + inst, access_chain, number_of_elements, insts_to_be_cloned)) + return false; } + return true; } void ReplaceDescArrayAccessUsingVarIndex::CollectRecursiveUsersWithConcreteType( @@ -208,17 +211,23 @@ BasicBlock* ReplaceDescArrayAccessUsingVarIndex::CreateCaseBlock( const std::deque& insts_to_be_cloned, uint32_t branch_target_id, std::unordered_map* old_ids_to_new_ids) const { - auto* case_block = CreateNewBlock(); - AddConstElementAccessToCaseBlock(case_block, access_chain, element_index, - old_ids_to_new_ids); - CloneInstsToBlock(case_block, access_chain, insts_to_be_cloned, - old_ids_to_new_ids); - AddBranchToBlock(case_block, branch_target_id); - UseNewIdsInBlock(case_block, *old_ids_to_new_ids); - return case_block; + std::unique_ptr case_block(CreateNewBlock()); + if (!case_block) return nullptr; + + if (!AddConstElementAccessToCaseBlock(case_block.get(), access_chain, + element_index, old_ids_to_new_ids)) { + return nullptr; + } + if (!CloneInstsToBlock(case_block.get(), access_chain, insts_to_be_cloned, + old_ids_to_new_ids)) { + return nullptr; + } + AddBranchToBlock(case_block.get(), branch_target_id); + UseNewIdsInBlock(case_block.get(), *old_ids_to_new_ids); + return case_block.release(); } -void ReplaceDescArrayAccessUsingVarIndex::CloneInstsToBlock( +bool ReplaceDescArrayAccessUsingVarIndex::CloneInstsToBlock( BasicBlock* block, Instruction* inst_to_skip_cloning, const std::deque& insts_to_be_cloned, std::unordered_map* old_ids_to_new_ids) const { @@ -227,6 +236,7 @@ void ReplaceDescArrayAccessUsingVarIndex::CloneInstsToBlock( std::unique_ptr clone(inst_to_be_cloned->Clone(context())); if (inst_to_be_cloned->HasResultId()) { uint32_t new_id = context()->TakeNextId(); + if (new_id == 0) return false; clone->SetResultId(new_id); (*old_ids_to_new_ids)[inst_to_be_cloned->result_id()] = new_id; } @@ -234,6 +244,7 @@ void ReplaceDescArrayAccessUsingVarIndex::CloneInstsToBlock( context()->set_instr_block(clone.get(), block); block->AddInstruction(std::move(clone)); } + return true; } void ReplaceDescArrayAccessUsingVarIndex::UseNewIdsInBlock( @@ -250,18 +261,19 @@ void ReplaceDescArrayAccessUsingVarIndex::UseNewIdsInBlock( } } -void ReplaceDescArrayAccessUsingVarIndex::ReplaceNonUniformAccessWithSwitchCase( +bool ReplaceDescArrayAccessUsingVarIndex::ReplaceNonUniformAccessWithSwitchCase( Instruction* access_chain_final_user, Instruction* access_chain, uint32_t number_of_elements, const std::deque& insts_to_be_cloned) const { auto* block = context()->get_instr_block(access_chain_final_user); // If the instruction does not belong to a block (i.e. in the case of // OpDecorate), no replacement is needed. - if (!block) return; + if (!block) return true; // Create merge block and add terminator auto* merge_block = SeparateInstructionsIntoNewBlock( block, access_chain_final_user->NextNode()); + if (!merge_block) return false; auto* function = block->GetParent(); @@ -273,6 +285,7 @@ void ReplaceDescArrayAccessUsingVarIndex::ReplaceNonUniformAccessWithSwitchCase( std::unique_ptr case_block(CreateCaseBlock( access_chain, idx, insts_to_be_cloned, merge_block->id(), &old_ids_to_new_ids_for_cloned_insts)); + if (!case_block) return false; case_block_ids.push_back(case_block->id()); function->InsertBasicBlockBefore(std::move(case_block), merge_block); @@ -288,6 +301,7 @@ void ReplaceDescArrayAccessUsingVarIndex::ReplaceNonUniformAccessWithSwitchCase( std::unique_ptr default_block( CreateDefaultBlock(access_chain_final_user->HasResultId(), &phi_operands, merge_block->id())); + if (!default_block) return false; uint32_t default_block_id = default_block->id(); function->InsertBasicBlockBefore(std::move(default_block), merge_block); @@ -301,11 +315,13 @@ void ReplaceDescArrayAccessUsingVarIndex::ReplaceNonUniformAccessWithSwitchCase( if (!phi_operands.empty()) { uint32_t phi_id = CreatePhiInstruction(merge_block, phi_operands, case_block_ids, default_block_id); + if (phi_id == 0) return false; context()->ReplaceAllUsesWith(access_chain_final_user->result_id(), phi_id); } // Replace OpPhi incoming block operand that uses |block| with |merge_block| ReplacePhiIncomingBlock(block->id(), merge_block->id()); + return true; } BasicBlock* @@ -316,13 +332,16 @@ ReplaceDescArrayAccessUsingVarIndex::SeparateInstructionsIntoNewBlock( &*separation_begin != separation_begin_inst) { ++separation_begin; } - return block->SplitBasicBlock(context(), context()->TakeNextId(), - separation_begin); + uint32_t new_id = context()->TakeNextId(); + if (new_id == 0) return nullptr; + return block->SplitBasicBlock(context(), new_id, separation_begin); } BasicBlock* ReplaceDescArrayAccessUsingVarIndex::CreateNewBlock() const { - auto* new_block = new BasicBlock(std::unique_ptr(new Instruction( - context(), spv::Op::OpLabel, 0, context()->TakeNextId(), {}))); + uint32_t new_id = context()->TakeNextId(); + if (new_id == 0) return nullptr; + auto* new_block = new BasicBlock(std::unique_ptr( + new Instruction(context(), spv::Op::OpLabel, 0, new_id, {}))); get_def_use_mgr()->AnalyzeInstDefUse(new_block->GetLabelInst()); context()->set_instr_block(new_block->GetLabelInst(), new_block); return new_block; @@ -336,7 +355,7 @@ void ReplaceDescArrayAccessUsingVarIndex::UseConstIndexForAccessChain( {const_element_idx_id}); } -void ReplaceDescArrayAccessUsingVarIndex::AddConstElementAccessToCaseBlock( +bool ReplaceDescArrayAccessUsingVarIndex::AddConstElementAccessToCaseBlock( BasicBlock* case_block, Instruction* access_chain, uint32_t const_element_idx, std::unordered_map* old_ids_to_new_ids) const { @@ -344,12 +363,14 @@ void ReplaceDescArrayAccessUsingVarIndex::AddConstElementAccessToCaseBlock( UseConstIndexForAccessChain(access_clone.get(), const_element_idx); uint32_t new_access_id = context()->TakeNextId(); + if (new_access_id == 0) return false; (*old_ids_to_new_ids)[access_clone->result_id()] = new_access_id; access_clone->SetResultId(new_access_id); get_def_use_mgr()->AnalyzeInstDefUse(access_clone.get()); context()->set_instr_block(access_clone.get(), case_block); case_block->AddInstruction(std::move(access_clone)); + return true; } void ReplaceDescArrayAccessUsingVarIndex::AddBranchToBlock( @@ -363,6 +384,7 @@ BasicBlock* ReplaceDescArrayAccessUsingVarIndex::CreateDefaultBlock( bool null_const_for_phi_is_needed, std::vector* phi_operands, uint32_t merge_block_id) const { auto* default_block = CreateNewBlock(); + if (!default_block) return nullptr; AddBranchToBlock(default_block, merge_block_id); if (!null_const_for_phi_is_needed) return default_block; @@ -413,7 +435,11 @@ uint32_t ReplaceDescArrayAccessUsingVarIndex::CreatePhiInstruction( kAnalysisDefUseAndInstrToBlockMapping}; uint32_t phi_result_type_id = context()->get_def_use_mgr()->GetDef(phi_operands[0])->type_id(); - auto* phi = builder.AddPhi(phi_result_type_id, incomings); + Instruction* phi = builder.AddPhi(phi_result_type_id, incomings); + if (!phi) { + return 0; + } + context()->get_def_use_mgr()->AnalyzeInstDefUse(phi); return phi->result_id(); } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/replace_desc_array_access_using_var_index.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/replace_desc_array_access_using_var_index.h index 51817c1..b385532 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/replace_desc_array_access_using_var_index.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/replace_desc_array_access_using_var_index.h @@ -49,14 +49,13 @@ class ReplaceDescArrayAccessUsingVarIndex : public Pass { private: // Replaces all accesses to |var| using variable indices with constant // elements of the array |var|. Creates switch-case statements to determine - // the value of the variable index for all the possible cases. Returns - // whether replacement is done or not. - bool ReplaceVariableAccessesWithConstantElements(Instruction* var) const; + // the value of the variable index for all the possible cases. + Status ReplaceVariableAccessesWithConstantElements(Instruction* var) const; // Replaces the OpAccessChain or OpInBoundsAccessChain instruction |use| that // uses the descriptor variable |var| with the OpAccessChain or // OpInBoundsAccessChain instruction with a constant Indexes operand. - void ReplaceAccessChain(Instruction* var, Instruction* use) const; + bool ReplaceAccessChain(Instruction* var, Instruction* use) const; // Updates the first Indexes operand of the OpAccessChain or // OpInBoundsAccessChain instruction |access_chain| to let it use a constant @@ -68,7 +67,7 @@ class ReplaceDescArrayAccessUsingVarIndex : public Pass { // |access_chain| that accesses an array descriptor variable using variable // indices with constant elements. |number_of_elements| is the number // of array elements. - void ReplaceUsersOfAccessChain(Instruction* access_chain, + bool ReplaceUsersOfAccessChain(Instruction* access_chain, uint32_t number_of_elements) const; // Puts all the recursive users of |access_chain| with concrete result types @@ -102,7 +101,7 @@ class ReplaceDescArrayAccessUsingVarIndex : public Pass { // OpInBoundsAccessChain) will have a constant index for its first index. The // OpSwitch instruction will have the cases for the variable index of // |access_chain| from 0 to |number_of_elements| - 1. - void ReplaceNonUniformAccessWithSwitchCase( + bool ReplaceNonUniformAccessWithSwitchCase( Instruction* access_chain_final_user, Instruction* access_chain, uint32_t number_of_elements, const std::deque& non_uniform_accesses_to_clone) const; @@ -124,7 +123,7 @@ class ReplaceDescArrayAccessUsingVarIndex : public Pass { // |access_chain| to |case_block|. The clone of |access_chain| will use // |const_element_idx| for its first index. |old_ids_to_new_ids| keeps the // mapping from the result id of |access_chain| to the result of its clone. - void AddConstElementAccessToCaseBlock( + bool AddConstElementAccessToCaseBlock( BasicBlock* case_block, Instruction* access_chain, uint32_t const_element_idx, std::unordered_map* old_ids_to_new_ids) const; @@ -132,7 +131,7 @@ class ReplaceDescArrayAccessUsingVarIndex : public Pass { // Clones all instructions in |insts_to_be_cloned| and put them to |block|. // |old_ids_to_new_ids| keeps the mapping from the result id of each // instruction of |insts_to_be_cloned| to the result of their clones. - void CloneInstsToBlock( + bool CloneInstsToBlock( BasicBlock* block, Instruction* inst_to_skip_cloning, const std::deque& insts_to_be_cloned, std::unordered_map* old_ids_to_new_ids) const; @@ -183,7 +182,8 @@ class ReplaceDescArrayAccessUsingVarIndex : public Pass { // |case_block_ids| and |default_block_id| as incoming blocks. The size of // |phi_operands| must be exactly 1 larger than the size of |case_block_ids|. // The last element of |phi_operands| will be used for |default_block_id|. It - // adds the phi instruction to the beginning of |parent_block|. + // adds the phi instruction to the beginning of |parent_block|. Returns 0 if + // it fails to create the Phi instruction. uint32_t CreatePhiInstruction(BasicBlock* parent_block, const std::vector& phi_operands, const std::vector& case_block_ids, diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/scalar_replacement_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/scalar_replacement_pass.cpp index ff81fae..cdda380 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/scalar_replacement_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/scalar_replacement_pass.cpp @@ -186,7 +186,7 @@ bool ScalarReplacementPass::ReplaceWholeDebugDeclare( Instruction* added_dbg_value = context()->get_debug_info_mgr()->AddDebugValueForDecl( dbg_decl, /*value_id=*/var->result_id(), - /*insert_before=*/insert_before, /*scope_and_line=*/dbg_decl); + /*insert_before=*/insert_before, /*line=*/dbg_decl); if (added_dbg_value == nullptr) return false; added_dbg_value->AddOperand( @@ -475,6 +475,7 @@ void ScalarReplacementPass::CreateVariable( if (id == 0) { replacements->push_back(nullptr); + return; } std::unique_ptr variable( @@ -488,7 +489,10 @@ void ScalarReplacementPass::CreateVariable( Instruction* inst = &*block->begin(); // If varInst was initialized, make sure to initialize its replacement. - GetOrCreateInitialValue(var_inst, index, inst); + if (!GetOrCreateInitialValue(var_inst, index, inst)) { + replacements->push_back(nullptr); + return; + } get_def_use_mgr()->AnalyzeInstDefUse(inst); context()->set_instr_block(inst, block); @@ -509,11 +513,11 @@ uint32_t ScalarReplacementPass::GetOrCreatePointerType(uint32_t id) { return ptr_type_id; } -void ScalarReplacementPass::GetOrCreateInitialValue(Instruction* source, +bool ScalarReplacementPass::GetOrCreateInitialValue(Instruction* source, uint32_t index, Instruction* newVar) { assert(source->opcode() == spv::Op::OpVariable); - if (source->NumInOperands() < 2) return; + if (source->NumInOperands() < 2) return true; uint32_t initId = source->GetSingleWordInOperand(1u); uint32_t storageId = GetStorageType(newVar)->result_id(); @@ -525,6 +529,7 @@ void ScalarReplacementPass::GetOrCreateInitialValue(Instruction* source, auto iter = type_to_null_.find(storageId); if (iter == type_to_null_.end()) { newInitId = TakeNextId(); + if (newInitId == 0) return false; type_to_null_[storageId] = newInitId; context()->AddGlobalValue( MakeUnique(context(), spv::Op::OpConstantNull, storageId, @@ -537,6 +542,7 @@ void ScalarReplacementPass::GetOrCreateInitialValue(Instruction* source, } else if (IsSpecConstantInst(init->opcode())) { // Create a new constant extract. newInitId = TakeNextId(); + if (newInitId == 0) return false; context()->AddGlobalValue(MakeUnique( context(), spv::Op::OpSpecConstantOp, storageId, newInitId, std::initializer_list{ @@ -561,6 +567,7 @@ void ScalarReplacementPass::GetOrCreateInitialValue(Instruction* source, if (newInitId != 0) { newVar->AddOperand({SPV_OPERAND_TYPE_ID, {newInitId}}); } + return true; } uint64_t ScalarReplacementPass::GetArrayLength( diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/scalar_replacement_pass.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/scalar_replacement_pass.h index 61d341e..77d5bd5 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/scalar_replacement_pass.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/scalar_replacement_pass.h @@ -199,7 +199,9 @@ class ScalarReplacementPass : public MemPass { // If there is an initial value for |source| for element |index|, it is // appended as an operand on |newVar|. If the initial value is OpUndef, no // initial value is added to |newVar|. - void GetOrCreateInitialValue(Instruction* source, uint32_t index, + // + // Returns true if the value was successfully created. + bool GetOrCreateInitialValue(Instruction* source, uint32_t index, Instruction* newVar); // Replaces the load to the entire composite. diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/split_combined_image_sampler_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/split_combined_image_sampler_pass.cpp index 0af4dba..338320d 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/split_combined_image_sampler_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/split_combined_image_sampler_pass.cpp @@ -275,8 +275,10 @@ spv_result_t SplitCombinedImageSamplerPass::RemapVar( auto [ptr_image_ty, ptr_sampler_ty] = SplitType(*combined_var_type); assert(ptr_image_ty); assert(ptr_sampler_ty); + // TODO(1841): Handle id overflow. Instruction* sampler_var = builder.AddVariable( ptr_sampler_ty->result_id(), SpvStorageClassUniformConstant); + // TODO(1841): Handle id overflow. Instruction* image_var = builder.AddVariable(ptr_image_ty->result_id(), SpvStorageClassUniformConstant); modified_ = true; @@ -354,8 +356,10 @@ spv_result_t SplitCombinedImageSamplerPass::RemapUses( // Create loads for the image part and sampler part. builder.SetInsertPoint(load); + // TODO(1841): Handle id overflow. auto* image = builder.AddLoad(PointeeTypeId(use.image_part), use.image_part->result_id()); + // TODO(1841): Handle id overflow. auto* sampler = builder.AddLoad(PointeeTypeId(use.sampler_part), use.sampler_part->result_id()); @@ -459,9 +463,11 @@ spv_result_t SplitCombinedImageSamplerPass::RemapUses( auto [result_image_part_ty, result_sampler_part_ty] = SplitType(*def_use_mgr_->GetDef(original_access_chain->type_id())); + // TODO(1841): Handle id overflow. auto* result_image_part = builder.AddOpcodeAccessChain( use.user->opcode(), result_image_part_ty->result_id(), use.image_part->result_id(), indices); + // TODO(1841): Handle id overflow. auto* result_sampler_part = builder.AddOpcodeAccessChain( use.user->opcode(), result_sampler_part_ty->result_id(), use.sampler_part->result_id(), indices); @@ -556,10 +562,14 @@ spv_result_t SplitCombinedImageSamplerPass::RemapFunctions() { Instruction* sampler; }; std::vector replacements; + bool error = false; Function::RewriteParamFn rewriter = [&](std::unique_ptr&& param, std::back_insert_iterator& appender) { + if (error) { + return; + } if (combined_types_.count(param->type_id()) == 0) { appender = std::move(param); return; @@ -569,12 +579,22 @@ spv_result_t SplitCombinedImageSamplerPass::RemapFunctions() { auto* combined_inst = param.release(); auto* combined_type = def_use_mgr_->GetDef(combined_inst->type_id()); auto [image_type, sampler_type] = SplitType(*combined_type); + uint32_t image_param_id = context()->TakeNextId(); + if (image_param_id == 0) { + error = true; + return; + } auto image_param = MakeUnique( context(), spv::Op::OpFunctionParameter, image_type->result_id(), - context()->TakeNextId(), Instruction::OperandList{}); + image_param_id, Instruction::OperandList{}); + uint32_t sampler_param_id = context()->TakeNextId(); + if (sampler_param_id == 0) { + error = true; + return; + } auto sampler_param = MakeUnique( context(), spv::Op::OpFunctionParameter, - sampler_type->result_id(), context()->TakeNextId(), + sampler_type->result_id(), sampler_param_id, Instruction::OperandList{}); replacements.push_back( {combined_inst, image_param.get(), sampler_param.get()}); @@ -583,6 +603,10 @@ spv_result_t SplitCombinedImageSamplerPass::RemapFunctions() { }; fn.RewriteParams(rewriter); + if (error) { + return SPV_ERROR_INTERNAL; + } + for (auto& r : replacements) { modified_ = true; def_use_mgr_->AnalyzeInstDefUse(r.image); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/ssa_rewrite_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/ssa_rewrite_pass.cpp index 3eb4ec3..615b129 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/ssa_rewrite_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/ssa_rewrite_pass.cpp @@ -87,13 +87,15 @@ std::string SSARewriter::PhiCandidate::PrettyPrint(const CFG* cfg) const { return str.str(); } -SSARewriter::PhiCandidate& SSARewriter::CreatePhiCandidate(uint32_t var_id, +SSARewriter::PhiCandidate* SSARewriter::CreatePhiCandidate(uint32_t var_id, BasicBlock* bb) { - // TODO(1841): Handle id overflow. uint32_t phi_result_id = pass_->context()->TakeNextId(); + if (phi_result_id == 0) { + return nullptr; + } auto result = phi_candidates_.emplace( phi_result_id, PhiCandidate(var_id, phi_result_id, bb)); - PhiCandidate& phi_candidate = result.first->second; + PhiCandidate* phi_candidate = &result.first->second; return phi_candidate; } @@ -268,11 +270,12 @@ uint32_t SSARewriter::GetReachingDef(uint32_t var_id, BasicBlock* bb) { // If there is more than one predecessor, this is a join block which may // require a Phi instruction. This will act as |var_id|'s current // definition to break potential cycles. - PhiCandidate& phi_candidate = CreatePhiCandidate(var_id, bb); + PhiCandidate* phi_candidate = CreatePhiCandidate(var_id, bb); + if (phi_candidate == nullptr) return 0; // Set the value for |bb| to avoid an infinite recursion. - WriteVariable(var_id, bb, phi_candidate.result_id()); - val_id = AddPhiOperands(&phi_candidate); + WriteVariable(var_id, bb, phi_candidate->result_id()); + val_id = AddPhiOperands(phi_candidate); } // If we could not find a store for this variable in the path from the root diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/ssa_rewrite_pass.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/ssa_rewrite_pass.h index 2470f85..076d9e1 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/ssa_rewrite_pass.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/ssa_rewrite_pass.h @@ -232,7 +232,7 @@ class SSARewriter { // during rewriting. // // Once the candidate Phi is created, it returns its ID. - PhiCandidate& CreatePhiCandidate(uint32_t var_id, BasicBlock* bb); + PhiCandidate* CreatePhiCandidate(uint32_t var_id, BasicBlock* bb); // Attempts to remove a trivial Phi candidate |phi_cand|. Trivial Phis are // those that only reference themselves and one other value |val| any number diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/strength_reduction_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/strength_reduction_pass.cpp index 16a7869..b9d6265 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/strength_reduction_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/strength_reduction_pass.cpp @@ -53,17 +53,15 @@ bool IsPowerOf2(uint32_t val) { Pass::Status StrengthReductionPass::Process() { // Initialize the member variables on a per module basis. - bool modified = false; int32_type_id_ = 0; uint32_type_id_ = 0; std::memset(constant_ids_, 0, sizeof(constant_ids_)); FindIntTypesAndConstants(); - modified = ScanFunctions(); - return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange); + return ScanFunctions(); } -bool StrengthReductionPass::ReplaceMultiplyByPowerOf2( +Pass::Status StrengthReductionPass::ReplaceMultiplyByPowerOf2( BasicBlock::iterator* inst) { assert((*inst)->opcode() == spv::Op::OpIMul && "Only works for multiplication of integers."); @@ -72,7 +70,7 @@ bool StrengthReductionPass::ReplaceMultiplyByPowerOf2( // Currently only works on 32-bit integers. if ((*inst)->type_id() != int32_type_id_ && (*inst)->type_id() != uint32_type_id_) { - return modified; + return Status::SuccessWithoutChange; } // Check the operands for a constant that is a power of 2. @@ -87,9 +85,11 @@ bool StrengthReductionPass::ReplaceMultiplyByPowerOf2( modified = true; uint32_t shiftAmount = CountTrailingZeros(constVal); uint32_t shiftConstResultId = GetConstantId(shiftAmount); + if (shiftConstResultId == 0) return Status::Failure; // Create the new instruction. uint32_t newResultId = TakeNextId(); + if (newResultId == 0) return Status::Failure; std::vector newOperands; newOperands.push_back((*inst)->GetInOperand(1 - i)); Operand shiftOperand(spv_operand_type_t::SPV_OPERAND_TYPE_ID, @@ -117,7 +117,7 @@ bool StrengthReductionPass::ReplaceMultiplyByPowerOf2( } } - return modified; + return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } void StrengthReductionPass::FindIntTypesAndConstants() { @@ -152,6 +152,7 @@ uint32_t StrengthReductionPass::GetConstantId(uint32_t val) { // Construct the constant. uint32_t resultId = TakeNextId(); + if (resultId == 0) return 0; Operand constant(spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER, {val}); std::unique_ptr newConstant(new Instruction( @@ -169,7 +170,7 @@ uint32_t StrengthReductionPass::GetConstantId(uint32_t val) { return constant_ids_[val]; } -bool StrengthReductionPass::ScanFunctions() { +Pass::Status StrengthReductionPass::ScanFunctions() { // I did not use |ForEachInst| in the module because the function that acts on // the instruction gets a pointer to the instruction. We cannot use that to // insert a new instruction. I want an iterator. @@ -178,16 +179,19 @@ bool StrengthReductionPass::ScanFunctions() { for (auto& bb : func) { for (auto inst = bb.begin(); inst != bb.end(); ++inst) { switch (inst->opcode()) { - case spv::Op::OpIMul: - if (ReplaceMultiplyByPowerOf2(&inst)) modified = true; + case spv::Op::OpIMul: { + Status s = ReplaceMultiplyByPowerOf2(&inst); + if (s == Status::Failure) return Status::Failure; + if (s == Status::SuccessWithChange) modified = true; break; + } default: break; } } } } - return modified; + return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange; } } // namespace opt diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/strength_reduction_pass.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/strength_reduction_pass.h index 1cbbbcc..48e72ab 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/strength_reduction_pass.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/strength_reduction_pass.h @@ -32,7 +32,7 @@ class StrengthReductionPass : public Pass { private: // Replaces multiple by power of 2 with an equivalent bit shift. // Returns true if something changed. - bool ReplaceMultiplyByPowerOf2(BasicBlock::iterator*); + Status ReplaceMultiplyByPowerOf2(BasicBlock::iterator*); // Scan the types and constants in the module looking for the integer // types that we are @@ -47,7 +47,7 @@ class StrengthReductionPass : public Pass { // Replaces certain instructions in function bodies with presumably cheaper // ones. Returns true if something changed. - bool ScanFunctions(); + Status ScanFunctions(); // Type ids for the types of interest, or 0 if they do not exist. uint32_t int32_type_id_; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/trim_capabilities_pass.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/trim_capabilities_pass.cpp index cc0e331..47f2cb2 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/trim_capabilities_pass.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/trim_capabilities_pass.cpp @@ -427,20 +427,20 @@ Handler_OpImageSparseRead_StorageImageReadWithoutFormat( // Opcode of interest to determine capabilities requirements. constexpr std::array, 14> kOpcodeHandlers{{ // clang-format off - {spv::Op::OpImageRead, Handler_OpImageRead_StorageImageReadWithoutFormat}, - {spv::Op::OpImageWrite, Handler_OpImageWrite_StorageImageWriteWithoutFormat}, - {spv::Op::OpImageSparseRead, Handler_OpImageSparseRead_StorageImageReadWithoutFormat}, - {spv::Op::OpTypeFloat, Handler_OpTypeFloat_Float16 }, - {spv::Op::OpTypeFloat, Handler_OpTypeFloat_Float64 }, - {spv::Op::OpTypeImage, Handler_OpTypeImage_ImageMSArray}, - {spv::Op::OpTypeInt, Handler_OpTypeInt_Int16 }, - {spv::Op::OpTypeInt, Handler_OpTypeInt_Int64 }, - {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageInputOutput16}, - {spv::Op::OpTypePointer, Handler_OpTypePointer_StoragePushConstant16}, - {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageUniform16}, - {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageUniform16}, - {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageUniformBufferBlock16}, - {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageBuffer16BitAccess}, + {spv::Op::OpImageRead, Handler_OpImageRead_StorageImageReadWithoutFormat}, + {spv::Op::OpImageWrite, Handler_OpImageWrite_StorageImageWriteWithoutFormat}, + {spv::Op::OpImageSparseRead, Handler_OpImageSparseRead_StorageImageReadWithoutFormat}, + {spv::Op::OpTypeFloat, Handler_OpTypeFloat_Float16 }, + {spv::Op::OpTypeFloat, Handler_OpTypeFloat_Float64 }, + {spv::Op::OpTypeImage, Handler_OpTypeImage_ImageMSArray}, + {spv::Op::OpTypeInt, Handler_OpTypeInt_Int16 }, + {spv::Op::OpTypeInt, Handler_OpTypeInt_Int64 }, + {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageInputOutput16}, + {spv::Op::OpTypePointer, Handler_OpTypePointer_StoragePushConstant16}, + {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageUniform16}, + {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageUniform16}, + {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageUniformBufferBlock16}, + {spv::Op::OpTypePointer, Handler_OpTypePointer_StorageBuffer16BitAccess}, // clang-format on }}; @@ -612,7 +612,9 @@ void TrimCapabilitiesPass::addInstructionRequirements( ExtensionSet* extensions) const { // Ignoring OpCapability and OpExtension instructions. if (instruction->opcode() == spv::Op::OpCapability || - instruction->opcode() == spv::Op::OpExtension) { + instruction->opcode() == spv::Op::OpConditionalCapabilityINTEL || + instruction->opcode() == spv::Op::OpExtension || + instruction->opcode() == spv::Op::OpConditionalExtensionINTEL) { return; } @@ -631,7 +633,7 @@ void TrimCapabilitiesPass::addInstructionRequirements( } // Last case: some complex logic needs to be run to determine capabilities. - auto[begin, end] = opcodeHandlers_.equal_range(instruction->opcode()); + auto [begin, end] = opcodeHandlers_.equal_range(instruction->opcode()); for (auto it = begin; it != end; it++) { const OpcodeHandler handler = it->second; auto result = handler(instruction); @@ -754,7 +756,7 @@ Pass::Status TrimCapabilitiesPass::Process() { return Status::SuccessWithoutChange; } - auto[required_capabilities, required_extensions] = + auto [required_capabilities, required_extensions] = DetermineRequiredCapabilitiesAndExtensions(); Pass::Status capStatus = TrimUnrequiredCapabilities(required_capabilities); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/trim_capabilities_pass.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/trim_capabilities_pass.h index d2369b1..06e989b 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/trim_capabilities_pass.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/trim_capabilities_pass.h @@ -82,6 +82,7 @@ class TrimCapabilitiesPass : public Pass { spv::Capability::FragmentShaderPixelInterlockEXT, spv::Capability::FragmentShaderSampleInterlockEXT, spv::Capability::FragmentShaderShadingRateInterlockEXT, + spv::Capability::Geometry, spv::Capability::GroupNonUniform, spv::Capability::GroupNonUniformArithmetic, spv::Capability::GroupNonUniformClustered, diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/type_manager.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/type_manager.cpp index be7dbc8..43e82cf 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/type_manager.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/type_manager.cpp @@ -495,6 +495,49 @@ uint32_t TypeManager::GetTypeInstruction(const Type* type) { {SPV_OPERAND_TYPE_ID, {coop_vec->components()}}}); break; } + case Type::kTensorARM: { + auto tensor_type = type->AsTensorARM(); + uint32_t const element_type = + GetTypeInstruction(tensor_type->element_type()); + if (element_type == 0) { + return 0; + } + if (tensor_type->rank_id() != 0) { + if (tensor_type->shape_id() != 0) { + typeInst = MakeUnique( + context(), spv::Op::OpTypeTensorARM, 0, id, + std::initializer_list{ + {SPV_OPERAND_TYPE_ID, {element_type}}, + {SPV_OPERAND_TYPE_ID, {tensor_type->rank_id()}}, + {SPV_OPERAND_TYPE_ID, {tensor_type->shape_id()}}}); + } else { + typeInst = MakeUnique( + context(), spv::Op::OpTypeTensorARM, 0, id, + std::initializer_list{ + {SPV_OPERAND_TYPE_ID, {element_type}}, + {SPV_OPERAND_TYPE_ID, {tensor_type->rank_id()}}}); + } + } else { + typeInst = + MakeUnique(context(), spv::Op::OpTypeTensorARM, 0, id, + std::initializer_list{ + {SPV_OPERAND_TYPE_ID, {element_type}}}); + } + break; + } + case Type::kGraphARM: { + auto const gty = type->AsGraphARM(); + std::vector ops; + ops.push_back( + Operand(SPV_OPERAND_TYPE_LITERAL_INTEGER, {gty->num_inputs()})); + for (auto iotype : gty->io_types()) { + uint32_t iotype_id = GetTypeInstruction(iotype); + ops.push_back(Operand(SPV_OPERAND_TYPE_ID, {iotype_id})); + } + typeInst = MakeUnique(context(), spv::Op::OpTypeGraphARM, 0, + id, ops); + break; + } default: assert(false && "Unexpected type"); break; @@ -754,6 +797,23 @@ Type* TypeManager::RebuildType(uint32_t type_id, const Type& type) { cv_type->components()); break; } + case Type::kTensorARM: { + const TensorARM* tensor_type = type.AsTensorARM(); + const Type* element_type = tensor_type->element_type(); + rebuilt_ty = MakeUnique( + RebuildType(GetId(element_type), *element_type), + tensor_type->rank_id(), tensor_type->shape_id()); + break; + } + case Type::kGraphARM: { + const GraphARM* graph_type = type.AsGraphARM(); + std::vector io_types; + for (auto ioty : graph_type->io_types()) { + io_types.push_back(RebuildType(GetId(ioty), *ioty)); + } + rebuilt_ty = MakeUnique(graph_type->num_inputs(), io_types); + break; + } default: assert(false && "Unhandled type"); return nullptr; @@ -1036,6 +1096,31 @@ Type* TypeManager::RecordIfTypeDefinition(const Instruction& inst) { inst.GetSingleWordInOperand(1), perm); break; } + case spv::Op::OpTypeTensorARM: { + switch (inst.NumInOperands()) { + case 1: + type = new TensorARM(GetType(inst.GetSingleWordInOperand(0))); + break; + case 2: + type = new TensorARM(GetType(inst.GetSingleWordInOperand(0)), + inst.GetSingleWordInOperand(1)); + break; + case 3: + type = new TensorARM(GetType(inst.GetSingleWordInOperand(0)), + inst.GetSingleWordInOperand(1), + inst.GetSingleWordInOperand(2)); + break; + } + break; + } + case spv::Op::OpTypeGraphARM: { + std::vector io_types; + for (unsigned i = 1; i < inst.NumInOperands(); i++) { + io_types.push_back(GetType(inst.GetSingleWordInOperand(i))); + } + type = new GraphARM(inst.GetSingleWordInOperand(0), io_types); + break; + } default: assert(false && "Type not handled by the type manager."); break; @@ -1067,7 +1152,11 @@ void TypeManager::AttachDecoration(const Instruction& inst, Type* type) { const auto count = inst.NumOperands(); std::vector data; for (uint32_t i = 1; i < count; ++i) { - data.push_back(inst.GetSingleWordOperand(i)); + // LinkageAttributes has a literal string as an operand, which is a + // varible length word. We cannot assume that all operands are single + // word. + const Operand::OperandData& words = inst.GetOperand(i).words; + data.insert(data.end(), words.begin(), words.end()); } type->AddDecoration(std::move(data)); } break; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/types.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/types.cpp index bb761a4..f0dc1c6 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/types.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/types.cpp @@ -135,6 +135,8 @@ std::unique_ptr Type::Clone() const { DeclareKindCase(CooperativeVectorNV); DeclareKindCase(RayQueryKHR); DeclareKindCase(HitObjectNV); + DeclareKindCase(TensorARM); + DeclareKindCase(GraphARM); #undef DeclareKindCase default: assert(false && "Unhandled type"); @@ -187,6 +189,8 @@ bool Type::operator==(const Type& other) const { DeclareKindCase(HitObjectNV); DeclareKindCase(TensorLayoutNV); DeclareKindCase(TensorViewNV); + DeclareKindCase(TensorARM); + DeclareKindCase(GraphARM); #undef DeclareKindCase default: assert(false && "Unhandled type"); @@ -247,6 +251,8 @@ size_t Type::ComputeHashValue(size_t hash, SeenTypes* seen) const { DeclareKindCase(HitObjectNV); DeclareKindCase(TensorLayoutNV); DeclareKindCase(TensorViewNV); + DeclareKindCase(TensorARM); + DeclareKindCase(GraphARM); #undef DeclareKindCase default: assert(false && "Unhandled type"); @@ -899,6 +905,91 @@ bool CooperativeVectorNV::IsSameImpl(const Type* that, components_ == mt->components_ && HasSameDecorations(that); } +TensorARM::TensorARM(const Type* elty, const uint32_t rank, + const uint32_t shape) + : Type(kTensorARM), element_type_(elty), rank_id_(rank), shape_id_(shape) { + assert(elty != nullptr); + if (shape != 0) { + assert(rank != 0); + } +} + +std::string TensorARM::str() const { + std::ostringstream oss; + oss << "tensor<" << element_type_->str() << ", id(" << rank_id_ << "), id(" + << shape_id_ << ")>"; + return oss.str(); +} + +size_t TensorARM::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { + hash = hash_combine(hash, rank_id_); + hash = hash_combine(hash, shape_id_); + return element_type_->ComputeHashValue(hash, seen); +} + +bool TensorARM::IsSameImpl(const Type* that, IsSameCache* seen) const { + const TensorARM* tt = that->AsTensorARM(); + if (!tt) return false; + return element_type_->IsSameImpl(tt->element_type_, seen) && + rank_id_ == tt->rank_id_ && shape_id_ == tt->shape_id_ && + HasSameDecorations(that); +} + +GraphARM::GraphARM(const uint32_t num_inputs, + const std::vector& io_types) + : Type(kGraphARM), num_inputs_(num_inputs), io_types_(io_types) { + assert(io_types.size() > 0); +} + +std::string GraphARM::str() const { + std::ostringstream oss; + oss << "graph<" << num_inputs_; + for (auto ioty : io_types_) { + oss << "," << ioty->str(); + } + oss << ">"; + return oss.str(); +} + +bool GraphARM::is_shaped() const { + // A graph is considered to be shaped if all its interface tensors are shaped + for (auto ioty : io_types_) { + auto tensor_type = ioty->AsTensorARM(); + assert(tensor_type); + if (!tensor_type->is_shaped()) { + return false; + } + } + return true; +} + +size_t GraphARM::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const { + hash = hash_combine(hash, num_inputs_); + for (auto ioty : io_types_) { + hash = ioty->ComputeHashValue(hash, seen); + } + return hash; +} + +bool GraphARM::IsSameImpl(const Type* that, IsSameCache* seen) const { + const GraphARM* og = that->AsGraphARM(); + if (!og) { + return false; + } + if (num_inputs_ != og->num_inputs_) { + return false; + } + if (io_types_.size() != og->io_types_.size()) { + return false; + } + for (size_t i = 0; i < io_types_.size(); i++) { + if (!io_types_[i]->IsSameImpl(og->io_types_[i], seen)) { + return false; + } + } + return true; +} + } // namespace analysis } // namespace opt } // namespace spvtools diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/types.h b/libs/bgfx/3rdparty/spirv-tools/source/opt/types.h index 9b12d5f..2dd6c75 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/types.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/types.h @@ -69,6 +69,8 @@ class RayQueryKHR; class HitObjectNV; class TensorLayoutNV; class TensorViewNV; +class TensorARM; +class GraphARM; // Abstract class for a SPIR-V type. It has a bunch of As() methods, // which is used as a way to probe the actual . @@ -114,6 +116,8 @@ class Type { kHitObjectNV, kTensorLayoutNV, kTensorViewNV, + kTensorARM, + kGraphARM, kLast }; @@ -220,6 +224,8 @@ class Type { DeclareCastMethod(HitObjectNV) DeclareCastMethod(TensorLayoutNV) DeclareCastMethod(TensorViewNV) + DeclareCastMethod(TensorARM) + DeclareCastMethod(GraphARM) #undef DeclareCastMethod protected: @@ -774,6 +780,56 @@ class CooperativeVectorNV : public Type { const uint32_t components_; }; +class TensorARM : public Type { + public: + TensorARM(const Type* elty, const uint32_t rank = 0, + const uint32_t shape = 0); + TensorARM(const TensorARM&) = default; + + std::string str() const override; + + TensorARM* AsTensorARM() override { return this; } + const TensorARM* AsTensorARM() const override { return this; } + + size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; + + const Type* element_type() const { return element_type_; } + uint32_t rank_id() const { return rank_id_; } + uint32_t shape_id() const { return shape_id_; } + bool is_ranked() const { return rank_id_ != 0; } + bool is_shaped() const { return shape_id_ != 0; } + + private: + bool IsSameImpl(const Type* that, IsSameCache*) const override; + + const Type* element_type_; + const uint32_t rank_id_; + const uint32_t shape_id_; +}; + +class GraphARM : public Type { + public: + GraphARM(const uint32_t num_inputs, const std::vector& io_types); + GraphARM(const GraphARM&) = default; + + std::string str() const override; + + GraphARM* AsGraphARM() override { return this; } + const GraphARM* AsGraphARM() const override { return this; } + + uint32_t num_inputs() const { return num_inputs_; } + const std::vector& io_types() const { return io_types_; } + bool is_shaped() const; + + size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override; + + private: + bool IsSameImpl(const Type* that, IsSameCache*) const override; + + const uint32_t num_inputs_; + const std::vector io_types_; +}; + #define DefineParameterlessType(type, name) \ class type : public Type { \ public: \ diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/upgrade_memory_model.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/upgrade_memory_model.cpp index 1b439a6..4af466d 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/upgrade_memory_model.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/upgrade_memory_model.cpp @@ -160,14 +160,38 @@ void UpgradeMemoryModel::UpgradeMemoryAndImages() { } switch (inst->opcode()) { - case spv::Op::OpLoad: + case spv::Op::OpLoad: { + Instruction* src_pointer = context()->get_def_use_mgr()->GetDef( + inst->GetSingleWordInOperand(0u)); + analysis::Type* src_type = + context()->get_type_mgr()->GetType(src_pointer->type_id()); + auto storage_class = src_type->AsPointer()->storage_class(); + if (storage_class == spv::StorageClass::Function || + storage_class == spv::StorageClass::Private) { + // If the buffer from function variable or private variable, flag + // NonPrivatePointer is unnecessary. + is_coherent = false; + } UpgradeFlags(inst, 1u, is_coherent, is_volatile, kVisibility, kMemory); break; - case spv::Op::OpStore: + } + case spv::Op::OpStore: { + Instruction* src_pointer = context()->get_def_use_mgr()->GetDef( + inst->GetSingleWordInOperand(0u)); + analysis::Type* src_type = + context()->get_type_mgr()->GetType(src_pointer->type_id()); + auto storage_class = src_type->AsPointer()->storage_class(); + if (storage_class == spv::StorageClass::Function || + storage_class == spv::StorageClass::Private) { + // If the buffer from function variable or private variable, flag + // NonPrivatePointer is unnecessary. + is_coherent = false; + } UpgradeFlags(inst, 2u, is_coherent, is_volatile, kAvailability, kMemory); break; + } case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: start_operand = inst->opcode() == spv::Op::OpCopyMemory ? 2u : 3u; @@ -366,6 +390,21 @@ std::pair UpgradeMemoryModel::TraceInstruction( indices.push_back(inst->GetSingleWordInOperand(i)); } break; + case spv::Op::OpLoad: + if (context()->get_type_mgr()->GetType(inst->type_id())->AsPointer()) { + analysis::Integer int_ty(32, false); + uint32_t int_id = + context()->get_type_mgr()->GetTypeInstruction(&int_ty); + const analysis::Constant* constant = + context()->get_constant_mgr()->GetConstant( + context()->get_type_mgr()->GetType(int_id), {0u}); + uint32_t constant_id = context() + ->get_constant_mgr() + ->GetDefiningInstruction(constant) + ->result_id(); + + indices.push_back(constant_id); + } default: break; } @@ -661,22 +700,29 @@ void UpgradeMemoryModel::UpgradeBarriers() { roots.push(e.GetSingleWordInOperand(1u)); if (context()->ProcessCallTreeFromRoots(CollectBarriers, &roots)) { for (auto barrier : barriers) { - // Add OutputMemoryKHR to the semantics of the barriers. + // Add OutputMemoryKHR to the semantics of the non-relaxed barriers. uint32_t semantics_id = barrier->GetSingleWordInOperand(2u); Instruction* semantics_inst = context()->get_def_use_mgr()->GetDef(semantics_id); analysis::Type* semantics_type = context()->get_type_mgr()->GetType(semantics_inst->type_id()); uint64_t semantics_value = GetIndexValue(semantics_inst); - const analysis::Constant* constant = - context()->get_constant_mgr()->GetConstant( - semantics_type, - {static_cast(semantics_value) | - uint32_t(spv::MemorySemanticsMask::OutputMemoryKHR)}); - barrier->SetInOperand(2u, {context() - ->get_constant_mgr() - ->GetDefiningInstruction(constant) - ->result_id()}); + const uint64_t memory_order_mask = + uint64_t(spv::MemorySemanticsMask::Acquire | + spv::MemorySemanticsMask::Release | + spv::MemorySemanticsMask::AcquireRelease | + spv::MemorySemanticsMask::SequentiallyConsistent); + if (semantics_value & memory_order_mask) { + const analysis::Constant* constant = + context()->get_constant_mgr()->GetConstant( + semantics_type, + {static_cast(semantics_value) | + uint32_t(spv::MemorySemanticsMask::OutputMemoryKHR)}); + barrier->SetInOperand(2u, {context() + ->get_constant_mgr() + ->GetDefiningInstruction(constant) + ->result_id()}); + } } } barriers.clear(); @@ -758,11 +804,13 @@ void UpgradeMemoryModel::UpgradeExtInst(Instruction* ext_inst) { InstructionBuilder builder( context(), where, IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping); + // TODO(1841): Handle id overflow. auto extract_0 = builder.AddCompositeExtract(element_type_id, ext_inst->result_id(), {0}); context()->ReplaceAllUsesWith(ext_inst->result_id(), extract_0->result_id()); // The extract's input was just changed to itself, so fix that. extract_0->SetInOperand(0u, {ext_inst->result_id()}); + // TODO(1841): Handle id overflow. auto extract_1 = builder.AddCompositeExtract(pointee_type_id, ext_inst->result_id(), {1}); builder.AddStore(ptr_id, extract_1->result_id()); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/opt/value_number_table.cpp b/libs/bgfx/3rdparty/spirv-tools/source/opt/value_number_table.cpp index 0c7e575..9f6863a 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/opt/value_number_table.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/opt/value_number_table.cpp @@ -143,8 +143,31 @@ uint32_t ValueNumberTable::AssignValueNumber(Instruction* inst) { } } - // TODO: Implement a normal form for opcodes that commute like integer - // addition. This will let us know that a+b is the same value as b+a. + // Apply normal form, so a+b == b+a + switch (value_ins.opcode()) { + case spv::Op::OpIAdd: + case spv::Op::OpFAdd: + case spv::Op::OpIMul: + case spv::Op::OpFMul: + case spv::Op::OpDot: + case spv::Op::OpLogicalEqual: + case spv::Op::OpLogicalNotEqual: + case spv::Op::OpLogicalOr: + case spv::Op::OpLogicalAnd: + case spv::Op::OpIEqual: + case spv::Op::OpINotEqual: + case spv::Op::OpBitwiseOr: + case spv::Op::OpBitwiseXor: + case spv::Op::OpBitwiseAnd: + if (value_ins.GetSingleWordInOperand(0) > + value_ins.GetSingleWordInOperand(1)) { + value_ins.SetInOperands( + {{SPV_OPERAND_TYPE_ID, {value_ins.GetSingleWordInOperand(1)}}, + {SPV_OPERAND_TYPE_ID, {value_ins.GetSingleWordInOperand(0)}}}); + } + default: + break; + } // Otherwise, we check if this value has been computed before. auto value_iterator = instruction_to_value_.find(value_ins); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/parsed_operand.cpp b/libs/bgfx/3rdparty/spirv-tools/source/parsed_operand.cpp index 649b9d6..5b4c68c 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/parsed_operand.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/parsed_operand.cpp @@ -59,7 +59,10 @@ void EmitNumericLiteral(std::ostream* out, const spv_parsed_instruction_t& inst, *out << spvtools::utils::FloatProxy( uint8_t(word & 0xFF)); break; - // TODO Bfloat16 + case SPV_FP_ENCODING_BFLOAT16: + *out << spvtools::utils::FloatProxy( + uint16_t(word & 0xFFFF)); + break; case SPV_FP_ENCODING_UNKNOWN: switch (operand.number_bit_width) { case 16: diff --git a/libs/bgfx/3rdparty/spirv-tools/source/table2.cpp b/libs/bgfx/3rdparty/spirv-tools/source/table2.cpp index 4559d77..dc1bff3 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/table2.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/table2.cpp @@ -372,4 +372,69 @@ bool GetExtensionFromString(const char* name, Extension* extension) { return false; } +// This is dirty copy of the spirv.hpp11 function +// TODO - Use a generated version of this function +const char* StorageClassToString(spv::StorageClass value) { + switch (value) { + case spv::StorageClass::UniformConstant: + return "UniformConstant"; + case spv::StorageClass::Input: + return "Input"; + case spv::StorageClass::Uniform: + return "Uniform"; + case spv::StorageClass::Output: + return "Output"; + case spv::StorageClass::Workgroup: + return "Workgroup"; + case spv::StorageClass::CrossWorkgroup: + return "CrossWorkgroup"; + case spv::StorageClass::Private: + return "Private"; + case spv::StorageClass::Function: + return "Function"; + case spv::StorageClass::Generic: + return "Generic"; + case spv::StorageClass::PushConstant: + return "PushConstant"; + case spv::StorageClass::AtomicCounter: + return "AtomicCounter"; + case spv::StorageClass::Image: + return "Image"; + case spv::StorageClass::StorageBuffer: + return "StorageBuffer"; + case spv::StorageClass::TileImageEXT: + return "TileImageEXT"; + case spv::StorageClass::TileAttachmentQCOM: + return "TileAttachmentQCOM"; + case spv::StorageClass::NodePayloadAMDX: + return "NodePayloadAMDX"; + case spv::StorageClass::CallableDataKHR: + return "CallableDataKHR"; + case spv::StorageClass::IncomingCallableDataKHR: + return "IncomingCallableDataKHR"; + case spv::StorageClass::RayPayloadKHR: + return "RayPayloadKHR"; + case spv::StorageClass::HitAttributeKHR: + return "HitAttributeKHR"; + case spv::StorageClass::IncomingRayPayloadKHR: + return "IncomingRayPayloadKHR"; + case spv::StorageClass::ShaderRecordBufferKHR: + return "ShaderRecordBufferKHR"; + case spv::StorageClass::PhysicalStorageBuffer: + return "PhysicalStorageBuffer"; + case spv::StorageClass::HitObjectAttributeNV: + return "HitObjectAttributeNV"; + case spv::StorageClass::TaskPayloadWorkgroupEXT: + return "TaskPayloadWorkgroupEXT"; + case spv::StorageClass::CodeSectionINTEL: + return "CodeSectionINTEL"; + case spv::StorageClass::DeviceOnlyINTEL: + return "DeviceOnlyINTEL"; + case spv::StorageClass::HostOnlyINTEL: + return "HostOnlyINTEL"; + default: + return "Unknown"; + } +} + } // namespace spvtools diff --git a/libs/bgfx/3rdparty/spirv-tools/source/table2.h b/libs/bgfx/3rdparty/spirv-tools/source/table2.h index e3731c4..1218fb2 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/table2.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/table2.h @@ -256,5 +256,8 @@ bool GetExtensionFromString(const char* str, Extension* extension); // Returns text string corresponding to |extension|. const char* ExtensionToString(Extension extension); +/// Used to provide better error message +const char* StorageClassToString(spv::StorageClass value); + } // namespace spvtools #endif // SOURCE_TABLE2_H_ diff --git a/libs/bgfx/3rdparty/spirv-tools/source/text_handler.cpp b/libs/bgfx/3rdparty/spirv-tools/source/text_handler.cpp index 1f1f1e8..df0cc39 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/text_handler.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/text_handler.cpp @@ -336,7 +336,7 @@ spv_result_t AssemblyContext::recordTypeDefinition( return diagnostic() << "Invalid OpTypeFloat instruction"; spv_fp_encoding_t enc = SPV_FP_ENCODING_UNKNOWN; if (pInst->words.size() >= 4) { - const spvtools::OperandDesc* desc; + const spvtools::OperandDesc* desc = nullptr; spv_result_t status = spvtools::LookupOperand(SPV_OPERAND_TYPE_FPENCODING, pInst->words[3], &desc); if (status == SPV_SUCCESS) { diff --git a/libs/bgfx/3rdparty/spirv-tools/source/util/hex_float.h b/libs/bgfx/3rdparty/spirv-tools/source/util/hex_float.h index 83b1c09..9bb3203 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/util/hex_float.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/util/hex_float.h @@ -103,6 +103,34 @@ class Float16 { uint16_t val; }; +class BFloat16 { + public: + BFloat16(uint16_t v) : val(v) {} + BFloat16() = default; + BFloat16(const BFloat16& other) { val = other.val; } + + // Exponent mask: 0x7F80, Mantissa mask: 0x007F + static bool isNan(const BFloat16& val) { + return ((val.val & 0x7F80) == 0x7F80) && ((val.val & 0x007F) != 0); + } + static bool isInfinity(const BFloat16& val) { + return ((val.val & 0x7F80) == 0x7F80) && ((val.val & 0x007F) == 0); + } + + uint16_t get_value() const { return val; } + + // a sign bit of 0, and an all 1 mantissa. + static BFloat16 max() { return BFloat16(0x7F7F); } + // a sign bit of 1, and an all 1 mantissa. + static BFloat16 lowest() { return BFloat16(0xFF7F); } + + private: + // 15: Sign + // 14-7: Exponent + // 6-0: Mantissa + uint16_t val; +}; + // To specialize this type, you must override uint_type to define // an unsigned integer that can fit your floating point type. // You must also add a isNan function that returns true if @@ -212,6 +240,24 @@ struct FloatProxyTraits { static uint32_t width() { return 16u; } }; +template <> +struct FloatProxyTraits { + using uint_type = uint16_t; + static bool isNan(BFloat16 f) { return BFloat16::isNan(f); } + // Returns true if the given value is any kind of infinity. + static bool isInfinity(BFloat16 f) { return BFloat16::isInfinity(f); } + // Returns the maximum normal value. + static BFloat16 max() { return BFloat16::max(); } + // Returns the lowest normal value. + static BFloat16 lowest() { return BFloat16::lowest(); } + // Returns the value as the native floating point format. + static BFloat16 getAsFloat(const uint_type& t) { return BFloat16(t); } + // Returns the bits from the given floating pointer number. + static uint_type getBitsFromFloat(const BFloat16& t) { return t.get_value(); } + // Returns the bitwidth. + static uint32_t width() { return 16u; } +}; + // Since copying a floating point number (especially if it is NaN) // does not guarantee that bits are preserved, this class lets us // store the type and use it as a float when necessary. @@ -403,6 +449,23 @@ struct HexFloatTraits> { static const uint_type NaN_pattern = 0x7c00; }; +// Traits for BFloat16. +// 1 sign bit, 7 exponent bits, 8 fractional bits. +template <> +struct HexFloatTraits> { + using uint_type = uint16_t; + using int_type = int16_t; + using underlying_type = FloatProxy; + using underlying_typetraits = FloatProxyTraits; + using native_type = uint16_t; + static const uint_type num_used_bits = 16; + static const uint_type num_exponent_bits = 8; + static const uint_type num_fraction_bits = 7; + static const uint_type exponent_bias = 127; + static const bool has_infinity = true; + static const uint_type NaN_pattern = 0x7F80; +}; + enum class round_direction { kToZero, kToNearestEven, @@ -1038,6 +1101,26 @@ ParseNormalFloat, HexFloatTraits>>( } return is; } + +// Same flow as Float16 +template <> +inline std::istream& +ParseNormalFloat, HexFloatTraits>>( + std::istream& is, bool negate_value, + HexFloat, HexFloatTraits>>& + value) { + HexFloat> float_val(0.0f); + ParseNormalFloat(is, negate_value, float_val); + + float_val.castTo(value, round_direction::kToZero); + + if (BFloat16::isInfinity(value.value().getAsFloat())) { + value.set_value(value.isNegative() ? BFloat16::lowest() : BFloat16::max()); + is.setstate(std::ios_base::failbit); + } + return is; +} + // Specialization of ParseNormalFloat for FloatProxy values. // This will parse the float as it were a 32-bit floating point number, // and then round it down to fit into a Float8_E4M3 value. @@ -1468,6 +1551,13 @@ inline std::ostream& operator<<(std::ostream& os, return os; } +template <> +inline std::ostream& operator<< (std::ostream& os, + const FloatProxy& value) { + os << HexFloat>(value); + return os; +} + template <> inline std::ostream& operator<< ( std::ostream& os, const FloatProxy& value) { diff --git a/libs/bgfx/3rdparty/spirv-tools/source/util/parse_number.cpp b/libs/bgfx/3rdparty/spirv-tools/source/util/parse_number.cpp index 3aa0752..117e6f2 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/util/parse_number.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/util/parse_number.cpp @@ -185,7 +185,15 @@ EncodeNumberStatus ParseAndEncodeFloatingPointNumber( emit(static_cast(hVal.value().getAsFloat().get_value())); return EncodeNumberStatus::kSuccess; } break; - case SPV_FP_ENCODING_BFLOAT16: // FIXME this likely needs separate handling + case SPV_FP_ENCODING_BFLOAT16: { + HexFloat> hVal(0); + if (!ParseNumber(text, &hVal)) { + ErrorMsgStream(error_msg) << "Invalid bfloat16 literal: " << text; + return EncodeNumberStatus::kInvalidText; + } + emit(static_cast(hVal.value().getAsFloat().get_value())); + return EncodeNumberStatus::kSuccess; + } break; case SPV_FP_ENCODING_IEEE754_BINARY16: { HexFloat> hVal(0); if (!ParseNumber(text, &hVal)) { diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate.cpp index f553a26..90bb480 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate.cpp @@ -64,9 +64,12 @@ void RegisterExtension(ValidationState_t& _, spv_result_t ProcessExtensions(void* user_data, const spv_parsed_instruction_t* inst) { const spv::Op opcode = static_cast(inst->opcode); - if (opcode == spv::Op::OpCapability) return SPV_SUCCESS; + if (opcode == spv::Op::OpCapability || + opcode == spv::Op::OpConditionalCapabilityINTEL) + return SPV_SUCCESS; - if (opcode == spv::Op::OpExtension) { + if (opcode == spv::Op::OpExtension || + opcode == spv::Op::OpConditionalExtensionINTEL) { ValidationState_t& _ = *(reinterpret_cast(user_data)); RegisterExtension(_, inst); return SPV_SUCCESS; @@ -115,10 +118,11 @@ spv_result_t ValidateEntryPoints(ValidationState_t& _) { _.ComputeFunctionToEntryPointMapping(); _.ComputeRecursiveEntryPoints(); - if (_.entry_points().empty() && !_.HasCapability(spv::Capability::Linkage)) { + if (_.entry_points().empty() && !_.HasCapability(spv::Capability::Linkage) && + !_.HasCapability(spv::Capability::GraphARM)) { return _.diag(SPV_ERROR_INVALID_BINARY, nullptr) << "No OpEntryPoint instruction was found. This is only allowed if " - "the Linkage capability is being used."; + "the Linkage or GraphARM capability is being used."; } for (const auto& entry_point : _.entry_points()) { @@ -151,6 +155,16 @@ spv_result_t ValidateEntryPoints(ValidationState_t& _) { return SPV_SUCCESS; } +spv_result_t ValidateGraphEntryPoints(ValidationState_t& _) { + if (_.graph_entry_points().empty() && + _.HasCapability(spv::Capability::GraphARM)) { + return _.diag(SPV_ERROR_INVALID_BINARY, nullptr) + << "No OpGraphEntryPointARM instruction was found but the GraphARM " + "capability is declared."; + } + return SPV_SUCCESS; +} + spv_result_t ValidateBinaryUsingContextAndValidationState( const spv_context_t& context, const uint32_t* words, const size_t num_words, spv_diagnostic* pDiagnostic, ValidationState_t* vstate) { @@ -217,43 +231,59 @@ spv_result_t ValidateBinaryUsingContextAndValidationState( // able to, briefly, de-const the instruction. Instruction* inst = const_cast(&instruction); - if (inst->opcode() == spv::Op::OpEntryPoint) { - const auto entry_point = inst->GetOperandAs(1); - const auto execution_model = inst->GetOperandAs(0); - const std::string desc_name = inst->GetOperandAs(2); + if ((inst->opcode() == spv::Op::OpEntryPoint) || + (inst->opcode() == spv::Op::OpConditionalEntryPointINTEL)) { + const int i_model = inst->opcode() == spv::Op::OpEntryPoint ? 0 : 1; + const int i_point = inst->opcode() == spv::Op::OpEntryPoint ? 1 : 2; + const int i_name = inst->opcode() == spv::Op::OpEntryPoint ? 2 : 3; + const int min_num_operands = + inst->opcode() == spv::Op::OpEntryPoint ? 3 : 4; + + const auto entry_point = inst->GetOperandAs(i_point); + const auto execution_model = + inst->GetOperandAs(i_model); + const std::string desc_name = inst->GetOperandAs(i_name); ValidationState_t::EntryPointDescription desc; desc.name = desc_name; std::vector interfaces; - for (size_t j = 3; j < inst->operands().size(); ++j) + for (size_t j = min_num_operands; j < inst->operands().size(); ++j) desc.interfaces.push_back(inst->word(inst->operand(j).offset)); vstate->RegisterEntryPoint(entry_point, execution_model, std::move(desc)); - if (visited_entry_points.size() > 0) { - for (const Instruction* check_inst : visited_entry_points) { - const auto check_execution_model = - check_inst->GetOperandAs(0); - const std::string check_name = - check_inst->GetOperandAs(2); - - if (desc_name == check_name && - execution_model == check_execution_model) { - return vstate->diag(SPV_ERROR_INVALID_DATA, inst) - << "2 Entry points cannot share the same name and " - "ExecutionMode."; + if (inst->opcode() == spv::Op::OpEntryPoint) { + // conditional entry points are allowed to share the same name and + // exec mode + if (visited_entry_points.size() > 0) { + for (const Instruction* check_inst : visited_entry_points) { + const auto check_execution_model = + check_inst->GetOperandAs(i_model); + const std::string check_name = + check_inst->GetOperandAs(i_name); + + if (desc_name == check_name && + execution_model == check_execution_model) { + return vstate->diag(SPV_ERROR_INVALID_DATA, inst) + << "2 Entry points cannot share the same name and " + "ExecutionMode."; + } } } + visited_entry_points.push_back(inst); } - visited_entry_points.push_back(inst); has_mask_task_nv |= (execution_model == spv::ExecutionModel::TaskNV || execution_model == spv::ExecutionModel::MeshNV); has_mask_task_ext |= (execution_model == spv::ExecutionModel::TaskEXT || execution_model == spv::ExecutionModel::MeshEXT); } + if (inst->opcode() == spv::Op::OpGraphEntryPointARM) { + const auto graph = inst->GetOperandAs(1); + vstate->RegisterGraphEntryPoint(graph); + } if (inst->opcode() == spv::Op::OpFunctionCall) { if (!vstate->in_function_body()) { return vstate->diag(SPV_ERROR_INVALID_LAYOUT, &instruction) @@ -299,6 +329,10 @@ spv_result_t ValidateBinaryUsingContextAndValidationState( return vstate->diag(SPV_ERROR_INVALID_LAYOUT, nullptr) << "Missing OpFunctionEnd at end of module."; + if (vstate->graph_definition_region() != kGraphDefinitionOutside) + return vstate->diag(SPV_ERROR_INVALID_LAYOUT, nullptr) + << "Missing OpGraphEndARM at end of module."; + if (vstate->HasCapability(spv::Capability::BindlessTextureNV) && !vstate->has_samplerimage_variable_address_mode_specified()) return vstate->diag(SPV_ERROR_INVALID_LAYOUT, nullptr) @@ -314,7 +348,7 @@ spv_result_t ValidateBinaryUsingContextAndValidationState( if (auto error = ValidateForwardDecls(*vstate)) return error; // Calculate reachability after all the blocks are parsed, but early that it - // can be relied on in subsequent pases. + // can be relied on in subsequent passes. ReachabilityPass(*vstate); // ID usage needs be handled in its own iteration of the instructions, @@ -368,6 +402,7 @@ spv_result_t ValidateBinaryUsingContextAndValidationState( if (auto error = MeshShadingPass(*vstate, &instruction)) return error; if (auto error = TensorLayoutPass(*vstate, &instruction)) return error; if (auto error = TensorPass(*vstate, &instruction)) return error; + if (auto error = GraphPass(*vstate, &instruction)) return error; if (auto error = InvalidTypePass(*vstate, &instruction)) return error; } @@ -377,6 +412,7 @@ spv_result_t ValidateBinaryUsingContextAndValidationState( if (auto error = ValidateAdjacency(*vstate)) return error; if (auto error = ValidateEntryPoints(*vstate)) return error; + if (auto error = ValidateGraphEntryPoints(*vstate)) return error; // CFG checks are performed after the binary has been parsed // and the CFGPass has collected information about the control flow if (auto error = PerformCfgChecks(*vstate)) return error; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate.h b/libs/bgfx/3rdparty/spirv-tools/source/val/validate.h index 2b4dee2..7c6faa1 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate.h @@ -195,8 +195,8 @@ spv_result_t NonUniformPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of debug instructions. spv_result_t DebugPass(ValidationState_t& _, const Instruction* inst); -// Validates that capability declarations use operands allowed in the current -// context. +/// Validates that capability declarations use operands allowed in the current +/// context. spv_result_t CapabilityPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of primitive instructions. @@ -226,6 +226,9 @@ spv_result_t MeshShadingPass(ValidationState_t& _, const Instruction* inst); /// Validates correctness of tensor instructions. spv_result_t TensorPass(ValidationState_t& _, const Instruction* inst); +/// Validates correctness of graph instructions. +spv_result_t GraphPass(ValidationState_t& _, const Instruction* inst); + /// Validates correctness of certain special type instructions. spv_result_t InvalidTypePass(ValidationState_t& _, const Instruction* inst); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_annotation.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_annotation.cpp index eaca8f0..2545f2f 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_annotation.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_annotation.cpp @@ -333,6 +333,14 @@ spv_result_t ValidateDecorate(ValidationState_t& _, const Instruction* inst) { } spv_result_t ValidateDecorateId(ValidationState_t& _, const Instruction* inst) { + const auto target_id = inst->GetOperandAs(0); + const auto target = _.FindDef(target_id); + if (target && spv::Op::OpDecorationGroup == target->opcode()) { + return _.diag(SPV_ERROR_INVALID_ID, inst) + << "OpMemberDecorate Target " << _.getIdName(target_id) + << " must not be an OpDecorationGroup instruction."; + } + const auto decoration = inst->GetOperandAs(1); if (!DecorationTakesIdParameters(decoration)) { return _.diag(SPV_ERROR_INVALID_ID, inst) @@ -340,6 +348,20 @@ spv_result_t ValidateDecorateId(ValidationState_t& _, const Instruction* inst) { "OpDecorateId"; } + for (uint32_t i = 2; i < inst->operands().size(); ++i) { + const auto param_id = inst->GetOperandAs(i); + const auto param = _.FindDef(param_id); + + // Both target and param are elements of ordered_instructions we can + // determine their relative positions in the SPIR-V module by comparing + // pointers. + if (target <= param) { + return _.diag(SPV_ERROR_INVALID_ID, inst) + << "Parameter " << _.getIdName(param_id) + << " must appear earlier in the binary than the target"; + } + } + // No member decorations take id parameters, so we don't bother checking if // we are using a member only decoration here. @@ -388,8 +410,7 @@ spv_result_t ValidateDecorationGroup(ValidationState_t& _, if (use->opcode() != spv::Op::OpDecorate && use->opcode() != spv::Op::OpGroupDecorate && use->opcode() != spv::Op::OpGroupMemberDecorate && - use->opcode() != spv::Op::OpName && - use->opcode() != spv::Op::OpDecorateId && !use->IsNonSemantic()) { + use->opcode() != spv::Op::OpName && !use->IsNonSemantic()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Result id of OpDecorationGroup can only " << "be targeted by OpName, OpGroupDecorate, " diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_atomics.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_atomics.cpp index 990ed31..510960b 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_atomics.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_atomics.cpp @@ -388,27 +388,6 @@ spv_result_t AtomicsPass(ValidationState_t& _, const Instruction* inst) { if (auto error = ValidateMemorySemantics( _, inst, unequal_semantics_index, memory_scope)) return error; - - // Volatile bits must match for equal and unequal semantics. Previous - // checks guarantee they are 32-bit constants, but we need to recheck - // whether they are evaluatable constants. - bool is_int32 = false; - bool is_equal_const = false; - bool is_unequal_const = false; - uint32_t equal_value = 0; - uint32_t unequal_value = 0; - std::tie(is_int32, is_equal_const, equal_value) = _.EvalInt32IfConst( - inst->GetOperandAs(equal_semantics_index)); - std::tie(is_int32, is_unequal_const, unequal_value) = - _.EvalInt32IfConst( - inst->GetOperandAs(unequal_semantics_index)); - if (is_equal_const && is_unequal_const && - ((equal_value & uint32_t(spv::MemorySemanticsMask::Volatile)) ^ - (unequal_value & uint32_t(spv::MemorySemanticsMask::Volatile)))) { - return _.diag(SPV_ERROR_INVALID_ID, inst) - << "Volatile mask setting must match for Equal and Unequal " - "memory semantics"; - } } if (opcode == spv::Op::OpAtomicStore) { diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_barriers.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_barriers.cpp index 0abd5c8..b7d2ea0 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_barriers.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_barriers.cpp @@ -45,10 +45,10 @@ spv_result_t BarriersPass(ValidationState_t& _, const Instruction* inst) { model != spv::ExecutionModel::MeshNV) { if (message) { *message = - "OpControlBarrier requires one of the following " - "Execution " - "Models: TessellationControl, GLCompute, Kernel, " - "MeshNV or TaskNV"; + "In SPIR-V 1.2 or earlier, OpControlBarrier requires " + "one of the following " + "Execution Models: TessellationControl, GLCompute, " + "Kernel, MeshNV or TaskNV"; } return false; } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_bitwise.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_bitwise.cpp index 4acc998..3f739b4 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_bitwise.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_bitwise.cpp @@ -39,9 +39,11 @@ spv_result_t ValidateBaseType(ValidationState_t& _, const Instruction* inst, if (_.GetBitWidth(base_type) != 32 && !_.options()->allow_vulkan_32_bit_bitwise) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << _.VkErrorID(4781) + << _.VkErrorID(10824) << "Expected 32-bit int type for Base operand: " - << spvOpcodeString(opcode); + << spvOpcodeString(opcode) + << _.MissingFeature("maintenance9 feature", + "--allow-vulkan-32-bit-bitwise", false); } } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_builtins.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_builtins.cpp index d25ebaf..ba02047 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_builtins.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_builtins.cpp @@ -17,21 +17,22 @@ // Validates correctness of built-in variables. #include +#include #include #include #include #include #include -#include #include +#include #include #include "source/opcode.h" #include "source/spirv_target_env.h" -#include "source/util/bitutils.h" #include "source/val/instruction.h" #include "source/val/validate.h" #include "source/val/validation_state.h" +#include "spirv/unified1/spirv.hpp11" namespace spvtools { namespace val { @@ -373,6 +374,18 @@ class BuiltInsValidator { spv_result_t ValidateMeshShadingEXTBuiltinsAtDefinition( const Decoration& decoration, const Instruction& inst); + // Used as a common method for validating MeshEXT builtins + spv_result_t ValidateMeshBuiltinInterfaceRules( + const Decoration& decoration, const Instruction& inst, + spv::Op scalar_type, const Instruction& referenced_from_inst); + spv_result_t ValidatePrimitiveShadingRateInterfaceRules( + const Decoration& decoration, const Instruction& inst, + const Instruction& referenced_from_inst); + // Builtin that needs check incase **not** used with MeshEXT + spv_result_t ValidateNonMeshInterfaceRules( + const Decoration& decoration, const Instruction& inst, + const Instruction& referenced_from_inst); + // The following section contains functions which are called when id defined // by |referenced_inst| is // 1. referenced by |referenced_from_inst| @@ -590,8 +603,9 @@ class BuiltInsValidator { spv_result_t ValidateBool( const Decoration& decoration, const Instruction& inst, const std::function& diag); - spv_result_t ValidateBlockBoolOrArrayedBool( + spv_result_t ValidateBlockTypeOrArrayedType( const Decoration& decoration, const Instruction& inst, + bool& present_in_block, spv::Op expected_scalar_type, const std::function& diag); spv_result_t ValidateI( const Decoration& decoration, const Instruction& inst, @@ -675,20 +689,50 @@ class BuiltInsValidator { // UniformConstant". std::string GetStorageClassDesc(const Instruction& inst) const; + uint64_t GetArrayLength(uint32_t interface_var_id); + // Updates inner working of the class. Is called sequentially for every // instruction. void Update(const Instruction& inst); - // Check if "inst" is an interface variable - // or type of a interface varibale of any mesh entry point - bool isMeshInterfaceVar(const Instruction& inst) { - auto getUnderlyingTypeId = [&](const Instruction* ifxVar) { - auto pointerTypeInst = _.FindDef(ifxVar->type_id()); - auto typeInst = _.FindDef(pointerTypeInst->GetOperandAs(2)); - while (typeInst->opcode() == spv::Op::OpTypeArray) { - typeInst = _.FindDef(typeInst->GetOperandAs(1)); + bool IsBulitinInEntryPoint(const Instruction& inst, uint32_t entry_point) { + auto get_underlying_type_id = [&](const Instruction* ifx_var) { + auto pointer_type_inst = _.FindDef(ifx_var->type_id()); + auto type_inst = _.FindDef(pointer_type_inst->GetOperandAs(2)); + while (type_inst->opcode() == spv::Op::OpTypeArray) { + type_inst = _.FindDef(type_inst->GetOperandAs(1)); }; - return typeInst->id(); + return type_inst->id(); + }; + + for (const auto& desc : _.entry_point_descriptions(entry_point)) { + for (auto interface : desc.interfaces) { + if (inst.opcode() == spv::Op::OpTypeStruct) { + auto varInst = _.FindDef(interface); + if (inst.id() == get_underlying_type_id(varInst)) { + return true; + } + } else if (inst.id() == interface) { + return true; + } + } + } + return false; + } + + // Check if "inst" is an interface variable or type of a interface varibale + // of any mesh entry point. Populate entry_point_interface_id with all + // entry points and interface variables that refer to the "inst" + bool IsMeshInterfaceVar( + const Instruction& inst, + std::map& entry_point_interface_id) { + auto get_underlying_type_id = [&](const Instruction* ifx_var) { + auto pointer_type_inst = _.FindDef(ifx_var->type_id()); + auto type_inst = _.FindDef(pointer_type_inst->GetOperandAs(2)); + while (type_inst->opcode() == spv::Op::OpTypeArray) { + type_inst = _.FindDef(type_inst->GetOperandAs(1)); + }; + return type_inst->id(); }; for (const uint32_t entry_point : _.entry_points()) { @@ -699,15 +743,19 @@ class BuiltInsValidator { for (auto interface : desc.interfaces) { if (inst.opcode() == spv::Op::OpTypeStruct) { auto varInst = _.FindDef(interface); - if (inst.id() == getUnderlyingTypeId(varInst)) return true; + if (inst.id() == get_underlying_type_id(varInst)) { + entry_point_interface_id[entry_point] = interface; + break; + } } else if (inst.id() == interface) { - return true; + entry_point_interface_id[entry_point] = interface; + break; } } } } } - return false; + return !entry_point_interface_id.empty(); } ValidationState_t& _; @@ -730,6 +778,10 @@ class BuiltInsValidator { // Execution models with which the current function can be called. std::set execution_models_; + + // For Builtin that can only be declared once in an entry point, keep track if + // the entry point has it already + std::set cull_primitive_entry_points_; }; void BuiltInsValidator::Update(const Instruction& inst) { @@ -807,6 +859,29 @@ std::string BuiltInsValidator::GetStorageClassDesc( return ss.str(); } +uint64_t BuiltInsValidator::GetArrayLength(uint32_t interface_var_id) { + uint32_t underlying_type; + spv::StorageClass storage_class; + uint64_t array_len = -1; + const Instruction* inst = _.FindDef(interface_var_id); + if (inst->opcode() != spv::Op::OpVariable) { + return -1; + } + + if (!_.GetPointerTypeInfo(inst->type_id(), &underlying_type, + &storage_class)) { + return 0; + } + if (_.GetIdOpcode(underlying_type) == spv::Op::OpTypeArray) { + // Get the array length + const auto length_id = _.FindDef(underlying_type)->word(3u); + if (!_.EvalConstantValUint64(length_id, &array_len)) { + return 0; + } + } + return array_len; +} + spv_result_t BuiltInsValidator::ValidateBool( const Decoration& decoration, const Instruction& inst, const std::function& diag) { @@ -823,25 +898,50 @@ spv_result_t BuiltInsValidator::ValidateBool( return SPV_SUCCESS; } -spv_result_t BuiltInsValidator::ValidateBlockBoolOrArrayedBool( - const Decoration& decoration, const Instruction& inst, +spv_result_t BuiltInsValidator::ValidateBlockTypeOrArrayedType( + const Decoration& decoration, const Instruction& inst, bool& isBlock, + spv::Op expected_scalar_type, const std::function& diag) { uint32_t underlying_type = 0; + int64_t array_len = -1; + isBlock = true; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } // Strip the array, if present. if (_.GetIdOpcode(underlying_type) == spv::Op::OpTypeArray) { + // Get the array length + const auto length_id = _.FindDef(underlying_type)->word(3u); + if (!_.EvalConstantValInt64(length_id, &array_len)) { + return diag(GetDefinitionDesc(decoration, inst) + + " Failed to find the array length."); + } underlying_type = _.FindDef(underlying_type)->word(2u); + isBlock = false; } else if (!_.HasDecoration(inst.id(), spv::Decoration::Block)) { // If not in array, and bool is in a struct, must be in a Block struct return diag(GetDefinitionDesc(decoration, inst) + " Scalar boolean must be in a Block."); } - if (!_.IsBoolScalarType(underlying_type)) { - return diag(GetDefinitionDesc(decoration, inst) + " is not a bool scalar."); + switch (expected_scalar_type) { + case spv::Op::OpTypeBool: + if (!_.IsBoolScalarType(underlying_type)) { + return diag(GetDefinitionDesc(decoration, inst) + + " is not a bool scalar."); + } + break; + case spv::Op::OpTypeInt: + if (!_.IsIntScalarType(underlying_type)) { + return diag(GetDefinitionDesc(decoration, inst) + + " is not an integer scalar."); + } + break; + default: + assert(0 && "Unhandled scalar type"); + return diag(GetDefinitionDesc(decoration, inst) + + " is not a recognized scalar type."); } return SPV_SUCCESS; @@ -2188,49 +2288,6 @@ spv_result_t BuiltInsValidator::ValidatePositionAtReference( spv_result_t BuiltInsValidator::ValidatePrimitiveIdAtDefinition( const Decoration& decoration, const Instruction& inst) { - if (spvIsVulkanEnv(_.context()->target_env)) { - // PrimitiveId can be a per-primitive variable for mesh shader stage. - // In such cases variable will have an array of 32-bit integers. - if (decoration.struct_member_index() != Decoration::kInvalidMember) { - // This must be a 32-bit int scalar. - if (spv_result_t error = ValidateI32( - decoration, inst, - [this, &inst](const std::string& message) -> spv_result_t { - return _.diag(SPV_ERROR_INVALID_DATA, &inst) - << _.VkErrorID(4337) - << "According to the Vulkan spec BuiltIn PrimitiveId " - "variable needs to be a 32-bit int scalar. " - << message; - })) { - return error; - } - } else { - if (spv_result_t error = ValidateOptionalArrayedI32( - decoration, inst, - [this, &inst](const std::string& message) -> spv_result_t { - return _.diag(SPV_ERROR_INVALID_DATA, &inst) - << _.VkErrorID(4337) - << "According to the Vulkan spec BuiltIn PrimitiveId " - "variable needs to be a 32-bit int scalar. " - << message; - })) { - return error; - } - } - - if (_.HasCapability(spv::Capability::MeshShadingEXT)) { - if (isMeshInterfaceVar(inst) && - !_.HasDecoration(inst.id(), spv::Decoration::PerPrimitiveEXT)) { - return _.diag(SPV_ERROR_INVALID_DATA, &inst) - << _.VkErrorID(7040) - << "According to the Vulkan spec the variable decorated with " - "Builtin PrimitiveId within the MeshEXT Execution Model must " - "also be decorated with the PerPrimitiveEXT decoration. "; - } - } - } - - // Seed at reference checks with this built-in. return ValidatePrimitiveIdAtReference(decoration, inst, inst, inst); } @@ -2297,6 +2354,27 @@ spv_result_t BuiltInsValidator::ValidatePrimitiveIdAtReference( referenced_from_inst, std::placeholders::_1)); } + if (!_.HasCapability(spv::Capability::MeshShadingEXT) && + !_.HasCapability(spv::Capability::MeshShadingNV) && + !_.HasCapability(spv::Capability::Geometry) && + !_.HasCapability(spv::Capability::Tessellation)) { + id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( + &BuiltInsValidator::ValidateNotCalledWithExecutionModel, this, 4333, + "Vulkan spec doesn't allow BuiltIn PrimitiveId to be used for " + "variables in the Fragment execution model unless it declares " + "Geometry, Tessellation, or MeshShader capabilities.", + spv::ExecutionModel::Fragment, decoration, built_in_inst, + referenced_from_inst, std::placeholders::_1)); + } + + id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( + &BuiltInsValidator::ValidateMeshBuiltinInterfaceRules, this, decoration, + built_in_inst, spv::Op::OpTypeInt, std::placeholders::_1)); + + id_to_at_reference_checks_[referenced_from_inst.id()].push_back( + std::bind(&BuiltInsValidator::ValidateNonMeshInterfaceRules, this, + decoration, built_in_inst, std::placeholders::_1)); + for (const spv::ExecutionModel execution_model : execution_models_) { switch (execution_model) { case spv::ExecutionModel::Fragment: @@ -2593,6 +2671,13 @@ spv_result_t BuiltInsValidator::ValidateTessLevelOuterAtDefinition( })) { return error; } + + if (!_.HasDecoration(inst.id(), spv::Decoration::Patch)) { + return _.diag(SPV_ERROR_INVALID_DATA, &inst) + << _.VkErrorID(10880) + << "BuiltIn TessLevelOuter variable needs to also have a Patch " + "decoration."; + } } // Seed at reference checks with this built-in. @@ -2607,13 +2692,20 @@ spv_result_t BuiltInsValidator::ValidateTessLevelInnerAtDefinition( [this, &inst](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(4397) - << "According to the Vulkan spec BuiltIn TessLevelOuter " + << "According to the Vulkan spec BuiltIn TessLevelInner " "variable needs to be a 2-component 32-bit float " "array. " << message; })) { return error; } + + if (!_.HasDecoration(inst.id(), spv::Decoration::Patch)) { + return _.diag(SPV_ERROR_INVALID_DATA, &inst) + << _.VkErrorID(10880) + << "BuiltIn TessLevelInner variable needs to also have a Patch " + "decoration."; + } } // Seed at reference checks with this built-in. @@ -2796,67 +2888,180 @@ spv_result_t BuiltInsValidator::ValidateVertexIndexAtReference( return SPV_SUCCESS; } -spv_result_t BuiltInsValidator::ValidateLayerOrViewportIndexAtDefinition( - const Decoration& decoration, const Instruction& inst) { - if (spvIsVulkanEnv(_.context()->target_env)) { - // This can be a per-primitive variable for mesh shader stage. - // In such cases variable will have an array of 32-bit integers. - if (decoration.struct_member_index() != Decoration::kInvalidMember) { - // This must be a 32-bit int scalar. - if (spv_result_t error = ValidateI32( - decoration, inst, - [this, &decoration, - &inst](const std::string& message) -> spv_result_t { - uint32_t vuid = - (decoration.builtin() == spv::BuiltIn::Layer) ? 4276 : 4408; +typedef struct { + uint32_t array_type; + uint32_t array_size; + uint32_t block_array_size; + uint32_t perprim_deco; +} MeshBuiltinVUIDs; + +spv_result_t BuiltInsValidator::ValidateMeshBuiltinInterfaceRules( + const Decoration& decoration, const Instruction& inst, spv::Op scalar_type, + const Instruction& referenced_from_inst) { + if (function_id_) { + if (execution_models_.count(spv::ExecutionModel::MeshEXT)) { + bool is_block = false; + const spv::BuiltIn builtin = decoration.builtin(); + + static const std::unordered_map + mesh_vuid_map = {{ + {spv::BuiltIn::CullPrimitiveEXT, {7036, 10589, 10590, 7038}}, + {spv::BuiltIn::PrimitiveId, {10595, 10596, 10597, 7040}}, + {spv::BuiltIn::Layer, {10592, 10593, 10594, 7039}}, + {spv::BuiltIn::ViewportIndex, {10601, 10602, 10603, 7060}}, + {spv::BuiltIn::PrimitiveShadingRateKHR, + {10598, 10599, 10600, 7059}}, + }}; + const MeshBuiltinVUIDs& vuids = mesh_vuid_map.at(builtin); + if (spv_result_t error = ValidateBlockTypeOrArrayedType( + decoration, inst, is_block, scalar_type, + [this, &inst, &builtin, &scalar_type, + &vuids](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) - << _.VkErrorID(vuid) - << "According to the Vulkan spec BuiltIn " + << _.VkErrorID(vuids.array_type) + << "According to the Vulkan specspec BuiltIn " << _.grammar().lookupOperandName( - SPV_OPERAND_TYPE_BUILT_IN, - (uint32_t)decoration.builtin()) - << "variable needs to be a 32-bit int scalar. " - << message; + SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)builtin) + << " variable needs to be a either a " + << spvOpcodeString(scalar_type) + << " or an " + "array of " + << spvOpcodeString(scalar_type) << ". " << message; })) { return error; } - } else { - if (spv_result_t error = ValidateOptionalArrayedI32( + + if (!_.HasDecoration(inst.id(), spv::Decoration::PerPrimitiveEXT)) { + return _.diag(SPV_ERROR_INVALID_DATA, &inst) + << _.VkErrorID(vuids.perprim_deco) + << "According to the Vulkan spec the variable decorated with " + "Builtin " + << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, + (uint32_t)builtin) + << " within the MeshEXT Execution Model must also be " + << "decorated with the PerPrimitiveEXT decoration. "; + } + + // These builtin have the ability to be an array with MeshEXT + // When an array, we need to make sure the array size lines up + std::map entry_interface_id_map; + bool found = IsMeshInterfaceVar(inst, entry_interface_id_map); + if (found) { + for (const auto& id : entry_interface_id_map) { + uint32_t entry_point_id = id.first; + uint32_t interface_var_id = id.second; + + const uint64_t interface_size = GetArrayLength(interface_var_id); + const uint32_t output_prim_size = + _.GetOutputPrimitivesEXT(entry_point_id); + if (interface_size != output_prim_size) { + return _.diag(SPV_ERROR_INVALID_DATA, &inst) + << _.VkErrorID(is_block ? vuids.block_array_size + : vuids.array_size) + << " The size of the array decorated with " + << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, + (uint32_t)builtin) + << " (" << interface_size + << ") must match the value specified by OutputPrimitivesEXT " + "(" + << output_prim_size << "). "; + } + } + } + } + } else { + // Propagate this rule to all dependant ids in the global scope. + id_to_at_reference_checks_[referenced_from_inst.id()].push_back( + std::bind(&BuiltInsValidator::ValidateMeshBuiltinInterfaceRules, this, + decoration, inst, scalar_type, std::placeholders::_1)); + } + return SPV_SUCCESS; +} + +spv_result_t BuiltInsValidator::ValidatePrimitiveShadingRateInterfaceRules( + const Decoration& decoration, const Instruction& inst, + const Instruction& referenced_from_inst) { + if (function_id_) { + if (!execution_models_.count(spv::ExecutionModel::MeshEXT)) { + if (spv_result_t error = ValidateI32( decoration, inst, - [this, &decoration, - &inst](const std::string& message) -> spv_result_t { - uint32_t vuid = - (decoration.builtin() == spv::BuiltIn::Layer) ? 4276 : 4408; + [this, &inst, + &decoration](const std::string& message) -> spv_result_t { return _.diag(SPV_ERROR_INVALID_DATA, &inst) - << _.VkErrorID(vuid) + << _.VkErrorID(4486) << "According to the Vulkan spec BuiltIn " << _.grammar().lookupOperandName( SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)decoration.builtin()) - << "variable needs to be a 32-bit int scalar. " + << " variable needs to be a 32-bit int scalar. " << message; })) { return error; } } + } else { + // Propagate this rule to all dependant ids in the global scope. + id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( + &BuiltInsValidator::ValidatePrimitiveShadingRateInterfaceRules, this, + decoration, inst, std::placeholders::_1)); + } + return SPV_SUCCESS; +} - if (isMeshInterfaceVar(inst) && - _.HasCapability(spv::Capability::MeshShadingEXT) && - !_.HasDecoration(inst.id(), spv::Decoration::PerPrimitiveEXT)) { - const spv::BuiltIn label = spv::BuiltIn(decoration.params()[0]); - uint32_t vkerrid = (label == spv::BuiltIn::Layer) ? 7039 : 7060; - return _.diag(SPV_ERROR_INVALID_DATA, &inst) - << _.VkErrorID(vkerrid) - << "According to the Vulkan spec the variable decorated with " - "Builtin " - << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN, - decoration.params()[0]) - << " within the MeshEXT Execution Model must also be decorated " - "with the PerPrimitiveEXT decoration. "; +// For Layer, ViewportIndex, and PrimitiveId +spv_result_t BuiltInsValidator::ValidateNonMeshInterfaceRules( + const Decoration& decoration, const Instruction& inst, + const Instruction& referenced_from_inst) { + if (function_id_) { + // This can be a per-primitive variable for NV mesh shader stage. + // In such cases variable will have an array of 32-bit integers. + if (!execution_models_.count(spv::ExecutionModel::MeshEXT)) { + const spv::BuiltIn builtin = decoration.builtin(); + const uint32_t vuid = (builtin == spv::BuiltIn::Layer) ? 4276 + : (builtin == spv::BuiltIn::ViewportIndex) ? 4408 + : 4337; + if (decoration.struct_member_index() != Decoration::kInvalidMember) { + if (spv_result_t error = ValidateI32( + decoration, inst, + [this, &vuid, builtin, + &inst](const std::string& message) -> spv_result_t { + return _.diag(SPV_ERROR_INVALID_DATA, &inst) + << _.VkErrorID(vuid) + << "According to the Vulkan spec BuiltIn " + << _.grammar().lookupOperandName( + SPV_OPERAND_TYPE_BUILT_IN, (uint32_t)builtin) + << "variable needs to be a 32-bit int scalar. " + << message; + })) { + return error; + } + } else if (spv_result_t error = ValidateOptionalArrayedI32( + decoration, inst, + [this, &vuid, builtin, + &inst](const std::string& message) -> spv_result_t { + return _.diag(SPV_ERROR_INVALID_DATA, &inst) + << _.VkErrorID(vuid) + << "According to the Vulkan spec BuiltIn " + << _.grammar().lookupOperandName( + SPV_OPERAND_TYPE_BUILT_IN, + (uint32_t)builtin) + << "variable needs to be a 32-bit int scalar. " + << message; + })) { + return error; + } } + } else { + // Propagate this rule to all dependant ids in the global scope. + id_to_at_reference_checks_[referenced_from_inst.id()].push_back( + std::bind(&BuiltInsValidator::ValidateNonMeshInterfaceRules, this, + decoration, inst, std::placeholders::_1)); } + return SPV_SUCCESS; +} - // Seed at reference checks with this built-in. +spv_result_t BuiltInsValidator::ValidateLayerOrViewportIndexAtDefinition( + const Decoration& decoration, const Instruction& inst) { return ValidateLayerOrViewportIndexAtReference(decoration, inst, inst, inst); } @@ -2914,6 +3119,14 @@ spv_result_t BuiltInsValidator::ValidateLayerOrViewportIndexAtReference( referenced_from_inst, std::placeholders::_1)); } + id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( + &BuiltInsValidator::ValidateMeshBuiltinInterfaceRules, this, decoration, + built_in_inst, spv::Op::OpTypeInt, std::placeholders::_1)); + + id_to_at_reference_checks_[referenced_from_inst.id()].push_back( + std::bind(&BuiltInsValidator::ValidateNonMeshInterfaceRules, this, + decoration, built_in_inst, std::placeholders::_1)); + for (const spv::ExecutionModel execution_model : execution_models_) { switch (execution_model) { case spv::ExecutionModel::Geometry: @@ -3338,12 +3551,47 @@ spv_result_t BuiltInsValidator::ValidateWorkgroupSizeAtDefinition( bool static_x = _.EvalConstantValUint64(inst.word(3), &x_size); bool static_y = _.EvalConstantValUint64(inst.word(4), &y_size); bool static_z = _.EvalConstantValUint64(inst.word(5), &z_size); - if (static_x && static_y && static_z && - ((x_size * y_size * z_size) == 0)) { - return _.diag(SPV_ERROR_INVALID_DATA, &inst) - << "WorkgroupSize decorations must not have a static " - "product of zero (X = " - << x_size << ", Y = " << y_size << ", Z = " << z_size << ")."; + if (static_x && static_y && static_z) { + const uint64_t product_size = x_size * y_size * z_size; + if (product_size == 0) { + return _.diag(SPV_ERROR_INVALID_DATA, &inst) + << "WorkgroupSize decorations must not have a static " + "product of zero (X = " + << x_size << ", Y = " << y_size << ", Z = " << z_size << ")."; + } + + // If there is a known static workgroup size, all entrypoints with + // explicit derivative execution modes can be validated. These are only + // found in execution models that support explicit workgroup sizes + for (const uint32_t entry_point : _.entry_points()) { + const auto* modes = _.GetExecutionModes(entry_point); + if (!modes) continue; + if (modes->count(spv::ExecutionMode::DerivativeGroupQuadsKHR)) { + if (x_size % 2 != 0 || y_size % 2 != 0) { + return _.diag(SPV_ERROR_INVALID_DATA, &inst) + << _.VkErrorID(10151) + << "WorkgroupSize decorations has a static dimensions of " + "(X = " + << x_size << ", Y = " << y_size << ") but Entry Point id " + << entry_point + << " has an DerivativeGroupQuadsKHR execution mode, so " + "both dimensions must be a multiple of 2"; + } + } + if (modes->count(spv::ExecutionMode::DerivativeGroupLinearKHR)) { + if (product_size % 4 != 0) { + return _.diag(SPV_ERROR_INVALID_DATA, &inst) + << _.VkErrorID(10152) + << "WorkgroupSize decorations has a static dimensions of " + "(X = " + << x_size << ", Y = " << y_size << ", Z = " << z_size + << ") but Entry Point id " << entry_point + << " has an DerivativeGroupLinearKHR execution mode, so " + "the product (" + << product_size << ") must be a multiple of 4"; + } + } + } } } } @@ -3986,34 +4234,6 @@ spv_result_t BuiltInsValidator::ValidateNVSMOrARMCoreBuiltinsAtReference( spv_result_t BuiltInsValidator::ValidatePrimitiveShadingRateAtDefinition( const Decoration& decoration, const Instruction& inst) { - if (spvIsVulkanEnv(_.context()->target_env)) { - if (spv_result_t error = ValidateI32( - decoration, inst, - [this, &inst, - &decoration](const std::string& message) -> spv_result_t { - return _.diag(SPV_ERROR_INVALID_DATA, &inst) - << _.VkErrorID(4486) - << "According to the Vulkan spec BuiltIn " - << _.grammar().lookupOperandName( - SPV_OPERAND_TYPE_BUILT_IN, - (uint32_t)decoration.builtin()) - << " variable needs to be a 32-bit int scalar. " - << message; - })) { - return error; - } - if (isMeshInterfaceVar(inst) && - _.HasCapability(spv::Capability::MeshShadingEXT) && - !_.HasDecoration(inst.id(), spv::Decoration::PerPrimitiveEXT)) { - return _.diag(SPV_ERROR_INVALID_DATA, &inst) - << _.VkErrorID(7059) - << "The variable decorated with PrimitiveShadingRateKHR " - "within the MeshEXT Execution Model must also be " - "decorated with the PerPrimitiveEXT decoration"; - } - } - - // Seed at reference checks with this built-in. return ValidatePrimitiveShadingRateAtReference(decoration, inst, inst, inst); } @@ -4035,6 +4255,14 @@ spv_result_t BuiltInsValidator::ValidatePrimitiveShadingRateAtReference( << " " << GetStorageClassDesc(referenced_from_inst); } + id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( + &BuiltInsValidator::ValidateMeshBuiltinInterfaceRules, this, decoration, + built_in_inst, spv::Op::OpTypeInt, std::placeholders::_1)); + + id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind( + &BuiltInsValidator::ValidatePrimitiveShadingRateInterfaceRules, this, + decoration, built_in_inst, std::placeholders::_1)); + for (const spv::ExecutionModel execution_model : execution_models_) { switch (execution_model) { case spv::ExecutionModel::Vertex: @@ -4365,48 +4593,61 @@ spv_result_t BuiltInsValidator::ValidateMeshShadingEXTBuiltinsAtDefinition( return error; } break; - case spv::BuiltIn::CullPrimitiveEXT: - if (spv_result_t error = ValidateBlockBoolOrArrayedBool( - decoration, inst, - [this, &inst, &decoration, - &vuid](const std::string& message) -> spv_result_t { - return _.diag(SPV_ERROR_INVALID_DATA, &inst) - << _.VkErrorID(vuid) << "According to the " - << spvLogStringForEnv(_.context()->target_env) - << " spec BuiltIn " - << _.grammar().lookupOperandName( - SPV_OPERAND_TYPE_BUILT_IN, - (uint32_t)decoration.builtin()) - << " variable needs to be a either a boolean or an " - "array of booleans." - << message; - })) { + case spv::BuiltIn::CullPrimitiveEXT: { + // We know this only allowed for Mesh Execution Model + if (spv_result_t error = ValidateMeshBuiltinInterfaceRules( + decoration, inst, spv::Op::OpTypeBool, inst)) { return error; } - if (!_.HasDecoration(inst.id(), spv::Decoration::PerPrimitiveEXT)) { - return _.diag(SPV_ERROR_INVALID_DATA, &inst) - << _.VkErrorID(7038) - << "The variable decorated with CullPrimitiveEXT within the " - "MeshEXT Execution Model must also be decorated with the " - "PerPrimitiveEXT decoration "; + + for (const uint32_t entry_point : _.entry_points()) { + auto* models = _.GetExecutionModels(entry_point); + if (models->find(spv::ExecutionModel::MeshEXT) == models->end() && + models->find(spv::ExecutionModel::MeshNV) == models->end()) { + continue; + } + + if (IsBulitinInEntryPoint(inst, entry_point)) { + if (cull_primitive_entry_points_.find(entry_point) != + cull_primitive_entry_points_.end()) { + return _.diag(SPV_ERROR_INVALID_DATA, &inst) + << _.VkErrorID(10591) + << "There must be only one declaration of the " + "CullPrimitiveEXT associated in entry point's " + "interface. " + << GetIdDesc(*_.FindDef(entry_point)); + } else { + cull_primitive_entry_points_.insert(entry_point); + } + } } + break; + } default: assert(0 && "Unexpected mesh EXT builtin"); } for (const uint32_t entry_point : _.entry_points()) { + // execution modes and builtin are both global, so only check these + // buildit definitions if we know the entrypoint is Mesh + auto* models = _.GetExecutionModels(entry_point); + if (models->find(spv::ExecutionModel::MeshEXT) == models->end() && + models->find(spv::ExecutionModel::MeshNV) == models->end()) { + continue; + } + const auto* modes = _.GetExecutionModes(entry_point); - uint64_t maxOutputPrimitives = _.GetOutputPrimitivesEXT(entry_point); + uint64_t max_output_primitives = _.GetOutputPrimitivesEXT(entry_point); uint32_t underlying_type = 0; if (spv_result_t error = GetUnderlyingType(_, decoration, inst, &underlying_type)) { return error; } - uint64_t primitiveArrayDim = 0; + uint64_t primitive_array_dim = 0; if (_.GetIdOpcode(underlying_type) == spv::Op::OpTypeArray) { underlying_type = _.FindDef(underlying_type)->word(3u); - if (!_.EvalConstantValUint64(underlying_type, &primitiveArrayDim)) { + if (!_.EvalConstantValUint64(underlying_type, &primitive_array_dim)) { assert(0 && "Array type definition is corrupt"); } } @@ -4419,7 +4660,8 @@ spv_result_t BuiltInsValidator::ValidateMeshShadingEXTBuiltinsAtDefinition( "with " "the OutputPoints Execution Mode. "; } - if (primitiveArrayDim && primitiveArrayDim != maxOutputPrimitives) { + if (primitive_array_dim && + primitive_array_dim != max_output_primitives) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(7046) << "The size of the array decorated with " @@ -4435,7 +4677,8 @@ spv_result_t BuiltInsValidator::ValidateMeshShadingEXTBuiltinsAtDefinition( "with " "the OutputLinesEXT Execution Mode. "; } - if (primitiveArrayDim && primitiveArrayDim != maxOutputPrimitives) { + if (primitive_array_dim && + primitive_array_dim != max_output_primitives) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(7052) << "The size of the array decorated with " @@ -4451,7 +4694,8 @@ spv_result_t BuiltInsValidator::ValidateMeshShadingEXTBuiltinsAtDefinition( "with " "the OutputTrianglesEXT Execution Mode. "; } - if (primitiveArrayDim && primitiveArrayDim != maxOutputPrimitives) { + if (primitive_array_dim && + primitive_array_dim != max_output_primitives) { return _.diag(SPV_ERROR_INVALID_DATA, &inst) << _.VkErrorID(7058) << "The size of the array decorated with " @@ -4692,6 +4936,7 @@ spv_result_t BuiltInsValidator::ValidateSingleBuiltInAtDefinitionVulkan( case spv::BuiltIn::CullMaskKHR: { return ValidateRayTracingBuiltinsAtDefinition(decoration, inst); } + // These are only for Mesh, not Task execution model case spv::BuiltIn::CullPrimitiveEXT: case spv::BuiltIn::PrimitivePointIndicesEXT: case spv::BuiltIn::PrimitiveLineIndicesEXT: diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_capability.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_capability.cpp index 05ccb11..ac8f824 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_capability.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_capability.cpp @@ -345,11 +345,18 @@ bool IsEnabledByCapabilityOpenCL_2_0(ValidationState_t& _, // Validates that capability declarations use operands allowed in the current // context. spv_result_t CapabilityPass(ValidationState_t& _, const Instruction* inst) { - if (inst->opcode() != spv::Op::OpCapability) return SPV_SUCCESS; - - assert(inst->operands().size() == 1); - - const spv_parsed_operand_t& operand = inst->operand(0); + if (inst->opcode() != spv::Op::OpCapability && + inst->opcode() != spv::Op::OpConditionalCapabilityINTEL) + return SPV_SUCCESS; + + assert(!((inst->opcode() == spv::Op::OpCapability) ^ + (inst->operands().size() == 1))); + assert(!((inst->opcode() == spv::Op::OpConditionalCapabilityINTEL) ^ + (inst->operands().size() == 2))); + + const uint32_t i_cap = + inst->opcode() == spv::Op::OpConditionalCapabilityINTEL ? 1 : 0; + const spv_parsed_operand_t& operand = inst->operand(i_cap); assert(operand.num_words == 1); assert(operand.offset < inst->words().size()); diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_composites.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_composites.cpp index 2afeae7..68636f3 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_composites.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_composites.cpp @@ -16,6 +16,8 @@ // Validates correctness of composite SPIR-V instructions. +#include + #include "source/opcode.h" #include "source/spirv_target_env.h" #include "source/val/instruction.h" @@ -618,8 +620,464 @@ spv_result_t ValidateCopyLogical(ValidationState_t& _, return SPV_SUCCESS; } -} // anonymous namespace +spv_result_t ValidateCompositeConstructCoopMatQCOM(ValidationState_t& _, + const Instruction* inst) { + // Is the result of coop mat ? + const auto result_type_inst = _.FindDef(inst->type_id()); + if (!result_type_inst || + result_type_inst->opcode() != spv::Op::OpTypeCooperativeMatrixKHR) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the result type be OpTypeCooperativeMatrixKHR"; + } + + const auto source = _.FindDef(inst->GetOperandAs(2u)); + const auto source_type_inst = _.FindDef(source->type_id()); + + if (!source_type_inst || source_type_inst->opcode() != spv::Op::OpTypeArray) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the input operand be an OpTypeArray."; + } + + // Is the scope Subgrouop ? + { + unsigned scope = UINT_MAX; + unsigned scope_id = result_type_inst->GetOperandAs(2u); + bool status = _.GetConstantValueAs(scope_id, scope); + bool is_scope_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(scope_id)->opcode()); + if (!is_scope_spec_const && + (!status || scope != static_cast(spv::Scope::Subgroup))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the result type's scope be Subgroup."; + } + } + + unsigned ar_len = UINT_MAX; + unsigned src_arr_len_id = source_type_inst->GetOperandAs(2u); + bool ar_len_status = _.GetConstantValueAs(src_arr_len_id, ar_len); + bool is_src_arr_len_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(src_arr_len_id)->opcode()); + + const auto source_elt_type = _.GetComponentType(source_type_inst->id()); + const auto result_elt_type = result_type_inst->GetOperandAs(1u); + + if ((source_elt_type != result_elt_type) && + !(_.ContainsSizedIntOrFloatType(source_elt_type, spv::Op::OpTypeInt, + 32) && + _.IsUnsignedIntScalarType(source_elt_type))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires ether the input element type is equal to the result " + "element type or it is the unsigned 32-bit integer."; + } + + unsigned res_row_id = result_type_inst->GetOperandAs(3u); + unsigned res_col_id = result_type_inst->GetOperandAs(4u); + unsigned res_use_id = result_type_inst->GetOperandAs(5u); + + unsigned cm_use = UINT_MAX; + bool cm_use_status = _.GetConstantValueAs(res_use_id, cm_use); + + switch (static_cast(cm_use)) { + case spv::CooperativeMatrixUse::MatrixAKHR: { + // result coopmat component type check + if (!_.IsIntNOrFP32OrFP16<8>(result_elt_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the result element type is one of 8-bit OpTypeInt " + "signed/unsigned, 16- or 32-bit OpTypeFloat" + << " when result coopmat's use is MatrixAKHR"; + } + + // result coopmat column length check + unsigned n_cols = UINT_MAX; + bool status = _.GetConstantValueAs(res_col_id, n_cols); + bool is_res_col_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(res_col_id)->opcode()); + if (!is_res_col_spec_const && + (!status || (!(_.ContainsSizedIntOrFloatType(result_elt_type, + spv::Op::OpTypeInt, 8) && + n_cols == 32) && + !(_.ContainsSizedIntOrFloatType( + result_elt_type, spv::Op::OpTypeFloat, 16) && + n_cols == 16) && + !(_.ContainsSizedIntOrFloatType( + result_elt_type, spv::Op::OpTypeFloat, 32) && + n_cols == 8)))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the columns of the result coopmat have the bit " + "length of 256" + << " when result coopmat's use is MatrixAKHR"; + } + // source array length check + if (!is_src_arr_len_spec_const && + (!ar_len_status || + (!(_.ContainsSizedIntOrFloatType(source_elt_type, spv::Op::OpTypeInt, + 32) && + _.IsUnsignedIntScalarType(source_elt_type) && (ar_len == 8)) && + !(n_cols == ar_len)))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the source array length be 8 if its elt type is " + "32-bit unsigned OpTypeInt and be the result's number of " + "columns, otherwise" + << " when result coopmat's use is MatrixAKHR"; + } + break; + } + case spv::CooperativeMatrixUse::MatrixBKHR: { + // result coopmat component type check + if (!_.IsIntNOrFP32OrFP16<8>(result_elt_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the result element type is one of 8-bit OpTypeInt " + "signed/unsigned, 16- or 32-bit OpTypeFloat" + << " when result coopmat's use is MatrixBKHR"; + } + + // result coopmat row length check + unsigned n_rows = UINT_MAX; + bool status = _.GetConstantValueAs(res_row_id, n_rows); + bool is_res_row_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(res_row_id)->opcode()); + if (!is_res_row_spec_const && + (!status || (!(_.ContainsSizedIntOrFloatType(result_elt_type, + spv::Op::OpTypeInt, 8) && + n_rows == 32) && + !(_.ContainsSizedIntOrFloatType( + result_elt_type, spv::Op::OpTypeFloat, 16) && + n_rows == 16) && + !(_.ContainsSizedIntOrFloatType( + result_elt_type, spv::Op::OpTypeFloat, 32) && + n_rows == 8)))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the rows of the result operand have the bit " + "length of 256" + << " when result coopmat's use is MatrixBKHR"; + } + // source array length check + if (!is_src_arr_len_spec_const && + (!ar_len_status || + (!(_.ContainsSizedIntOrFloatType(source_elt_type, spv::Op::OpTypeInt, + 32) && + _.IsUnsignedIntScalarType(source_elt_type) && (ar_len == 8)) && + !(n_rows == ar_len)))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the source array length be 8 if its elt type is " + "32-bit unsigned OpTypeInt and be the result's number of " + "rows, otherwise" + << " when result coopmat's use is MatrixBKHR"; + } + break; + } + case spv::CooperativeMatrixUse::MatrixAccumulatorKHR: { + // result coopmat component type check + if (!_.IsIntNOrFP32OrFP16<32>(result_elt_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the result element type is one of 32-bit " + "OpTypeInt signed/unsigned, 16- or 32-bit OpTypeFloat" + << " when result coopmat's use is MatrixAccumulatorKHR"; + } + + // source array length check + unsigned n_cols = UINT_MAX; + bool status = _.GetConstantValueAs(res_col_id, n_cols); + bool is_res_col_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(res_col_id)->opcode()); + if (!is_res_col_spec_const && !is_src_arr_len_spec_const && + (!status || !ar_len_status || + (!(_.ContainsSizedIntOrFloatType(source_elt_type, spv::Op::OpTypeInt, + 32) && + _.IsUnsignedIntScalarType(source_elt_type) && + (_.ContainsSizedIntOrFloatType(result_elt_type, + spv::Op::OpTypeFloat, 16) + ? (n_cols / 2 == ar_len) + : n_cols == ar_len)) && + (n_cols != ar_len)))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the source array length be a half of the number " + "of columns of the resulting cooerative matrix if the " + "matrix's componet type is 16-bit OpTypeFloat and be equal " + "to the number of columns, otherwise," + << " when result coopmat's use is MatrixAccumulatorKHR"; + } + break; + } + default: { + bool is_cm_use_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(res_use_id)->opcode()); + if (!is_cm_use_spec_const || !cm_use_status) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the the resulting cooerative matrix's use be " + << " one of MatrixAKHR (== 0), MatrixBKHR (== 1), and " + "MatrixAccumulatorKHR (== 2)"; + } + break; + } + } + + return SPV_SUCCESS; +} + +spv_result_t ValidateCompositeExtractCoopMatQCOM(ValidationState_t& _, + const Instruction* inst) { + const auto result_type_inst = _.FindDef(inst->type_id()); + if (!result_type_inst || result_type_inst->opcode() != spv::Op::OpTypeArray) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the input operand be an OpTypeArray."; + } + + const auto source = _.FindDef(inst->GetOperandAs(2u)); + const auto source_type_inst = _.FindDef(source->type_id()); + + // Is the source of coop mat ? + if (!source_type_inst || + source_type_inst->opcode() != spv::Op::OpTypeCooperativeMatrixKHR) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the source type be OpTypeCooperativeMatrixKHR"; + } + // Is the scope Subgrouop ? + { + unsigned scope = UINT_MAX; + unsigned scope_id = source_type_inst->GetOperandAs(2u); + bool status = _.GetConstantValueAs(scope_id, scope); + bool is_scope_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(scope_id)->opcode()); + if (!is_scope_spec_const && + (!status || scope != static_cast(spv::Scope::Subgroup))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the source type's scope be Subgroup."; + } + } + + unsigned ar_len = UINT_MAX; + unsigned res_arr_len_id = result_type_inst->GetOperandAs(2u); + bool ar_len_status = _.GetConstantValueAs(res_arr_len_id, ar_len); + bool is_res_arr_len_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(res_arr_len_id)->opcode()); + + const auto source_elt_type = _.GetComponentType(source_type_inst->id()); + const auto result_elt_type = result_type_inst->GetOperandAs(1u); + + unsigned src_row_id = source_type_inst->GetOperandAs(3u); + unsigned src_col_id = source_type_inst->GetOperandAs(4u); + unsigned src_use_id = source_type_inst->GetOperandAs(5u); + + unsigned cm_use = UINT_MAX; + bool cm_use_status = _.GetConstantValueAs(src_use_id, cm_use); + + switch (static_cast(cm_use)) { + case spv::CooperativeMatrixUse::MatrixAKHR: { + // source coopmat component type check + if (!_.IsIntNOrFP32OrFP16<8>(source_elt_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the source element type be one of 8-bit OpTypeInt " + "signed/unsigned, 16- or 32-bit OpTypeFloat" + << " when source coopmat's use is MatrixAKHR"; + } + + // source coopmat column length check + unsigned n_cols = UINT_MAX; + bool status = _.GetConstantValueAs(src_col_id, n_cols); + bool is_src_col_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(src_col_id)->opcode()); + if (!is_src_col_spec_const && + (!status || (!(_.ContainsSizedIntOrFloatType(source_elt_type, + spv::Op::OpTypeInt, 8) && + n_cols == 32) && + !(_.ContainsSizedIntOrFloatType( + source_elt_type, spv::Op::OpTypeFloat, 16) && + n_cols == 16) && + !(_.ContainsSizedIntOrFloatType( + source_elt_type, spv::Op::OpTypeFloat, 32) && + n_cols == 8)))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the columns of the source coopmat have the bit " + "length of 256" + << " when source coopmat's use is MatrixAKHR"; + } + // result type check + if (!is_res_arr_len_spec_const && + !(source_elt_type == result_elt_type && (n_cols == ar_len)) && + !(_.ContainsSizedIntOrFloatType(result_elt_type, spv::Op::OpTypeInt, + 32) && + _.IsUnsignedIntScalarType(result_elt_type) && (ar_len == 8))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires either the result element type be the same as the " + "source cooperative matrix's component type" + << " and its length be the same as the number of columns of the " + "matrix or the result element type be" + << " unsigned 32-bit OpTypeInt and the length be 8" + << " when source coopmat's use is MatrixAKHR"; + } + break; + } + case spv::CooperativeMatrixUse::MatrixBKHR: { + // source coopmat component type check + if (!_.IsIntNOrFP32OrFP16<8>(source_elt_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the source element type be one of 8-bit OpTypeInt " + "signed/unsigned, 16- or 32-bit OpTypeFloat" + << " when source coopmat's use is MatrixBKHR"; + } + + // source coopmat row length check + unsigned n_rows = UINT_MAX; + bool status = _.GetConstantValueAs(src_row_id, n_rows); + bool is_src_row_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(src_row_id)->opcode()); + if (!is_src_row_spec_const && + (!status || (!(_.ContainsSizedIntOrFloatType(source_elt_type, + spv::Op::OpTypeInt, 8) && + n_rows == 32) && + !(_.ContainsSizedIntOrFloatType( + source_elt_type, spv::Op::OpTypeFloat, 16) && + n_rows == 16) && + !(_.ContainsSizedIntOrFloatType( + source_elt_type, spv::Op::OpTypeFloat, 32) && + n_rows == 8)))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the rows of the source coopmat have the bit " + "length of 256" + << " when source coopmat's use is MatrixBKHR"; + } + // result type check + if (!is_res_arr_len_spec_const && + !(source_elt_type == result_elt_type && (n_rows == ar_len)) && + !(_.ContainsSizedIntOrFloatType(result_elt_type, spv::Op::OpTypeInt, + 32) && + _.IsUnsignedIntScalarType(result_elt_type) && (ar_len == 8))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires either the result element type be the same as the " + "source cooperative matrix's component type" + << " and its length be the same as the number of rows of the " + "matrix or the result element type be" + << " unsigned 32-bit OpTypeInt and the length be 8" + << " when source coopmat's use is MatrixBKHR"; + } + break; + } + case spv::CooperativeMatrixUse::MatrixAccumulatorKHR: { + // source coopmat component type check + if (!_.IsIntNOrFP32OrFP16<32>(source_elt_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the source element type be one of 32-bit " + "OpTypeInt signed/unsigned, 16- or 32-bit OpTypeFloat" + << " when source coopmat's use is MatrixAccumulatorKHR"; + } + + // result type check + unsigned n_cols = UINT_MAX; + bool status = _.GetConstantValueAs(src_col_id, n_cols); + bool is_src_col_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(src_col_id)->opcode()); + if (!is_src_col_spec_const && !is_res_arr_len_spec_const && + (!status || !ar_len_status || + (!(source_elt_type == result_elt_type && (n_cols == ar_len)) && + !(_.ContainsSizedIntOrFloatType(result_elt_type, spv::Op::OpTypeInt, + 32) && + _.IsUnsignedIntScalarType(result_elt_type) && + (_.ContainsSizedIntOrFloatType(source_elt_type, + spv::Op::OpTypeFloat, 16) + ? (n_cols / 2 == ar_len) + : (n_cols == ar_len)))))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires either the result element type be the same as the " + "source cooperative matrix's component type" + << " and its length be the same as the number of columns of the " + "matrix or the result element type be" + << " unsigned 32-bit OpTypeInt and the length be the number of " + "the columns of the matrix if its component" + << " type is 32-bit OpTypeFloat and be a half of the number of " + "the columns of the matrix if its component" + << " type is 16-bit OpTypeFloat" + << " when source coopmat's use is MatrixAccumulatorKHR"; + } + break; + } + default: { + bool is_cm_use_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(src_use_id)->opcode()); + if (!is_cm_use_spec_const || !cm_use_status) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the the source cooerative matrix's use be " + << " one of MatrixAKHR (== 0), MatrixBKHR (== 1), and " + "MatrixAccumulatorKHR (== 2)"; + } + break; + } + } + + return SPV_SUCCESS; +} + +spv_result_t ValidateExtractSubArrayQCOM(ValidationState_t& _, + const Instruction* inst) { + const auto result_type_inst = _.FindDef(inst->type_id()); + const auto source = _.FindDef(inst->GetOperandAs(2u)); + const auto source_type_inst = _.FindDef(source->type_id()); + + // Are the input and the result arrays? + if (result_type_inst->opcode() != spv::Op::OpTypeArray || + source_type_inst->opcode() != spv::Op::OpTypeArray) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires OpTypeArray operands for the input and the result."; + } + + const auto source_elt_type = _.GetComponentType(source_type_inst->id()); + const auto result_elt_type = _.GetComponentType(result_type_inst->id()); + + // Do the input and result element types match? + if (source_elt_type != result_elt_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the input and result element types match."; + } + + // Elt type must be one of int32_t/uint32_t/float32/float16 + if (!_.IsIntNOrFP32OrFP16<32>(source_elt_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the element type be one of 32-bit OpTypeInt " + "(signed/unsigned), 32-bit OpTypeFloat and 16-bit OpTypeFloat"; + } + + const auto start_index = _.FindDef(inst->GetOperandAs(3u)); + if (!start_index || !_.ContainsSizedIntOrFloatType(start_index->type_id(), + spv::Op::OpTypeInt, 32)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the type of the start index operand be 32-bit " + "OpTypeInt"; + } + + return SPV_SUCCESS; +} + +} // anonymous namespace // Validates correctness of composite instructions. spv_result_t CompositesPass(ValidationState_t& _, const Instruction* inst) { switch (inst->opcode()) { @@ -641,6 +1099,12 @@ spv_result_t CompositesPass(ValidationState_t& _, const Instruction* inst) { return ValidateTranspose(_, inst); case spv::Op::OpCopyLogical: return ValidateCopyLogical(_, inst); + case spv::Op::OpCompositeConstructCoopMatQCOM: + return ValidateCompositeConstructCoopMatQCOM(_, inst); + case spv::Op::OpCompositeExtractCoopMatQCOM: + return ValidateCompositeExtractCoopMatQCOM(_, inst); + case spv::Op::OpExtractSubArrayQCOM: + return ValidateExtractSubArrayQCOM(_, inst); default: break; } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_conversion.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_conversion.cpp index be50a6f..acd70e7 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_conversion.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_conversion.cpp @@ -14,6 +14,8 @@ // Validates correctness of conversion instructions. +#include + #include "source/opcode.h" #include "source/spirv_constant.h" #include "source/spirv_target_env.h" @@ -572,26 +574,38 @@ spv_result_t ConversionPass(ValidationState_t& _, const Instruction* inst) { if (result_is_pointer && !input_is_pointer && !input_is_int_scalar && !(input_is_int_vector && input_has_int32)) return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "Expected input to be a pointer, int scalar or 32-bit int " + << "In SPIR-V 1.5 or later (or with " + "SPV_KHR_physical_storage_buffer), expected input to be a " + "pointer, " + "int scalar or 32-bit int " "vector if Result Type is pointer: " << spvOpcodeString(opcode); if (input_is_pointer && !result_is_pointer && !result_is_int_scalar && !(result_is_int_vector && result_has_int32)) return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "Pointer can only be converted to another pointer, int " + << "In SPIR-V 1.5 or later (or with " + "SPV_KHR_physical_storage_buffer), pointer can only be " + "converted to " + "another pointer, int " "scalar or 32-bit int vector: " << spvOpcodeString(opcode); } else { if (result_is_pointer && !input_is_pointer && !input_is_int_scalar) return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "Expected input to be a pointer or int scalar if Result " + << "In SPIR-V 1.4 or earlier (and without " + "SPV_KHR_physical_storage_buffer), expected input to be a " + "pointer " + "or int scalar if Result " "Type is pointer: " << spvOpcodeString(opcode); if (input_is_pointer && !result_is_pointer && !result_is_int_scalar) return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "Pointer can only be converted to another pointer or int " + << "In SPIR-V 1.4 or earlier (and without " + "SPV_KHR_physical_storage_buffer), pointer can only be " + "converted " + "to another pointer or int " "scalar: " << spvOpcodeString(opcode); } @@ -664,6 +678,69 @@ spv_result_t ConversionPass(ValidationState_t& _, const Instruction* inst) { break; } + case spv::Op::OpBitCastArrayQCOM: { + const auto result_type_inst = _.FindDef(inst->type_id()); + const auto source = _.FindDef(inst->GetOperandAs(2u)); + const auto source_type_inst = _.FindDef(source->type_id()); + + // Are the input and the result arrays? + if (result_type_inst->opcode() != spv::Op::OpTypeArray || + source_type_inst->opcode() != spv::Op::OpTypeArray) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires OpTypeArray operands for the input and the " + "result."; + } + + const auto source_elt_type = _.GetComponentType(source_type_inst->id()); + const auto result_elt_type = _.GetComponentType(result_type_inst->id()); + + if (!_.IsIntNOrFP32OrFP16<32>(source_elt_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the source element type be one of 32-bit " + "OpTypeInt " + "(signed/unsigned), 32-bit OpTypeFloat and 16-bit " + "OpTypeFloat"; + } + + if (!_.IsIntNOrFP32OrFP16<32>(result_elt_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires the result element type be one of 32-bit " + "OpTypeInt " + "(signed/unsigned), 32-bit OpTypeFloat and 16-bit " + "OpTypeFloat"; + } + + unsigned src_arr_len_id = source_type_inst->GetOperandAs(2u); + unsigned res_arr_len_id = result_type_inst->GetOperandAs(2u); + + // Are the input and result element types compatible? + unsigned src_arr_len = UINT_MAX, res_arr_len = UINT_MAX; + bool src_arr_len_status = + _.GetConstantValueAs(src_arr_len_id, src_arr_len); + bool res_arr_len_status = + _.GetConstantValueAs(res_arr_len_id, res_arr_len); + + bool is_src_arr_len_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(src_arr_len_id)->opcode()); + bool is_res_arr_len_spec_const = + spvOpcodeIsSpecConstant(_.FindDef(res_arr_len_id)->opcode()); + + unsigned source_bitlen = _.GetBitWidth(source_elt_type) * src_arr_len; + unsigned result_bitlen = _.GetBitWidth(result_elt_type) * res_arr_len; + if (!is_src_arr_len_spec_const && !is_res_arr_len_spec_const && + (!src_arr_len_status || !res_arr_len_status || + source_bitlen != result_bitlen)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Opcode " << spvOpcodeString(inst->opcode()) + << " requires source and result types be compatible for " + "conversion."; + } + break; + } + default: break; } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_decorations.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_decorations.cpp index e62eda8..2c8ef95 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_decorations.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_decorations.cpp @@ -398,11 +398,29 @@ bool IsAlignedTo(uint32_t offset, uint32_t alignment) { return 0 == (offset % alignment); } +std::string getStorageClassString(spv::StorageClass sc) { + switch (sc) { + case spv::StorageClass::Uniform: + return "Uniform"; + case spv::StorageClass::UniformConstant: + return "UniformConstant"; + case spv::StorageClass::PushConstant: + return "PushConstant"; + case spv::StorageClass::Workgroup: + return "Workgroup"; + case spv::StorageClass::PhysicalStorageBuffer: + return "PhysicalStorageBuffer"; + default: + // Only other valid storage class in these checks + return "StorageBuffer"; + } +} + // Returns SPV_SUCCESS if the given struct satisfies standard layout rules for // Block or BufferBlocks in Vulkan. Otherwise emits a diagnostic and returns // something other than SPV_SUCCESS. Matrices inherit the specified column // or row major-ness. -spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str, +spv_result_t checkLayout(uint32_t struct_id, spv::StorageClass storage_class, const char* decoration_str, bool blockRules, bool scalar_block_layout, uint32_t incoming_offset, MemberConstraints& constraints, @@ -418,22 +436,48 @@ spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str, // is more permissive than relaxed layout. const bool relaxed_block_layout = vstate.IsRelaxedBlockLayout(); - auto fail = [&vstate, struct_id, storage_class_str, decoration_str, - blockRules, relaxed_block_layout, + auto fail = [&vstate, struct_id, storage_class, decoration_str, blockRules, + relaxed_block_layout, scalar_block_layout](uint32_t member_idx) -> DiagnosticStream { - DiagnosticStream ds = - std::move(vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(struct_id)) - << "Structure id " << struct_id << " decorated as " - << decoration_str << " for variable in " << storage_class_str - << " storage class must follow " - << (scalar_block_layout - ? "scalar " - : (relaxed_block_layout ? "relaxed " : "standard ")) - << (blockRules ? "uniform buffer" : "storage buffer") - << " layout rules: member " << member_idx << " "); + DiagnosticStream ds = std::move( + vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(struct_id)) + << "Structure id " << struct_id << " decorated as " << decoration_str + << " for variable in " << getStorageClassString(storage_class) + << " storage class must follow " + << (scalar_block_layout + ? "scalar " + : (relaxed_block_layout ? "relaxed " : "standard ")) + << (blockRules ? "uniform buffer" : "storage buffer") + << " layout rules: member " << member_idx << " "); return ds; }; + // People often use spirv-val from Vulkan Validation Layers, it ends up + // mapping the various block layout rules from the enabled feature. This + // offers a hint to help the user understand possbily why things are not + // working when the shader itself "seems" valid, but just was a lack of adding + // a supported feature + auto extra = [&vstate, scalar_block_layout, storage_class, + relaxed_block_layout, blockRules]() { + if (!scalar_block_layout) { + if (storage_class == spv::StorageClass::Workgroup) { + return vstate.MissingFeature( + "workgroupMemoryExplicitLayoutScalarBlockLayout feature", + "--workgroup-scalar-block-layout", true); + } else if (!relaxed_block_layout) { + return vstate.MissingFeature("VK_KHR_relaxed_block_layout extension", + "--relax-block-layout", true); + } else if (blockRules) { + return vstate.MissingFeature("uniformBufferStandardLayout feature", + "--uniform-buffer-standard-layout", true); + } else { + return vstate.MissingFeature("scalarBlockLayout feature", + "--scalar-block-layout", true); + } + } + return std::string(""); + }; + // If we are checking the layout of untyped pointers or physical storage // buffer pointers, we may not actually have a struct here. Instead, pretend // we have a struct with a single member at offset 0. @@ -507,7 +551,7 @@ spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str, const auto size = getSize(id, constraint, constraints, vstate); // Check offset. if (offset == 0xffffffff) - return fail(memberIdx) << "is missing an Offset decoration"; + return fail(memberIdx) << "is missing an Offset decoration" << extra(); if (opcode == spv::Op::OpTypeRuntimeArray && ordered_member_idx != member_offsets.size() - 1) { @@ -524,42 +568,44 @@ spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str, const auto componentId = inst->words()[2]; const auto scalar_alignment = getScalarAlignment(componentId, vstate); if (!IsAlignedTo(offset, scalar_alignment)) { - return fail(memberIdx) - << "at offset " << offset - << " is not aligned to scalar element size " << scalar_alignment; + return fail(memberIdx) << "at offset " << offset + << " is not aligned to scalar element size " + << scalar_alignment << extra(); } } else { // Without relaxed block layout, the offset must be divisible by the // alignment requirement. if (!IsAlignedTo(offset, alignment)) { - return fail(memberIdx) - << "at offset " << offset << " is not aligned to " << alignment; + return fail(memberIdx) << "at offset " << offset + << " is not aligned to " << alignment << extra(); } } if (offset < nextValidOffset) return fail(memberIdx) << "at offset " << offset << " overlaps previous member ending at offset " - << nextValidOffset - 1; + << nextValidOffset - 1 << extra(); if (!scalar_block_layout && relaxed_block_layout) { // Check improper straddle of vectors. if (spv::Op::OpTypeVector == opcode && hasImproperStraddle(id, offset, constraint, constraints, vstate)) return fail(memberIdx) - << "is an improperly straddling vector at offset " << offset; + << "is an improperly straddling vector at offset " << offset + << extra(); } // Check struct members recursively. spv_result_t recursive_status = SPV_SUCCESS; if (spv::Op::OpTypeStruct == opcode && SPV_SUCCESS != (recursive_status = checkLayout( - id, storage_class_str, decoration_str, blockRules, + id, storage_class, decoration_str, blockRules, scalar_block_layout, offset, constraints, vstate))) return recursive_status; // Check matrix stride. if (spv::Op::OpTypeMatrix == opcode) { const auto stride = constraint.matrix_stride; if (!IsAlignedTo(stride, alignment)) { - return fail(memberIdx) << "is a matrix with stride " << stride - << " not satisfying alignment to " << alignment; + return fail(memberIdx) + << "is a matrix with stride " << stride + << " not satisfying alignment to " << alignment << extra(); } } @@ -576,12 +622,13 @@ spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str, if (spv::Decoration::ArrayStride == decoration.dec_type()) { array_stride = decoration.params()[0]; if (array_stride == 0) { - return fail(memberIdx) << "contains an array with stride 0"; + return fail(memberIdx) + << "contains an array with stride 0" << extra(); } if (!IsAlignedTo(array_stride, array_alignment)) return fail(memberIdx) << "contains an array with stride " << decoration.params()[0] - << " not satisfying alignment to " << alignment; + << " not satisfying alignment to " << alignment << extra(); } } @@ -608,7 +655,7 @@ spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str, if (SPV_SUCCESS != (recursive_status = checkLayout( - typeId, storage_class_str, decoration_str, blockRules, + typeId, storage_class, decoration_str, blockRules, scalar_block_layout, next_offset, constraints, vstate))) return recursive_status; @@ -620,7 +667,7 @@ spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str, if (!IsAlignedTo(stride, alignment)) { return fail(memberIdx) << "is a matrix with stride " << stride - << " not satisfying alignment to " << alignment; + << " not satisfying alignment to " << alignment << extra(); } } @@ -636,7 +683,7 @@ spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str, if (element_size > array_stride) { return fail(memberIdx) << "contains an array with stride " << array_stride - << ", but with an element size of " << element_size; + << ", but with an element size of " << element_size << extra(); } } nextValidOffset = offset + size; @@ -801,32 +848,35 @@ spv_result_t CheckDecorationsOfEntryPoints(ValidationState_t& vstate) { if (storage_class == spv::StorageClass::TaskPayloadWorkgroupEXT) { if (has_task_payload) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) - << "There can be at most one OpVariable with storage " + << "There can be at most one " + "OpVariable with storage " "class TaskPayloadWorkgroupEXT associated with " "an OpEntryPoint"; } has_task_payload = true; } - } - if (vstate.version() >= SPV_SPIRV_VERSION_WORD(1, 4)) { + // Starting in 1.4, OpEntryPoint must list all global variables // it statically uses and those interfaces must be unique. if (storage_class == spv::StorageClass::Function) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) - << "OpEntryPoint interfaces should only list global " + << "In SPIR-V 1.4 or later, OpEntryPoint interfaces should " + "only list global " "variables"; } if (!seen_vars.insert(var_instr).second) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) - << "Non-unique OpEntryPoint interface " + << "In SPIR-V 1.4 or later, non-unique OpEntryPoint " + "interface " << vstate.getIdName(interface) << " is disallowed"; } } else { if (storage_class != spv::StorageClass::Input && storage_class != spv::StorageClass::Output) { return vstate.diag(SPV_ERROR_INVALID_ID, var_instr) - << "OpEntryPoint interfaces must be OpVariables with " + << "In SPIR-V 1.3 or earlier, OpEntryPoint interfaces must " + "be OpVariables with " "Storage Class of Input(1) or Output(3). Found Storage " "Class " << uint32_t(storage_class) << " for Entry Point id " @@ -1129,6 +1179,56 @@ void ComputeMemberConstraintsForArray(MemberConstraints* constraints, } } +spv_result_t CheckDecorationsOfVariables(ValidationState_t& vstate) { + if (!spvIsVulkanEnv(vstate.context()->target_env)) { + return SPV_SUCCESS; + } + for (const auto& inst : vstate.ordered_instructions()) { + if ((spv::Op::OpVariable == inst.opcode()) || + (spv::Op::OpUntypedVariableKHR == inst.opcode())) { + const auto var_id = inst.id(); + const auto storageClass = inst.GetOperandAs(2); + const bool uniform = storageClass == spv::StorageClass::Uniform; + const bool uniform_constant = + storageClass == spv::StorageClass::UniformConstant; + const bool storage_buffer = + storageClass == spv::StorageClass::StorageBuffer; + + const char* sc_str = uniform ? "Uniform" + : uniform_constant ? "UniformConstant" + : "StorageBuffer"; + // Check variables in the UniformConstant, StorageBuffer, and Uniform + // storage classes are decorated with DescriptorSet and Binding + // (VUID-06677). + if (uniform_constant || storage_buffer || uniform) { + // Skip validation if the variable is not used and we're looking + // at a module coming from HLSL that has not been legalized yet. + if (vstate.options()->before_hlsl_legalization && + vstate.EntryPointReferences(var_id).empty()) { + continue; + } + if (!hasDecoration(var_id, spv::Decoration::DescriptorSet, vstate)) { + return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) + << vstate.VkErrorID(6677) << sc_str << " id '" << var_id + << "' is missing DescriptorSet decoration.\n" + << "From Vulkan spec:\n" + << "These variables must have DescriptorSet and Binding " + "decorations specified"; + } + if (!hasDecoration(var_id, spv::Decoration::Binding, vstate)) { + return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) + << vstate.VkErrorID(6677) << sc_str << " id '" << var_id + << "' is missing Binding decoration.\n" + << "From Vulkan spec:\n" + << "These variables must have DescriptorSet and Binding " + "decorations specified"; + } + } + } + } + return SPV_SUCCESS; +} + spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) { // Set of entry points that are known to use a push constant. std::unordered_set uses_push_constant; @@ -1148,8 +1248,6 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) { const auto storageClassVal = words[3]; const auto storageClass = spv::StorageClass(storageClassVal); const bool uniform = storageClass == spv::StorageClass::Uniform; - const bool uniform_constant = - storageClass == spv::StorageClass::UniformConstant; const bool push_constant = storageClass == spv::StorageClass::PushConstant; const bool storage_buffer = @@ -1172,29 +1270,6 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) { } } } - // Vulkan: Check DescriptorSet and Binding decoration for - // UniformConstant which cannot be a struct. - if (uniform_constant) { - auto entry_points = vstate.EntryPointReferences(var_id); - if (!entry_points.empty() && - !hasDecoration(var_id, spv::Decoration::DescriptorSet, vstate)) { - return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) - << vstate.VkErrorID(6677) << "UniformConstant id '" << var_id - << "' is missing DescriptorSet decoration.\n" - << "From Vulkan spec:\n" - << "These variables must have DescriptorSet and Binding " - "decorations specified"; - } - if (!entry_points.empty() && - !hasDecoration(var_id, spv::Decoration::Binding, vstate)) { - return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) - << vstate.VkErrorID(6677) << "UniformConstant id '" << var_id - << "' is missing Binding decoration.\n" - << "From Vulkan spec:\n" - << "These variables must have DescriptorSet and Binding " - "decorations specified"; - } - } } if (spvIsOpenGLEnv(vstate.context()->target_env)) { @@ -1207,8 +1282,8 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) { if (!entry_points.empty() && !hasDecoration(var_id, spv::Decoration::Binding, vstate)) { return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) - << (uniform ? "Uniform" : "Storage Buffer") << " id '" - << var_id << "' is missing Binding decoration.\n" + << getStorageClassString(storageClass) << " id '" << var_id + << "' is missing Binding decoration.\n" << "From ARB_gl_spirv extension:\n" << "Uniform and shader storage block variables must " << "also be decorated with a *Binding*."; @@ -1243,12 +1318,6 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) { ComputeMemberConstraintsForStruct(&constraints, id, LayoutConstraints(), vstate); } - // Prepare for messages - const char* sc_str = - uniform - ? "Uniform" - : (push_constant ? "PushConstant" - : (workgroup ? "Workgroup" : "StorageBuffer")); if (spvIsVulkanEnv(vstate.context()->target_env)) { const bool block = hasDecoration(id, spv::Decoration::Block, vstate); @@ -1286,30 +1355,6 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) { << "Such variables must be identified with a Block or " "BufferBlock decoration"; } - // Vulkan: Check DescriptorSet and Binding decoration for - // Uniform and StorageBuffer variables. - if (uniform || storage_buffer) { - auto entry_points = vstate.EntryPointReferences(var_id); - if (!entry_points.empty() && - !hasDecoration(var_id, spv::Decoration::DescriptorSet, - vstate)) { - return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) - << vstate.VkErrorID(6677) << sc_str << " id '" << var_id - << "' is missing DescriptorSet decoration.\n" - << "From Vulkan spec:\n" - << "These variables must have DescriptorSet and Binding " - "decorations specified"; - } - if (!entry_points.empty() && - !hasDecoration(var_id, spv::Decoration::Binding, vstate)) { - return vstate.diag(SPV_ERROR_INVALID_ID, vstate.FindDef(var_id)) - << vstate.VkErrorID(6677) << sc_str << " id '" << var_id - << "' is missing Binding decoration.\n" - << "From Vulkan spec:\n" - << "These variables must have DescriptorSet and Binding " - "decorations specified"; - } - } } if (id != 0) { @@ -1386,14 +1431,14 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) { if (spvIsVulkanEnv(vstate.context()->target_env)) { if (blockRules && (SPV_SUCCESS != - (recursive_status = checkLayout(id, sc_str, deco_str, true, - scalar_block_layout, 0, - constraints, vstate)))) { + (recursive_status = checkLayout( + id, storageClass, deco_str, true, scalar_block_layout, + 0, constraints, vstate)))) { return recursive_status; } else if (bufferRules && (SPV_SUCCESS != (recursive_status = checkLayout( - id, sc_str, deco_str, false, - scalar_block_layout, 0, + id, storageClass, deco_str, + false, scalar_block_layout, 0, constraints, vstate)))) { return recursive_status; } @@ -1413,9 +1458,9 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) { ComputeMemberConstraintsForStruct(&constraints, pointee_type_id, LayoutConstraints(), vstate); } - if (auto res = checkLayout(pointee_type_id, "PhysicalStorageBuffer", - "Block", !buffer, scalar_block_layout, 0, - constraints, vstate)) { + if (auto res = checkLayout( + pointee_type_id, spv::StorageClass::PhysicalStorageBuffer, + "Block", !buffer, scalar_block_layout, 0, constraints, vstate)) { return res; } } else if (vstate.HasCapability(spv::Capability::UntypedPointersKHR) && @@ -1464,14 +1509,6 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) { const auto sc = vstate.FindDef(ptr_ty_id)->GetOperandAs(1); - const char* sc_str = - sc == spv::StorageClass::Uniform - ? "Uniform" - : (sc == spv::StorageClass::PushConstant - ? "PushConstant" - : (sc == spv::StorageClass::Workgroup ? "Workgroup" - : "StorageBuffer")); - auto data_type = vstate.FindDef(data_type_id); scalar_block_layout = sc == spv::StorageClass::Workgroup @@ -1511,7 +1548,7 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) { ? (sc == spv::StorageClass::Uniform ? "BufferBlock" : "Block") : "Block"; if (auto result = - checkLayout(data_type_id, sc_str, deco_str, !bufferRules, + checkLayout(data_type_id, sc, deco_str, !bufferRules, scalar_block_layout, 0, constraints, vstate)) { return result; } @@ -1732,14 +1769,19 @@ spv_result_t CheckFPRoundingModeForShaders(ValidationState_t& vstate, return SPV_SUCCESS; } -// Returns SPV_SUCCESS if validation rules are satisfied for the NonWritable +// Returns SPV_SUCCESS if validation rules are satisfied for the NonReadable or +// NonWritable // decoration. Otherwise emits a diagnostic and returns something other than // SPV_SUCCESS. The |inst| parameter is the object being decorated. This must // be called after TypePass and AnnotateCheckDecorationsOfBuffers are called. -spv_result_t CheckNonWritableDecoration(ValidationState_t& vstate, - const Instruction& inst, - const Decoration& decoration) { +spv_result_t CheckNonReadableWritableDecorations(ValidationState_t& vstate, + const Instruction& inst, + const Decoration& decoration) { assert(inst.id() && "Parser ensures the target of the decoration has an ID"); + const bool is_non_writable = + decoration.dec_type() == spv::Decoration::NonWritable; + assert(is_non_writable || + decoration.dec_type() == spv::Decoration::NonReadable); if (decoration.struct_member_index() == Decoration::kInvalidMember) { // The target must be a memory object declaration. @@ -1751,7 +1793,10 @@ spv_result_t CheckNonWritableDecoration(ValidationState_t& vstate, opcode != spv::Op::OpFunctionParameter && opcode != spv::Op::OpRawAccessChainNV) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) - << "Target of NonWritable decoration must be a memory object " + << "Target of " + << (is_non_writable ? "NonWritable" : "NonReadable") + << " decoration must be a " + "memory object " "declaration (a variable or a function parameter)"; } const auto var_storage_class = @@ -1762,7 +1807,8 @@ spv_result_t CheckNonWritableDecoration(ValidationState_t& vstate, : spv::StorageClass::Max; if ((var_storage_class == spv::StorageClass::Function || var_storage_class == spv::StorageClass::Private) && - vstate.features().nonwritable_var_in_function_or_private) { + vstate.features().nonwritable_var_in_function_or_private && + is_non_writable) { // New permitted feature in SPIR-V 1.4. } else if (var_storage_class == spv::StorageClass::TileAttachmentQCOM) { } else if ( @@ -1770,12 +1816,18 @@ spv_result_t CheckNonWritableDecoration(ValidationState_t& vstate, vstate.IsPointerToUniformBlock(type_id) || vstate.IsPointerToStorageBuffer(type_id) || vstate.IsPointerToStorageImage(type_id) || + vstate.IsPointerToTensor(type_id) || opcode == spv::Op::OpRawAccessChainNV) { } else { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) - << "Target of NonWritable decoration is invalid: must point to a " - "storage image, uniform block, " - << (vstate.features().nonwritable_var_in_function_or_private + << "Target of " + << (is_non_writable ? "NonWritable" : "NonReadable") + << " decoration is invalid: " + "must point to a " + "storage image, tensor variable in UniformConstant storage " + "class, uniform block, " + << (vstate.features().nonwritable_var_in_function_or_private && + is_non_writable ? "storage buffer, or variable in Private or Function " "storage class" : "or storage buffer"); @@ -2063,8 +2115,10 @@ spv_result_t CheckDecorationsFromDecoration(ValidationState_t& vstate) { PASS_OR_BAIL( CheckFPRoundingModeForShaders(vstate, *inst, decoration)); break; + case spv::Decoration::NonReadable: case spv::Decoration::NonWritable: - PASS_OR_BAIL(CheckNonWritableDecoration(vstate, *inst, decoration)); + PASS_OR_BAIL( + CheckNonReadableWritableDecorations(vstate, *inst, decoration)); break; case spv::Decoration::Uniform: case spv::Decoration::UniformId: @@ -2122,17 +2176,19 @@ bool AllowsLayout(ValidationState_t& vstate, const spv::StorageClass sc) { } } -bool UsesExplicitLayout(ValidationState_t& vstate, uint32_t type_id, - std::unordered_map& cache) { +// Returns a decoration used to make it explicit +spv::Decoration UsesExplicitLayout( + ValidationState_t& vstate, uint32_t type_id, + std::unordered_map& cache) { if (type_id == 0) { - return false; + return spv::Decoration::Max; } if (cache.count(type_id)) { return cache[type_id]; } - bool res = false; + spv::Decoration res = spv::Decoration::Max; const auto type_inst = vstate.FindDef(type_id); if (type_inst->opcode() == spv::Op::OpTypeStruct || type_inst->opcode() == spv::Op::OpTypeArray || @@ -2148,21 +2204,26 @@ bool UsesExplicitLayout(ValidationState_t& vstate, uint32_t type_id, allowLayoutDecorations = AllowsLayout(vstate, sc); } if (!allowLayoutDecorations) { - res = std::any_of( - iter->second.begin(), iter->second.end(), [](const Decoration& d) { - return d.dec_type() == spv::Decoration::Block || - d.dec_type() == spv::Decoration::BufferBlock || - d.dec_type() == spv::Decoration::Offset || - d.dec_type() == spv::Decoration::ArrayStride || - d.dec_type() == spv::Decoration::MatrixStride; - }); + for (const auto& d : iter->second) { + const spv::Decoration dec = d.dec_type(); + if (dec == spv::Decoration::Block || + dec == spv::Decoration::BufferBlock || + dec == spv::Decoration::Offset || + dec == spv::Decoration::ArrayStride || + dec == spv::Decoration::MatrixStride) { + res = dec; + break; + } + } } } - if (!res) { + if (res == spv::Decoration::Max) { switch (type_inst->opcode()) { case spv::Op::OpTypeStruct: - for (uint32_t i = 1; !res && i < type_inst->operands().size(); i++) { + for (uint32_t i = 1; + res == spv::Decoration::Max && i < type_inst->operands().size(); + i++) { res = UsesExplicitLayout( vstate, type_inst->GetOperandAs(i), cache); } @@ -2194,10 +2255,13 @@ spv_result_t CheckInvalidVulkanExplicitLayout(ValidationState_t& vstate) { return SPV_SUCCESS; } - std::unordered_map cache; + std::unordered_map cache; for (const auto& inst : vstate.ordered_instructions()) { const auto type_id = inst.type_id(); const auto type_inst = vstate.FindDef(type_id); + + spv::StorageClass sc = spv::StorageClass::Max; + spv::Decoration layout_dec = spv::Decoration::Max; uint32_t fail_id = 0; // Variables are the main place to check for improper decorations, but some // untyped pointer instructions must also be checked since those types may @@ -2207,16 +2271,18 @@ spv_result_t CheckInvalidVulkanExplicitLayout(ValidationState_t& vstate) { switch (inst.opcode()) { case spv::Op::OpVariable: case spv::Op::OpUntypedVariableKHR: { - const auto sc = inst.GetOperandAs(2); + sc = inst.GetOperandAs(2); auto check_id = type_id; if (inst.opcode() == spv::Op::OpUntypedVariableKHR) { if (inst.operands().size() > 3) { check_id = inst.GetOperandAs(3); } } - if (!AllowsLayout(vstate, sc) && - UsesExplicitLayout(vstate, check_id, cache)) { - fail_id = check_id; + if (!AllowsLayout(vstate, sc)) { + layout_dec = UsesExplicitLayout(vstate, check_id, cache); + if (layout_dec != spv::Decoration::Max) { + fail_id = check_id; + } } break; } @@ -2226,13 +2292,17 @@ spv_result_t CheckInvalidVulkanExplicitLayout(ValidationState_t& vstate) { case spv::Op::OpUntypedInBoundsPtrAccessChainKHR: { // Check both the base type and return type. The return type may have an // invalid array stride. - const auto sc = type_inst->GetOperandAs(1); - const auto base_type_id = inst.GetOperandAs(2); + sc = type_inst->GetOperandAs(1); if (!AllowsLayout(vstate, sc)) { - if (UsesExplicitLayout(vstate, base_type_id, cache)) { + const auto base_type_id = inst.GetOperandAs(2); + layout_dec = UsesExplicitLayout(vstate, base_type_id, cache); + if (layout_dec != spv::Decoration::Max) { fail_id = base_type_id; - } else if (UsesExplicitLayout(vstate, type_id, cache)) { - fail_id = type_id; + } else { + layout_dec = UsesExplicitLayout(vstate, type_id, cache); + if (layout_dec != spv::Decoration::Max) { + fail_id = type_id; + } } } break; @@ -2242,11 +2312,13 @@ spv_result_t CheckInvalidVulkanExplicitLayout(ValidationState_t& vstate) { const auto ptr_ty_id = vstate.FindDef(inst.GetOperandAs(3))->type_id(); const auto ptr_ty = vstate.FindDef(ptr_ty_id); - const auto sc = ptr_ty->GetOperandAs(1); - const auto base_type_id = inst.GetOperandAs(2); - if (!AllowsLayout(vstate, sc) && - UsesExplicitLayout(vstate, base_type_id, cache)) { - fail_id = base_type_id; + sc = ptr_ty->GetOperandAs(1); + if (!AllowsLayout(vstate, sc)) { + const auto base_type_id = inst.GetOperandAs(2); + layout_dec = UsesExplicitLayout(vstate, base_type_id, cache); + if (layout_dec != spv::Decoration::Max) { + fail_id = base_type_id; + } } break; } @@ -2255,10 +2327,12 @@ spv_result_t CheckInvalidVulkanExplicitLayout(ValidationState_t& vstate) { const auto ptr_type = vstate.FindDef(vstate.FindDef(ptr_id)->type_id()); if (ptr_type->opcode() == spv::Op::OpTypeUntypedPointerKHR) { // For untyped pointers check the return type for an invalid layout. - const auto sc = ptr_type->GetOperandAs(1); - if (!AllowsLayout(vstate, sc) && - UsesExplicitLayout(vstate, type_id, cache)) { - fail_id = type_id; + sc = ptr_type->GetOperandAs(1); + if (!AllowsLayout(vstate, sc)) { + layout_dec = UsesExplicitLayout(vstate, type_id, cache); + if (layout_dec != spv::Decoration::Max) { + fail_id = type_id; + } } } break; @@ -2269,11 +2343,13 @@ spv_result_t CheckInvalidVulkanExplicitLayout(ValidationState_t& vstate) { if (ptr_type->opcode() == spv::Op::OpTypeUntypedPointerKHR) { // For untyped pointers, check the type of the data operand for an // invalid layout. - const auto sc = ptr_type->GetOperandAs(1); - const auto data_type_id = vstate.GetOperandTypeId(&inst, 1); - if (!AllowsLayout(vstate, sc) && - UsesExplicitLayout(vstate, data_type_id, cache)) { - fail_id = inst.GetOperandAs(2); + sc = ptr_type->GetOperandAs(1); + if (!AllowsLayout(vstate, sc)) { + const auto data_type_id = vstate.GetOperandTypeId(&inst, 1); + layout_dec = UsesExplicitLayout(vstate, data_type_id, cache); + if (layout_dec != spv::Decoration::Max) { + fail_id = inst.GetOperandAs(2); + } } } break; @@ -2285,7 +2361,10 @@ spv_result_t CheckInvalidVulkanExplicitLayout(ValidationState_t& vstate) { return vstate.diag(SPV_ERROR_INVALID_ID, &inst) << vstate.VkErrorID(10684) << "Invalid explicit layout decorations on type for operand " - << vstate.getIdName(fail_id); + << vstate.getIdName(fail_id) << ", the " + << spvtools::StorageClassToString(sc) + << " storage class has a explicit layout from the " + << vstate.SpvDecorationString(layout_dec) << " decoration."; } } @@ -2298,6 +2377,7 @@ spv_result_t ValidateDecorations(ValidationState_t& vstate) { if (auto error = CheckImportedVariableInitialization(vstate)) return error; if (auto error = CheckDecorationsOfEntryPoints(vstate)) return error; if (auto error = CheckDecorationsOfBuffers(vstate)) return error; + if (auto error = CheckDecorationsOfVariables(vstate)) return error; if (auto error = CheckDecorationsCompatibility(vstate)) return error; if (auto error = CheckLinkageAttrOfFunctions(vstate)) return error; if (auto error = CheckVulkanMemoryModelDeprecatedDecorations(vstate)) diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_extensions.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_extensions.cpp index 58aaf52..b26d817 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_extensions.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_extensions.cpp @@ -84,12 +84,37 @@ uint32_t GetUint32Constant(ValidationState_t& _, uint32_t id) { return inst->word(3); } +std::string GetExtInstName(const ValidationState_t& _, + const Instruction* inst) { + const uint32_t ext_inst_set = inst->word(3); + const uint32_t ext_inst_index = inst->word(4); + const spv_ext_inst_type_t ext_inst_type = + spv_ext_inst_type_t(inst->ext_inst_type()); + + const ExtInstDesc* desc = nullptr; + if (LookupExtInst(ext_inst_type, ext_inst_index, &desc) != SPV_SUCCESS || + !desc) { + return std::string("Unknown ExtInst"); + } + + auto* import_inst = _.FindDef(ext_inst_set); + assert(import_inst); + + std::ostringstream ss; + ss << import_inst->GetOperandAs(1); + ss << " "; + ss << desc->name().data(); + + return ss.str(); +} + // Check that the operand of a debug info instruction |inst| at |word_index| // is a result id of an instruction with |expected_opcode|. -spv_result_t ValidateOperandForDebugInfo( - ValidationState_t& _, const std::string& operand_name, - spv::Op expected_opcode, const Instruction* inst, uint32_t word_index, - const std::function& ext_inst_name) { +spv_result_t ValidateOperandForDebugInfo(ValidationState_t& _, + const std::string& operand_name, + spv::Op expected_opcode, + const Instruction* inst, + uint32_t word_index) { auto* operand = _.FindDef(inst->word(word_index)); if (operand->opcode() != expected_opcode) { const spvtools::InstructionDesc* desc = nullptr; @@ -97,12 +122,13 @@ spv_result_t ValidateOperandForDebugInfo( &desc) != SPV_SUCCESS || !desc) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand " << operand_name << " is invalid"; + << GetExtInstName(_, inst) << ": " << "expected operand " + << operand_name << " is invalid"; } return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " << "expected operand " << operand_name - << " must be a result id of " << "Op" << desc->name().data(); + << GetExtInstName(_, inst) << ": " << "expected operand " + << operand_name << " must be a result id of " << "Op" + << desc->name().data(); } return SPV_SUCCESS; } @@ -113,28 +139,26 @@ spv_result_t ValidateOperandForDebugInfo( // word so cannot be validated. spv_result_t ValidateUint32ConstantOperandForDebugInfo( ValidationState_t& _, const std::string& operand_name, - const Instruction* inst, uint32_t word_index, - const std::function& ext_inst_name) { + const Instruction* inst, uint32_t word_index) { if (!IsUint32Constant(_, inst->word(word_index))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": expected operand " << operand_name + << GetExtInstName(_, inst) << ": expected operand " << operand_name << " must be a result id of 32-bit unsigned OpConstant"; } return SPV_SUCCESS; } -#define CHECK_OPERAND(NAME, opcode, index) \ - do { \ - auto result = ValidateOperandForDebugInfo(_, NAME, opcode, inst, index, \ - ext_inst_name); \ - if (result != SPV_SUCCESS) return result; \ +#define CHECK_OPERAND(NAME, opcode, index) \ + do { \ + auto result = ValidateOperandForDebugInfo(_, NAME, opcode, inst, index); \ + if (result != SPV_SUCCESS) return result; \ } while (0) -#define CHECK_CONST_UINT_OPERAND(NAME, index) \ - if (vulkanDebugInfo) { \ - auto result = ValidateUint32ConstantOperandForDebugInfo( \ - _, NAME, inst, index, ext_inst_name); \ - if (result != SPV_SUCCESS) return result; \ +#define CHECK_CONST_UINT_OPERAND(NAME, index) \ + if (vulkanDebugInfo) { \ + auto result = \ + ValidateUint32ConstantOperandForDebugInfo(_, NAME, inst, index); \ + if (result != SPV_SUCCESS) return result; \ } // True if the operand of a debug info instruction |inst| at |word_index| @@ -180,7 +204,7 @@ bool DoesDebugInfoOperandMatchExpectation( spv_result_t ValidateDebugInfoOperand( ValidationState_t& _, const std::string& debug_inst_name, CommonDebugInfoInstructions expected_debug_inst, const Instruction* inst, - uint32_t word_index, const std::function& ext_inst_name) { + uint32_t word_index) { std::function expectation = [expected_debug_inst](CommonDebugInfoInstructions dbg_inst) { return dbg_inst == expected_debug_inst; @@ -193,38 +217,39 @@ spv_result_t ValidateDebugInfoOperand( SPV_SUCCESS || !desc) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand " << debug_inst_name << " is invalid"; + << GetExtInstName(_, inst) << ": " << "expected operand " + << debug_inst_name << " is invalid"; } return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " << "expected operand " << debug_inst_name - << " must be a result id of " << desc->name().data(); + << GetExtInstName(_, inst) << ": " << "expected operand " + << debug_inst_name << " must be a result id of " + << desc->name().data(); } -#define CHECK_DEBUG_OPERAND(NAME, debug_opcode, index) \ - do { \ - auto result = ValidateDebugInfoOperand(_, NAME, debug_opcode, inst, index, \ - ext_inst_name); \ - if (result != SPV_SUCCESS) return result; \ +#define CHECK_DEBUG_OPERAND(NAME, debug_opcode, index) \ + do { \ + auto result = \ + ValidateDebugInfoOperand(_, NAME, debug_opcode, inst, index); \ + if (result != SPV_SUCCESS) return result; \ } while (0) // Check that the operand of a debug info instruction |inst| at |word_index| // is a result id of an debug info instruction with DebugTypeBasic. -spv_result_t ValidateOperandBaseType( - ValidationState_t& _, const Instruction* inst, uint32_t word_index, - const std::function& ext_inst_name) { +spv_result_t ValidateOperandBaseType(ValidationState_t& _, + const Instruction* inst, + uint32_t word_index) { return ValidateDebugInfoOperand(_, "Base Type", CommonDebugInfoDebugTypeBasic, - inst, word_index, ext_inst_name); + inst, word_index); } // Check that the operand of a debug info instruction |inst| at |word_index| // is a result id of a debug lexical scope instruction which is one of // DebugCompilationUnit, DebugFunction, DebugLexicalBlock, or // DebugTypeComposite. -spv_result_t ValidateOperandLexicalScope( - ValidationState_t& _, const std::string& debug_inst_name, - const Instruction* inst, uint32_t word_index, - const std::function& ext_inst_name) { +spv_result_t ValidateOperandLexicalScope(ValidationState_t& _, + const std::string& debug_inst_name, + const Instruction* inst, + uint32_t word_index) { std::function expectation = [](CommonDebugInfoInstructions dbg_inst) { return dbg_inst == CommonDebugInfoDebugCompilationUnit || @@ -236,19 +261,18 @@ spv_result_t ValidateOperandLexicalScope( return SPV_SUCCESS; return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand " << debug_inst_name - << " must be a result id of a lexical scope"; + << GetExtInstName(_, inst) << ": " << "expected operand " + << debug_inst_name << " must be a result id of a lexical scope"; } // Check that the operand of a debug info instruction |inst| at |word_index| // is a result id of a debug type instruction (See DebugTypeXXX in // "4.3. Type instructions" section of OpenCL.DebugInfo.100 spec. -spv_result_t ValidateOperandDebugType( - ValidationState_t& _, const std::string& debug_inst_name, - const Instruction* inst, uint32_t word_index, - const std::function& ext_inst_name, - bool allow_template_param) { +spv_result_t ValidateOperandDebugType(ValidationState_t& _, + const std::string& debug_inst_name, + const Instruction* inst, + uint32_t word_index, + bool allow_template_param) { // Check for NonSemanticShaderDebugInfo100 specific types. if (inst->ext_inst_type() == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) { @@ -275,9 +299,8 @@ spv_result_t ValidateOperandDebugType( return SPV_SUCCESS; return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand " << debug_inst_name - << " is not a valid debug type"; + << GetExtInstName(_, inst) << ": " << "expected operand " + << debug_inst_name << " is not a valid debug type"; } spv_result_t ValidateClspvReflectionKernel(ValidationState_t& _, @@ -1052,7 +1075,9 @@ bool IsDebugVariableWithIntScalarType(ValidationState_t& _, spv_result_t ValidateExtension(ValidationState_t& _, const Instruction* inst) { std::string extension = GetExtensionString(&(inst->c_inst())); if (_.version() < SPV_SPIRV_VERSION_WORD(1, 3)) { - if (extension == ExtensionToString(kSPV_KHR_vulkan_memory_model)) { + if (extension == ExtensionToString(kSPV_KHR_vulkan_memory_model) || + extension == + ExtensionToString(kSPV_QCOM_cooperative_matrix_conversion)) { return _.diag(SPV_ERROR_WRONG_VERSION, inst) << extension << " extension requires SPIR-V version 1.3 or later."; } @@ -1064,7 +1089,9 @@ spv_result_t ValidateExtension(ValidationState_t& _, const Instruction* inst) { extension == ExtensionToString(kSPV_NV_shader_invocation_reorder) || extension == ExtensionToString(kSPV_NV_cluster_acceleration_structure) || - extension == ExtensionToString(kSPV_NV_linear_swept_spheres)) { + extension == ExtensionToString(kSPV_NV_linear_swept_spheres) || + extension == ExtensionToString(kSPV_QCOM_image_processing) || + extension == ExtensionToString(kSPV_QCOM_image_processing2)) { return _.diag(SPV_ERROR_WRONG_VERSION, inst) << extension << " extension requires SPIR-V version 1.4 or later."; } @@ -1081,2755 +1108,2755 @@ spv_result_t ValidateExtInstImport(ValidationState_t& _, const std::string name = inst->GetOperandAs(name_id); if (name.find("NonSemantic.") == 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "NonSemantic extended instruction sets cannot be declared " - "without SPV_KHR_non_semantic_info."; + << "NonSemantic extended instruction " + "sets cannot be declared " + "without SPV_KHR_non_semantic_info. (This can also be fixed " + "having SPIR-V 1.6 or later)"; } } return SPV_SUCCESS; } -spv_result_t ValidateExtInst(ValidationState_t& _, const Instruction* inst) { +spv_result_t ValidateExtInstGlslStd450(ValidationState_t& _, + const Instruction* inst) { const uint32_t result_type = inst->type_id(); const uint32_t num_operands = static_cast(inst->operands().size()); - const uint32_t ext_inst_set = inst->word(3); const uint32_t ext_inst_index = inst->word(4); - const spv_ext_inst_type_t ext_inst_type = - spv_ext_inst_type_t(inst->ext_inst_type()); - - auto ext_inst_name = [&_, ext_inst_set, ext_inst_type, ext_inst_index]() { - const ExtInstDesc* desc = nullptr; - if (LookupExtInst(ext_inst_type, ext_inst_index, &desc) != SPV_SUCCESS || - !desc) { - return std::string("Unknown ExtInst"); - } - - auto* import_inst = _.FindDef(ext_inst_set); - assert(import_inst); - - std::ostringstream ss; - ss << import_inst->GetOperandAs(1); - ss << " "; - ss << desc->name().data(); - - return ss.str(); - }; - - if (ext_inst_type == SPV_EXT_INST_TYPE_GLSL_STD_450) { - const GLSLstd450 ext_inst_key = GLSLstd450(ext_inst_index); - switch (ext_inst_key) { - case GLSLstd450Round: - case GLSLstd450RoundEven: - case GLSLstd450FAbs: - case GLSLstd450Trunc: - case GLSLstd450FSign: - case GLSLstd450Floor: - case GLSLstd450Ceil: - case GLSLstd450Fract: - case GLSLstd450Sqrt: - case GLSLstd450InverseSqrt: - case GLSLstd450FMin: - case GLSLstd450FMax: - case GLSLstd450FClamp: - case GLSLstd450FMix: - case GLSLstd450Step: - case GLSLstd450SmoothStep: - case GLSLstd450Fma: - case GLSLstd450Normalize: - case GLSLstd450FaceForward: - case GLSLstd450Reflect: - case GLSLstd450NMin: - case GLSLstd450NMax: - case GLSLstd450NClamp: { - bool supportsCoopVec = - (ext_inst_key == GLSLstd450FMin || ext_inst_key == GLSLstd450FMax || - ext_inst_key == GLSLstd450FClamp || - ext_inst_key == GLSLstd450NMin || ext_inst_key == GLSLstd450NMax || - ext_inst_key == GLSLstd450NClamp || - ext_inst_key == GLSLstd450Step || ext_inst_key == GLSLstd450Fma); - - if (!_.IsFloatScalarOrVectorType(result_type) && - !(supportsCoopVec && - _.IsFloatCooperativeVectorNVType(result_type))) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float scalar or vector type"; - } - - for (uint32_t operand_index = 4; operand_index < num_operands; - ++operand_index) { - const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); - if (result_type != operand_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected types of all operands to be equal to Result " - "Type"; - } - } - break; + const GLSLstd450 ext_inst_key = GLSLstd450(ext_inst_index); + switch (ext_inst_key) { + case GLSLstd450Round: + case GLSLstd450RoundEven: + case GLSLstd450FAbs: + case GLSLstd450Trunc: + case GLSLstd450FSign: + case GLSLstd450Floor: + case GLSLstd450Ceil: + case GLSLstd450Fract: + case GLSLstd450Sqrt: + case GLSLstd450InverseSqrt: + case GLSLstd450FMin: + case GLSLstd450FMax: + case GLSLstd450FClamp: + case GLSLstd450FMix: + case GLSLstd450Step: + case GLSLstd450SmoothStep: + case GLSLstd450Fma: + case GLSLstd450Normalize: + case GLSLstd450FaceForward: + case GLSLstd450Reflect: + case GLSLstd450NMin: + case GLSLstd450NMax: + case GLSLstd450NClamp: { + bool supportsCoopVec = + (ext_inst_key == GLSLstd450FMin || ext_inst_key == GLSLstd450FMax || + ext_inst_key == GLSLstd450FClamp || ext_inst_key == GLSLstd450NMin || + ext_inst_key == GLSLstd450NMax || ext_inst_key == GLSLstd450NClamp || + ext_inst_key == GLSLstd450Step || ext_inst_key == GLSLstd450Fma); + + if (!_.IsFloatScalarOrVectorType(result_type) && + !(supportsCoopVec && _.IsFloatCooperativeVectorNVType(result_type))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float scalar or vector type"; } - case GLSLstd450SAbs: - case GLSLstd450SSign: - case GLSLstd450UMin: - case GLSLstd450SMin: - case GLSLstd450UMax: - case GLSLstd450SMax: - case GLSLstd450UClamp: - case GLSLstd450SClamp: - case GLSLstd450FindILsb: - case GLSLstd450FindUMsb: - case GLSLstd450FindSMsb: { - bool supportsCoopVec = - (ext_inst_key == GLSLstd450UMin || ext_inst_key == GLSLstd450UMax || - ext_inst_key == GLSLstd450UClamp || - ext_inst_key == GLSLstd450SMin || ext_inst_key == GLSLstd450SMax || - ext_inst_key == GLSLstd450SClamp); - - if (!_.IsIntScalarOrVectorType(result_type) && - !(supportsCoopVec && _.IsIntCooperativeVectorNVType(result_type))) { + for (uint32_t operand_index = 4; operand_index < num_operands; + ++operand_index) { + const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); + if (result_type != operand_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be an int scalar or vector type"; + << GetExtInstName(_, inst) << ": " + << "expected types of all operands to be equal to Result " + "Type"; } + } + break; + } - const uint32_t result_type_bit_width = _.GetBitWidth(result_type); - const uint32_t result_type_dimension = _.GetDimension(result_type); - - for (uint32_t operand_index = 4; operand_index < num_operands; - ++operand_index) { - const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); - if (!operand_type || - (!_.IsIntScalarOrVectorType(operand_type) && - !(supportsCoopVec && - _.IsIntCooperativeVectorNVType(operand_type)))) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected all operands to be int scalars or vectors"; - } - - if (result_type_dimension != _.GetDimension(operand_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected all operands to have the same dimension as " - << "Result Type"; - } + case GLSLstd450SAbs: + case GLSLstd450SSign: + case GLSLstd450UMin: + case GLSLstd450SMin: + case GLSLstd450UMax: + case GLSLstd450SMax: + case GLSLstd450UClamp: + case GLSLstd450SClamp: + case GLSLstd450FindILsb: + case GLSLstd450FindUMsb: + case GLSLstd450FindSMsb: { + bool supportsCoopVec = + (ext_inst_key == GLSLstd450UMin || ext_inst_key == GLSLstd450UMax || + ext_inst_key == GLSLstd450UClamp || ext_inst_key == GLSLstd450SMin || + ext_inst_key == GLSLstd450SMax || ext_inst_key == GLSLstd450SClamp); + + if (!_.IsIntScalarOrVectorType(result_type) && + !(supportsCoopVec && _.IsIntCooperativeVectorNVType(result_type))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be an int scalar or vector type"; + } - if (result_type_bit_width != _.GetBitWidth(operand_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected all operands to have the same bit width as " - << "Result Type"; - } + const uint32_t result_type_bit_width = _.GetBitWidth(result_type); + const uint32_t result_type_dimension = _.GetDimension(result_type); - if (ext_inst_key == GLSLstd450FindUMsb || - ext_inst_key == GLSLstd450FindSMsb) { - if (result_type_bit_width != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "this instruction is currently limited to 32-bit width " - << "components"; - } - } + for (uint32_t operand_index = 4; operand_index < num_operands; + ++operand_index) { + const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); + if (!operand_type || + (!_.IsIntScalarOrVectorType(operand_type) && + !(supportsCoopVec && + _.IsIntCooperativeVectorNVType(operand_type)))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected all operands to be int scalars or vectors"; } - break; - } - case GLSLstd450Radians: - case GLSLstd450Degrees: - case GLSLstd450Sin: - case GLSLstd450Cos: - case GLSLstd450Tan: - case GLSLstd450Asin: - case GLSLstd450Acos: - case GLSLstd450Atan: - case GLSLstd450Sinh: - case GLSLstd450Cosh: - case GLSLstd450Tanh: - case GLSLstd450Asinh: - case GLSLstd450Acosh: - case GLSLstd450Atanh: - case GLSLstd450Exp: - case GLSLstd450Exp2: - case GLSLstd450Log: - case GLSLstd450Log2: - case GLSLstd450Atan2: - case GLSLstd450Pow: { - bool supportsCoopVec = - (ext_inst_key == GLSLstd450Atan || ext_inst_key == GLSLstd450Tanh || - ext_inst_key == GLSLstd450Exp || ext_inst_key == GLSLstd450Log); - - if (!_.IsFloatScalarOrVectorType(result_type) && - !(supportsCoopVec && - _.IsFloatCooperativeVectorNVType(result_type))) { + if (result_type_dimension != _.GetDimension(operand_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a 16 or 32-bit scalar or " - "vector float type"; + << GetExtInstName(_, inst) << ": " + << "expected all operands to have the same dimension as " + << "Result Type"; } - const uint32_t result_type_bit_width = _.GetBitWidth(result_type); - if (result_type_bit_width != 16 && result_type_bit_width != 32) { + if (result_type_bit_width != _.GetBitWidth(operand_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a 16 or 32-bit scalar or " - "vector float type"; + << GetExtInstName(_, inst) << ": " + << "expected all operands to have the same bit width as " + << "Result Type"; } - for (uint32_t operand_index = 4; operand_index < num_operands; - ++operand_index) { - const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); - if (result_type != operand_type) { + if (ext_inst_key == GLSLstd450FindUMsb || + ext_inst_key == GLSLstd450FindSMsb) { + if (result_type_bit_width != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected types of all operands to be equal to Result " - "Type"; + << GetExtInstName(_, inst) << ": " + << "this instruction is currently limited to 32-bit width " + << "components"; } } - break; } + break; + } - case GLSLstd450Determinant: { - const uint32_t x_type = _.GetOperandTypeId(inst, 4); - uint32_t num_rows = 0; - uint32_t num_cols = 0; - uint32_t col_type = 0; - uint32_t component_type = 0; - if (!_.GetMatrixTypeInfo(x_type, &num_rows, &num_cols, &col_type, - &component_type) || - num_rows != num_cols) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X to be a square matrix"; - } + case GLSLstd450Radians: + case GLSLstd450Degrees: + case GLSLstd450Sin: + case GLSLstd450Cos: + case GLSLstd450Tan: + case GLSLstd450Asin: + case GLSLstd450Acos: + case GLSLstd450Atan: + case GLSLstd450Sinh: + case GLSLstd450Cosh: + case GLSLstd450Tanh: + case GLSLstd450Asinh: + case GLSLstd450Acosh: + case GLSLstd450Atanh: + case GLSLstd450Exp: + case GLSLstd450Exp2: + case GLSLstd450Log: + case GLSLstd450Log2: + case GLSLstd450Atan2: + case GLSLstd450Pow: { + bool supportsCoopVec = + (ext_inst_key == GLSLstd450Atan || ext_inst_key == GLSLstd450Tanh || + ext_inst_key == GLSLstd450Exp || ext_inst_key == GLSLstd450Log); + + if (!_.IsFloatScalarOrVectorType(result_type) && + !(supportsCoopVec && _.IsFloatCooperativeVectorNVType(result_type))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a 16 or 32-bit scalar or " + "vector float type"; + } - if (result_type != component_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X component type to be equal to " - << "Result Type"; - } - break; + const uint32_t result_type_bit_width = _.GetBitWidth(result_type); + if (result_type_bit_width != 16 && result_type_bit_width != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a 16 or 32-bit scalar or " + "vector float type"; } - case GLSLstd450MatrixInverse: { - uint32_t num_rows = 0; - uint32_t num_cols = 0; - uint32_t col_type = 0; - uint32_t component_type = 0; - if (!_.GetMatrixTypeInfo(result_type, &num_rows, &num_cols, &col_type, - &component_type) || - num_rows != num_cols) { + for (uint32_t operand_index = 4; operand_index < num_operands; + ++operand_index) { + const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); + if (result_type != operand_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a square matrix"; + << GetExtInstName(_, inst) << ": " + << "expected types of all operands to be equal to Result " + "Type"; } + } + break; + } - const uint32_t x_type = _.GetOperandTypeId(inst, 4); - if (result_type != x_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X type to be equal to Result Type"; - } - break; + case GLSLstd450Determinant: { + const uint32_t x_type = _.GetOperandTypeId(inst, 4); + uint32_t num_rows = 0; + uint32_t num_cols = 0; + uint32_t col_type = 0; + uint32_t component_type = 0; + if (!_.GetMatrixTypeInfo(x_type, &num_rows, &num_cols, &col_type, + &component_type) || + num_rows != num_cols) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X to be a square matrix"; } - case GLSLstd450Modf: { - if (!_.IsFloatScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or vector float type"; - } + if (result_type != component_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X component type to be equal to " + << "Result Type"; + } + break; + } - const uint32_t x_type = _.GetOperandTypeId(inst, 4); - const uint32_t i_type = _.GetOperandTypeId(inst, 5); + case GLSLstd450MatrixInverse: { + uint32_t num_rows = 0; + uint32_t num_cols = 0; + uint32_t col_type = 0; + uint32_t component_type = 0; + if (!_.GetMatrixTypeInfo(result_type, &num_rows, &num_cols, &col_type, + &component_type) || + num_rows != num_cols) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a square matrix"; + } - if (x_type != result_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X type to be equal to Result Type"; - } + const uint32_t x_type = _.GetOperandTypeId(inst, 4); + if (result_type != x_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X type to be equal to Result Type"; + } + break; + } - spv::StorageClass i_storage_class; - uint32_t i_data_type = 0; - if (!_.GetPointerTypeInfo(i_type, &i_data_type, &i_storage_class)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand I to be a pointer"; - } + case GLSLstd450Modf: { + if (!_.IsFloatScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or vector float type"; + } - if (i_data_type != result_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand I data type to be equal to Result Type"; - } + const uint32_t x_type = _.GetOperandTypeId(inst, 4); + const uint32_t i_type = _.GetOperandTypeId(inst, 5); - break; + if (x_type != result_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X type to be equal to Result Type"; } - case GLSLstd450ModfStruct: { - std::vector result_types; - if (!_.GetStructMemberTypes(result_type, &result_types) || - result_types.size() != 2 || - !_.IsFloatScalarOrVectorType(result_types[0]) || - result_types[1] != result_types[0]) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a struct with two identical " - << "scalar or vector float type members"; - } + spv::StorageClass i_storage_class; + uint32_t i_data_type = 0; + if (!_.GetPointerTypeInfo(i_type, &i_data_type, &i_storage_class)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand I to be a pointer"; + } - const uint32_t x_type = _.GetOperandTypeId(inst, 4); - if (x_type != result_types[0]) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X type to be equal to members of " - << "Result Type struct"; - } - break; + if (i_data_type != result_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand I data type to be equal to Result Type"; } - case GLSLstd450Frexp: { - if (!_.IsFloatScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or vector float type"; - } + break; + } - const uint32_t x_type = _.GetOperandTypeId(inst, 4); - const uint32_t exp_type = _.GetOperandTypeId(inst, 5); + case GLSLstd450ModfStruct: { + std::vector result_types; + if (!_.GetStructMemberTypes(result_type, &result_types) || + result_types.size() != 2 || + !_.IsFloatScalarOrVectorType(result_types[0]) || + result_types[1] != result_types[0]) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a struct with two identical " + << "scalar or vector float type members"; + } - if (x_type != result_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X type to be equal to Result Type"; - } + const uint32_t x_type = _.GetOperandTypeId(inst, 4); + if (x_type != result_types[0]) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X type to be equal to members of " + << "Result Type struct"; + } + break; + } - spv::StorageClass exp_storage_class; - uint32_t exp_data_type = 0; - if (!_.GetPointerTypeInfo(exp_type, &exp_data_type, - &exp_storage_class)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Exp to be a pointer"; - } + case GLSLstd450Frexp: { + if (!_.IsFloatScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or vector float type"; + } - if (!_.IsIntScalarOrVectorType(exp_data_type) || - (!_.HasExtension(kSPV_AMD_gpu_shader_int16) && - _.GetBitWidth(exp_data_type) != 32) || - (_.HasExtension(kSPV_AMD_gpu_shader_int16) && - _.GetBitWidth(exp_data_type) != 16 && - _.GetBitWidth(exp_data_type) != 32)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Exp data type to be a " - << (_.HasExtension(kSPV_AMD_gpu_shader_int16) - ? "16-bit or 32-bit " - : "32-bit ") - << "int scalar or vector type"; - } + const uint32_t x_type = _.GetOperandTypeId(inst, 4); + const uint32_t exp_type = _.GetOperandTypeId(inst, 5); - if (_.GetDimension(result_type) != _.GetDimension(exp_data_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Exp data type to have the same component " - << "number as Result Type"; - } + if (x_type != result_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X type to be equal to Result Type"; + } - break; + spv::StorageClass exp_storage_class; + uint32_t exp_data_type = 0; + if (!_.GetPointerTypeInfo(exp_type, &exp_data_type, &exp_storage_class)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Exp to be a pointer"; } - case GLSLstd450Ldexp: { - if (!_.IsFloatScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or vector float type"; - } + if (!_.IsIntScalarOrVectorType(exp_data_type) || + (!_.HasExtension(kSPV_AMD_gpu_shader_int16) && + _.GetBitWidth(exp_data_type) != 32) || + (_.HasExtension(kSPV_AMD_gpu_shader_int16) && + _.GetBitWidth(exp_data_type) != 16 && + _.GetBitWidth(exp_data_type) != 32)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Exp data type to be a " + << (_.HasExtension(kSPV_AMD_gpu_shader_int16) + ? "16-bit or 32-bit " + : "32-bit ") + << "int scalar or vector type"; + } - const uint32_t x_type = _.GetOperandTypeId(inst, 4); - const uint32_t exp_type = _.GetOperandTypeId(inst, 5); + if (_.GetDimension(result_type) != _.GetDimension(exp_data_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Exp data type to have the same component " + << "number as Result Type"; + } - if (x_type != result_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X type to be equal to Result Type"; - } + break; + } - if (!_.IsIntScalarOrVectorType(exp_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Exp to be a 32-bit int scalar " - << "or vector type"; - } + case GLSLstd450Ldexp: { + if (!_.IsFloatScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or vector float type"; + } - if (_.GetDimension(result_type) != _.GetDimension(exp_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Exp to have the same component " - << "number as Result Type"; - } + const uint32_t x_type = _.GetOperandTypeId(inst, 4); + const uint32_t exp_type = _.GetOperandTypeId(inst, 5); - break; + if (x_type != result_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X type to be equal to Result Type"; } - case GLSLstd450FrexpStruct: { - std::vector result_types; - if (!_.GetStructMemberTypes(result_type, &result_types) || - result_types.size() != 2 || - !_.IsFloatScalarOrVectorType(result_types[0]) || - !_.IsIntScalarOrVectorType(result_types[1]) || - (!_.HasExtension(kSPV_AMD_gpu_shader_int16) && - _.GetBitWidth(result_types[1]) != 32) || - (_.HasExtension(kSPV_AMD_gpu_shader_int16) && - _.GetBitWidth(result_types[1]) != 16 && - _.GetBitWidth(result_types[1]) != 32) || - _.GetDimension(result_types[0]) != - _.GetDimension(result_types[1])) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a struct with two members, " - << "first member a float scalar or vector, second member a " - << (_.HasExtension(kSPV_AMD_gpu_shader_int16) - ? "16-bit or 32-bit " - : "32-bit ") - << "int scalar or vector with the same number of " - << "components as the first member"; - } + if (!_.IsIntScalarOrVectorType(exp_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Exp to be a 32-bit int scalar " + << "or vector type"; + } - const uint32_t x_type = _.GetOperandTypeId(inst, 4); - if (x_type != result_types[0]) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X type to be equal to the first member " - << "of Result Type struct"; - } - break; + if (_.GetDimension(result_type) != _.GetDimension(exp_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Exp to have the same component " + << "number as Result Type"; } - case GLSLstd450PackSnorm4x8: - case GLSLstd450PackUnorm4x8: { - if (!_.IsIntScalarType(result_type) || - _.GetBitWidth(result_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be 32-bit int scalar type"; - } + break; + } - const uint32_t v_type = _.GetOperandTypeId(inst, 4); - if (!_.IsFloatVectorType(v_type) || _.GetDimension(v_type) != 4 || - _.GetBitWidth(v_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand V to be a 32-bit float vector of size 4"; - } - break; + case GLSLstd450FrexpStruct: { + std::vector result_types; + if (!_.GetStructMemberTypes(result_type, &result_types) || + result_types.size() != 2 || + !_.IsFloatScalarOrVectorType(result_types[0]) || + !_.IsIntScalarOrVectorType(result_types[1]) || + (!_.HasExtension(kSPV_AMD_gpu_shader_int16) && + _.GetBitWidth(result_types[1]) != 32) || + (_.HasExtension(kSPV_AMD_gpu_shader_int16) && + _.GetBitWidth(result_types[1]) != 16 && + _.GetBitWidth(result_types[1]) != 32) || + _.GetDimension(result_types[0]) != _.GetDimension(result_types[1])) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a struct with two members, " + << "first member a float scalar or vector, second member a " + << (_.HasExtension(kSPV_AMD_gpu_shader_int16) + ? "16-bit or 32-bit " + : "32-bit ") + << "int scalar or vector with the same number of " + << "components as the first member"; } - case GLSLstd450PackSnorm2x16: - case GLSLstd450PackUnorm2x16: - case GLSLstd450PackHalf2x16: { - if (!_.IsIntScalarType(result_type) || - _.GetBitWidth(result_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be 32-bit int scalar type"; - } + const uint32_t x_type = _.GetOperandTypeId(inst, 4); + if (x_type != result_types[0]) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X type to be equal to the first member " + << "of Result Type struct"; + } + break; + } - const uint32_t v_type = _.GetOperandTypeId(inst, 4); - if (!_.IsFloatVectorType(v_type) || _.GetDimension(v_type) != 2 || - _.GetBitWidth(v_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand V to be a 32-bit float vector of size 2"; - } - break; + case GLSLstd450PackSnorm4x8: + case GLSLstd450PackUnorm4x8: { + if (!_.IsIntScalarType(result_type) || _.GetBitWidth(result_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be 32-bit int scalar type"; } - case GLSLstd450PackDouble2x32: { - if (!_.IsFloatScalarType(result_type) || - _.GetBitWidth(result_type) != 64) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be 64-bit float scalar type"; - } + const uint32_t v_type = _.GetOperandTypeId(inst, 4); + if (!_.IsFloatVectorType(v_type) || _.GetDimension(v_type) != 4 || + _.GetBitWidth(v_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand V to be a 32-bit float vector of size 4"; + } + break; + } - const uint32_t v_type = _.GetOperandTypeId(inst, 4); - if (!_.IsIntVectorType(v_type) || _.GetDimension(v_type) != 2 || - _.GetBitWidth(v_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand V to be a 32-bit int vector of size 2"; - } - break; + case GLSLstd450PackSnorm2x16: + case GLSLstd450PackUnorm2x16: + case GLSLstd450PackHalf2x16: { + if (!_.IsIntScalarType(result_type) || _.GetBitWidth(result_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be 32-bit int scalar type"; } - case GLSLstd450UnpackSnorm4x8: - case GLSLstd450UnpackUnorm4x8: { - if (!_.IsFloatVectorType(result_type) || - _.GetDimension(result_type) != 4 || - _.GetBitWidth(result_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a 32-bit float vector of size " - "4"; - } + const uint32_t v_type = _.GetOperandTypeId(inst, 4); + if (!_.IsFloatVectorType(v_type) || _.GetDimension(v_type) != 2 || + _.GetBitWidth(v_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand V to be a 32-bit float vector of size 2"; + } + break; + } - const uint32_t v_type = _.GetOperandTypeId(inst, 4); - if (!_.IsIntScalarType(v_type) || _.GetBitWidth(v_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P to be a 32-bit int scalar"; - } - break; + case GLSLstd450PackDouble2x32: { + if (!_.IsFloatScalarType(result_type) || + _.GetBitWidth(result_type) != 64) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be 64-bit float scalar type"; } - case GLSLstd450UnpackSnorm2x16: - case GLSLstd450UnpackUnorm2x16: - case GLSLstd450UnpackHalf2x16: { - if (!_.IsFloatVectorType(result_type) || - _.GetDimension(result_type) != 2 || - _.GetBitWidth(result_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a 32-bit float vector of size " - "2"; - } + const uint32_t v_type = _.GetOperandTypeId(inst, 4); + if (!_.IsIntVectorType(v_type) || _.GetDimension(v_type) != 2 || + _.GetBitWidth(v_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand V to be a 32-bit int vector of size 2"; + } + break; + } - const uint32_t v_type = _.GetOperandTypeId(inst, 4); - if (!_.IsIntScalarType(v_type) || _.GetBitWidth(v_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P to be a 32-bit int scalar"; - } - break; + case GLSLstd450UnpackSnorm4x8: + case GLSLstd450UnpackUnorm4x8: { + if (!_.IsFloatVectorType(result_type) || + _.GetDimension(result_type) != 4 || + _.GetBitWidth(result_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a 32-bit float vector of size " + "4"; } - case GLSLstd450UnpackDouble2x32: { - if (!_.IsIntVectorType(result_type) || - _.GetDimension(result_type) != 2 || - _.GetBitWidth(result_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a 32-bit int vector of size " - "2"; - } + const uint32_t v_type = _.GetOperandTypeId(inst, 4); + if (!_.IsIntScalarType(v_type) || _.GetBitWidth(v_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P to be a 32-bit int scalar"; + } + break; + } - const uint32_t v_type = _.GetOperandTypeId(inst, 4); - if (!_.IsFloatScalarType(v_type) || _.GetBitWidth(v_type) != 64) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand V to be a 64-bit float scalar"; - } - break; + case GLSLstd450UnpackSnorm2x16: + case GLSLstd450UnpackUnorm2x16: + case GLSLstd450UnpackHalf2x16: { + if (!_.IsFloatVectorType(result_type) || + _.GetDimension(result_type) != 2 || + _.GetBitWidth(result_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a 32-bit float vector of size " + "2"; } - case GLSLstd450Length: { - if (!_.IsFloatScalarType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float scalar type"; - } + const uint32_t v_type = _.GetOperandTypeId(inst, 4); + if (!_.IsIntScalarType(v_type) || _.GetBitWidth(v_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P to be a 32-bit int scalar"; + } + break; + } - const uint32_t x_type = _.GetOperandTypeId(inst, 4); - if (!_.IsFloatScalarOrVectorType(x_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X to be of float scalar or vector type"; - } + case GLSLstd450UnpackDouble2x32: { + if (!_.IsIntVectorType(result_type) || _.GetDimension(result_type) != 2 || + _.GetBitWidth(result_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a 32-bit int vector of size " + "2"; + } - if (result_type != _.GetComponentType(x_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X component type to be equal to Result " - "Type"; - } - break; + const uint32_t v_type = _.GetOperandTypeId(inst, 4); + if (!_.IsFloatScalarType(v_type) || _.GetBitWidth(v_type) != 64) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand V to be a 64-bit float scalar"; } + break; + } - case GLSLstd450Distance: { - if (!_.IsFloatScalarType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float scalar type"; - } + case GLSLstd450Length: { + if (!_.IsFloatScalarType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float scalar type"; + } - const uint32_t p0_type = _.GetOperandTypeId(inst, 4); - if (!_.IsFloatScalarOrVectorType(p0_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P0 to be of float scalar or vector type"; - } + const uint32_t x_type = _.GetOperandTypeId(inst, 4); + if (!_.IsFloatScalarOrVectorType(x_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X to be of float scalar or vector type"; + } - if (result_type != _.GetComponentType(p0_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P0 component type to be equal to " - << "Result Type"; - } + if (result_type != _.GetComponentType(x_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X component type to be equal to Result " + "Type"; + } + break; + } - const uint32_t p1_type = _.GetOperandTypeId(inst, 5); - if (!_.IsFloatScalarOrVectorType(p1_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P1 to be of float scalar or vector type"; - } + case GLSLstd450Distance: { + if (!_.IsFloatScalarType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float scalar type"; + } - if (result_type != _.GetComponentType(p1_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P1 component type to be equal to " - << "Result Type"; - } + const uint32_t p0_type = _.GetOperandTypeId(inst, 4); + if (!_.IsFloatScalarOrVectorType(p0_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P0 to be of float scalar or vector type"; + } - if (_.GetDimension(p0_type) != _.GetDimension(p1_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operands P0 and P1 to have the same number of " - << "components"; - } - break; + if (result_type != _.GetComponentType(p0_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P0 component type to be equal to " + << "Result Type"; } - case GLSLstd450Cross: { - if (!_.IsFloatVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float vector type"; - } + const uint32_t p1_type = _.GetOperandTypeId(inst, 5); + if (!_.IsFloatScalarOrVectorType(p1_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P1 to be of float scalar or vector type"; + } - if (_.GetDimension(result_type) != 3) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to have 3 components"; - } + if (result_type != _.GetComponentType(p1_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P1 component type to be equal to " + << "Result Type"; + } - const uint32_t x_type = _.GetOperandTypeId(inst, 4); - const uint32_t y_type = _.GetOperandTypeId(inst, 5); + if (_.GetDimension(p0_type) != _.GetDimension(p1_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operands P0 and P1 to have the same number of " + << "components"; + } + break; + } - if (x_type != result_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X type to be equal to Result Type"; - } + case GLSLstd450Cross: { + if (!_.IsFloatVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float vector type"; + } - if (y_type != result_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Y type to be equal to Result Type"; - } - break; + if (_.GetDimension(result_type) != 3) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to have 3 components"; } - case GLSLstd450Refract: { - if (!_.IsFloatScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float scalar or vector type"; - } + const uint32_t x_type = _.GetOperandTypeId(inst, 4); + const uint32_t y_type = _.GetOperandTypeId(inst, 5); - const uint32_t i_type = _.GetOperandTypeId(inst, 4); - const uint32_t n_type = _.GetOperandTypeId(inst, 5); - const uint32_t eta_type = _.GetOperandTypeId(inst, 6); + if (x_type != result_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X type to be equal to Result Type"; + } - if (result_type != i_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand I to be of type equal to Result Type"; - } + if (y_type != result_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Y type to be equal to Result Type"; + } + break; + } - if (result_type != n_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand N to be of type equal to Result Type"; - } + case GLSLstd450Refract: { + if (!_.IsFloatScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float scalar or vector type"; + } - if (!_.IsFloatScalarType(eta_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Eta to be a float scalar"; - } - break; + const uint32_t i_type = _.GetOperandTypeId(inst, 4); + const uint32_t n_type = _.GetOperandTypeId(inst, 5); + const uint32_t eta_type = _.GetOperandTypeId(inst, 6); + + if (result_type != i_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand I to be of type equal to Result Type"; } - case GLSLstd450InterpolateAtCentroid: - case GLSLstd450InterpolateAtSample: - case GLSLstd450InterpolateAtOffset: { - if (!_.HasCapability(spv::Capability::InterpolationFunction)) { - return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst) - << ext_inst_name() - << " requires capability InterpolationFunction"; - } + if (result_type != n_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand N to be of type equal to Result Type"; + } - if (!_.IsFloatScalarOrVectorType(result_type) || - _.GetBitWidth(result_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a 32-bit float scalar " - << "or vector type"; - } + if (!_.IsFloatScalarType(eta_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Eta to be a float scalar"; + } + break; + } + + case GLSLstd450InterpolateAtCentroid: + case GLSLstd450InterpolateAtSample: + case GLSLstd450InterpolateAtOffset: { + if (!_.HasCapability(spv::Capability::InterpolationFunction)) { + return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst) + << GetExtInstName(_, inst) + << " requires capability InterpolationFunction"; + } + + if (!_.IsFloatScalarOrVectorType(result_type) || + _.GetBitWidth(result_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a 32-bit float scalar " + << "or vector type"; + } + + // If HLSL legalization and first operand is an OpLoad, use load + // pointer as the interpolant lvalue. Else use interpolate first + // operand. + uint32_t interp_id = inst->GetOperandAs(4); + auto* interp_inst = _.FindDef(interp_id); + uint32_t interpolant_type = (_.options()->before_hlsl_legalization && + interp_inst->opcode() == spv::Op::OpLoad) + ? _.GetOperandTypeId(interp_inst, 2) + : _.GetOperandTypeId(inst, 4); + + spv::StorageClass interpolant_storage_class; + uint32_t interpolant_data_type = 0; + if (!_.GetPointerTypeInfo(interpolant_type, &interpolant_data_type, + &interpolant_storage_class)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Interpolant to be a pointer"; + } + + if (result_type != interpolant_data_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Interpolant data type to be equal to Result Type"; + } + + if (interpolant_storage_class != spv::StorageClass::Input) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Interpolant storage class to be Input"; + } - // If HLSL legalization and first operand is an OpLoad, use load - // pointer as the interpolant lvalue. Else use interpolate first - // operand. - uint32_t interp_id = inst->GetOperandAs(4); - auto* interp_inst = _.FindDef(interp_id); - uint32_t interpolant_type = (_.options()->before_hlsl_legalization && - interp_inst->opcode() == spv::Op::OpLoad) - ? _.GetOperandTypeId(interp_inst, 2) - : _.GetOperandTypeId(inst, 4); - - spv::StorageClass interpolant_storage_class; - uint32_t interpolant_data_type = 0; - if (!_.GetPointerTypeInfo(interpolant_type, &interpolant_data_type, - &interpolant_storage_class)) { + if (ext_inst_key == GLSLstd450InterpolateAtSample) { + const uint32_t sample_type = _.GetOperandTypeId(inst, 5); + if (!_.IsIntScalarType(sample_type) || + _.GetBitWidth(sample_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Interpolant to be a pointer"; + << GetExtInstName(_, inst) << ": " + << "expected Sample to be 32-bit integer"; } + } - if (result_type != interpolant_data_type) { + if (ext_inst_key == GLSLstd450InterpolateAtOffset) { + const uint32_t offset_type = _.GetOperandTypeId(inst, 5); + if (!_.IsFloatVectorType(offset_type) || + _.GetDimension(offset_type) != 2 || + _.GetBitWidth(offset_type) != 32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Interpolant data type to be equal to Result Type"; + << GetExtInstName(_, inst) << ": " + << "expected Offset to be a vector of 2 32-bit floats"; } + } + + _.function(inst->function()->id()) + ->RegisterExecutionModelLimitation( + spv::ExecutionModel::Fragment, + GetExtInstName(_, inst) + + std::string(" requires Fragment execution model")); + break; + } + + case GLSLstd450IMix: { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Extended instruction GLSLstd450IMix is not supported"; + } + + case GLSLstd450Bad: { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Encountered extended instruction GLSLstd450Bad"; + } + + case GLSLstd450Count: { + assert(0); + break; + } + } + + return SPV_SUCCESS; +} + +spv_result_t ValidateExtInstOpenClStd(ValidationState_t& _, + const Instruction* inst) { + const uint32_t result_type = inst->type_id(); + const uint32_t num_operands = static_cast(inst->operands().size()); + const uint32_t ext_inst_index = inst->word(4); + const OpenCLLIB::Entrypoints ext_inst_key = + OpenCLLIB::Entrypoints(ext_inst_index); + switch (ext_inst_key) { + case OpenCLLIB::Acos: + case OpenCLLIB::Acosh: + case OpenCLLIB::Acospi: + case OpenCLLIB::Asin: + case OpenCLLIB::Asinh: + case OpenCLLIB::Asinpi: + case OpenCLLIB::Atan: + case OpenCLLIB::Atan2: + case OpenCLLIB::Atanh: + case OpenCLLIB::Atanpi: + case OpenCLLIB::Atan2pi: + case OpenCLLIB::Cbrt: + case OpenCLLIB::Ceil: + case OpenCLLIB::Copysign: + case OpenCLLIB::Cos: + case OpenCLLIB::Cosh: + case OpenCLLIB::Cospi: + case OpenCLLIB::Erfc: + case OpenCLLIB::Erf: + case OpenCLLIB::Exp: + case OpenCLLIB::Exp2: + case OpenCLLIB::Exp10: + case OpenCLLIB::Expm1: + case OpenCLLIB::Fabs: + case OpenCLLIB::Fdim: + case OpenCLLIB::Floor: + case OpenCLLIB::Fma: + case OpenCLLIB::Fmax: + case OpenCLLIB::Fmin: + case OpenCLLIB::Fmod: + case OpenCLLIB::Hypot: + case OpenCLLIB::Lgamma: + case OpenCLLIB::Log: + case OpenCLLIB::Log2: + case OpenCLLIB::Log10: + case OpenCLLIB::Log1p: + case OpenCLLIB::Logb: + case OpenCLLIB::Mad: + case OpenCLLIB::Maxmag: + case OpenCLLIB::Minmag: + case OpenCLLIB::Nextafter: + case OpenCLLIB::Pow: + case OpenCLLIB::Powr: + case OpenCLLIB::Remainder: + case OpenCLLIB::Rint: + case OpenCLLIB::Round: + case OpenCLLIB::Rsqrt: + case OpenCLLIB::Sin: + case OpenCLLIB::Sinh: + case OpenCLLIB::Sinpi: + case OpenCLLIB::Sqrt: + case OpenCLLIB::Tan: + case OpenCLLIB::Tanh: + case OpenCLLIB::Tanpi: + case OpenCLLIB::Tgamma: + case OpenCLLIB::Trunc: + case OpenCLLIB::Half_cos: + case OpenCLLIB::Half_divide: + case OpenCLLIB::Half_exp: + case OpenCLLIB::Half_exp2: + case OpenCLLIB::Half_exp10: + case OpenCLLIB::Half_log: + case OpenCLLIB::Half_log2: + case OpenCLLIB::Half_log10: + case OpenCLLIB::Half_powr: + case OpenCLLIB::Half_recip: + case OpenCLLIB::Half_rsqrt: + case OpenCLLIB::Half_sin: + case OpenCLLIB::Half_sqrt: + case OpenCLLIB::Half_tan: + case OpenCLLIB::Native_cos: + case OpenCLLIB::Native_divide: + case OpenCLLIB::Native_exp: + case OpenCLLIB::Native_exp2: + case OpenCLLIB::Native_exp10: + case OpenCLLIB::Native_log: + case OpenCLLIB::Native_log2: + case OpenCLLIB::Native_log10: + case OpenCLLIB::Native_powr: + case OpenCLLIB::Native_recip: + case OpenCLLIB::Native_rsqrt: + case OpenCLLIB::Native_sin: + case OpenCLLIB::Native_sqrt: + case OpenCLLIB::Native_tan: + case OpenCLLIB::FClamp: + case OpenCLLIB::Degrees: + case OpenCLLIB::FMax_common: + case OpenCLLIB::FMin_common: + case OpenCLLIB::Mix: + case OpenCLLIB::Radians: + case OpenCLLIB::Step: + case OpenCLLIB::Smoothstep: + case OpenCLLIB::Sign: { + if (!_.IsFloatScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float scalar or vector type"; + } + + const uint32_t num_components = _.GetDimension(result_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or a vector with 2, " + "3, 4, 8 or 16 components"; + } - if (interpolant_storage_class != spv::StorageClass::Input) { + for (uint32_t operand_index = 4; operand_index < num_operands; + ++operand_index) { + const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); + if (result_type != operand_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Interpolant storage class to be Input"; + << GetExtInstName(_, inst) << ": " + << "expected types of all operands to be equal to Result " + "Type"; } + } + break; + } - if (ext_inst_key == GLSLstd450InterpolateAtSample) { - const uint32_t sample_type = _.GetOperandTypeId(inst, 5); - if (!_.IsIntScalarType(sample_type) || - _.GetBitWidth(sample_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Sample to be 32-bit integer"; - } - } + case OpenCLLIB::Fract: + case OpenCLLIB::Modf: + case OpenCLLIB::Sincos: { + if (!_.IsFloatScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float scalar or vector type"; + } - if (ext_inst_key == GLSLstd450InterpolateAtOffset) { - const uint32_t offset_type = _.GetOperandTypeId(inst, 5); - if (!_.IsFloatVectorType(offset_type) || - _.GetDimension(offset_type) != 2 || - _.GetBitWidth(offset_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Offset to be a vector of 2 32-bit floats"; - } - } + const uint32_t num_components = _.GetDimension(result_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or a vector with 2, " + "3, 4, 8 or 16 components"; + } - _.function(inst->function()->id()) - ->RegisterExecutionModelLimitation( - spv::ExecutionModel::Fragment, - ext_inst_name() + - std::string(" requires Fragment execution model")); - break; + const uint32_t x_type = _.GetOperandTypeId(inst, 4); + if (result_type != x_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected type of operand X to be equal to Result Type"; } - case GLSLstd450IMix: { + const uint32_t p_type = _.GetOperandTypeId(inst, 5); + spv::StorageClass p_storage_class; + uint32_t p_data_type = 0; + if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "Extended instruction GLSLstd450IMix is not supported"; + << GetExtInstName(_, inst) << ": " + << "expected the last operand to be a pointer"; } - case GLSLstd450Bad: { + if (p_storage_class != spv::StorageClass::Generic && + p_storage_class != spv::StorageClass::CrossWorkgroup && + p_storage_class != spv::StorageClass::Workgroup && + p_storage_class != spv::StorageClass::Function) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "Encountered extended instruction GLSLstd450Bad"; + << GetExtInstName(_, inst) << ": " + << "expected storage class of the pointer to be Generic, " + "CrossWorkgroup, Workgroup or Function"; } - case GLSLstd450Count: { - assert(0); - break; + if (!_.ContainsUntypedPointer(p_type) && result_type != p_data_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected data type of the pointer to be equal to Result " + "Type"; } + break; } - } else if (ext_inst_type == SPV_EXT_INST_TYPE_OPENCL_STD) { - const OpenCLLIB::Entrypoints ext_inst_key = - OpenCLLIB::Entrypoints(ext_inst_index); - switch (ext_inst_key) { - case OpenCLLIB::Acos: - case OpenCLLIB::Acosh: - case OpenCLLIB::Acospi: - case OpenCLLIB::Asin: - case OpenCLLIB::Asinh: - case OpenCLLIB::Asinpi: - case OpenCLLIB::Atan: - case OpenCLLIB::Atan2: - case OpenCLLIB::Atanh: - case OpenCLLIB::Atanpi: - case OpenCLLIB::Atan2pi: - case OpenCLLIB::Cbrt: - case OpenCLLIB::Ceil: - case OpenCLLIB::Copysign: - case OpenCLLIB::Cos: - case OpenCLLIB::Cosh: - case OpenCLLIB::Cospi: - case OpenCLLIB::Erfc: - case OpenCLLIB::Erf: - case OpenCLLIB::Exp: - case OpenCLLIB::Exp2: - case OpenCLLIB::Exp10: - case OpenCLLIB::Expm1: - case OpenCLLIB::Fabs: - case OpenCLLIB::Fdim: - case OpenCLLIB::Floor: - case OpenCLLIB::Fma: - case OpenCLLIB::Fmax: - case OpenCLLIB::Fmin: - case OpenCLLIB::Fmod: - case OpenCLLIB::Hypot: - case OpenCLLIB::Lgamma: - case OpenCLLIB::Log: - case OpenCLLIB::Log2: - case OpenCLLIB::Log10: - case OpenCLLIB::Log1p: - case OpenCLLIB::Logb: - case OpenCLLIB::Mad: - case OpenCLLIB::Maxmag: - case OpenCLLIB::Minmag: - case OpenCLLIB::Nextafter: - case OpenCLLIB::Pow: - case OpenCLLIB::Powr: - case OpenCLLIB::Remainder: - case OpenCLLIB::Rint: - case OpenCLLIB::Round: - case OpenCLLIB::Rsqrt: - case OpenCLLIB::Sin: - case OpenCLLIB::Sinh: - case OpenCLLIB::Sinpi: - case OpenCLLIB::Sqrt: - case OpenCLLIB::Tan: - case OpenCLLIB::Tanh: - case OpenCLLIB::Tanpi: - case OpenCLLIB::Tgamma: - case OpenCLLIB::Trunc: - case OpenCLLIB::Half_cos: - case OpenCLLIB::Half_divide: - case OpenCLLIB::Half_exp: - case OpenCLLIB::Half_exp2: - case OpenCLLIB::Half_exp10: - case OpenCLLIB::Half_log: - case OpenCLLIB::Half_log2: - case OpenCLLIB::Half_log10: - case OpenCLLIB::Half_powr: - case OpenCLLIB::Half_recip: - case OpenCLLIB::Half_rsqrt: - case OpenCLLIB::Half_sin: - case OpenCLLIB::Half_sqrt: - case OpenCLLIB::Half_tan: - case OpenCLLIB::Native_cos: - case OpenCLLIB::Native_divide: - case OpenCLLIB::Native_exp: - case OpenCLLIB::Native_exp2: - case OpenCLLIB::Native_exp10: - case OpenCLLIB::Native_log: - case OpenCLLIB::Native_log2: - case OpenCLLIB::Native_log10: - case OpenCLLIB::Native_powr: - case OpenCLLIB::Native_recip: - case OpenCLLIB::Native_rsqrt: - case OpenCLLIB::Native_sin: - case OpenCLLIB::Native_sqrt: - case OpenCLLIB::Native_tan: - case OpenCLLIB::FClamp: - case OpenCLLIB::Degrees: - case OpenCLLIB::FMax_common: - case OpenCLLIB::FMin_common: - case OpenCLLIB::Mix: - case OpenCLLIB::Radians: - case OpenCLLIB::Step: - case OpenCLLIB::Smoothstep: - case OpenCLLIB::Sign: { - if (!_.IsFloatScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float scalar or vector type"; - } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or a vector with 2, " - "3, 4, 8 or 16 components"; - } + case OpenCLLIB::Frexp: + case OpenCLLIB::Lgamma_r: + case OpenCLLIB::Remquo: { + if (!_.IsFloatScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float scalar or vector type"; + } - for (uint32_t operand_index = 4; operand_index < num_operands; - ++operand_index) { - const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); - if (result_type != operand_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected types of all operands to be equal to Result " - "Type"; - } - } - break; + const uint32_t num_components = _.GetDimension(result_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or a vector with 2, " + "3, 4, 8 or 16 components"; } - case OpenCLLIB::Fract: - case OpenCLLIB::Modf: - case OpenCLLIB::Sincos: { - if (!_.IsFloatScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float scalar or vector type"; - } + uint32_t operand_index = 4; + const uint32_t x_type = _.GetOperandTypeId(inst, operand_index++); + if (result_type != x_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected type of operand X to be equal to Result Type"; + } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { + if (ext_inst_key == OpenCLLIB::Remquo) { + const uint32_t y_type = _.GetOperandTypeId(inst, operand_index++); + if (result_type != y_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or a vector with 2, " - "3, 4, 8 or 16 components"; + << GetExtInstName(_, inst) << ": " + << "expected type of operand Y to be equal to Result Type"; } + } - const uint32_t x_type = _.GetOperandTypeId(inst, 4); - if (result_type != x_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected type of operand X to be equal to Result Type"; - } + const uint32_t p_type = _.GetOperandTypeId(inst, operand_index++); + spv::StorageClass p_storage_class; + uint32_t p_data_type = 0; + if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected the last operand to be a pointer"; + } - const uint32_t p_type = _.GetOperandTypeId(inst, 5); - spv::StorageClass p_storage_class; - uint32_t p_data_type = 0; - if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected the last operand to be a pointer"; - } + if (p_storage_class != spv::StorageClass::Generic && + p_storage_class != spv::StorageClass::CrossWorkgroup && + p_storage_class != spv::StorageClass::Workgroup && + p_storage_class != spv::StorageClass::Function) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected storage class of the pointer to be Generic, " + "CrossWorkgroup, Workgroup or Function"; + } - if (p_storage_class != spv::StorageClass::Generic && - p_storage_class != spv::StorageClass::CrossWorkgroup && - p_storage_class != spv::StorageClass::Workgroup && - p_storage_class != spv::StorageClass::Function) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected storage class of the pointer to be Generic, " - "CrossWorkgroup, Workgroup or Function"; - } + if ((!_.IsIntScalarOrVectorType(p_data_type) || + _.GetBitWidth(p_data_type) != 32) && + !_.ContainsUntypedPointer(p_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected data type of the pointer to be a 32-bit int " + "scalar or vector type"; + } - if (!_.ContainsUntypedPointer(p_type) && result_type != p_data_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected data type of the pointer to be equal to Result " - "Type"; - } - break; + if (!_.ContainsUntypedPointer(p_type) && + _.GetDimension(p_data_type) != num_components) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected data type of the pointer to have the same number " + "of components as Result Type"; } + break; + } - case OpenCLLIB::Frexp: - case OpenCLLIB::Lgamma_r: - case OpenCLLIB::Remquo: { - if (!_.IsFloatScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float scalar or vector type"; - } + case OpenCLLIB::Ilogb: { + if (!_.IsIntScalarOrVectorType(result_type) || + _.GetBitWidth(result_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a 32-bit int scalar or vector " + "type"; + } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or a vector with 2, " - "3, 4, 8 or 16 components"; - } + const uint32_t num_components = _.GetDimension(result_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or a vector with 2, " + "3, 4, 8 or 16 components"; + } - uint32_t operand_index = 4; - const uint32_t x_type = _.GetOperandTypeId(inst, operand_index++); - if (result_type != x_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected type of operand X to be equal to Result Type"; - } + const uint32_t x_type = _.GetOperandTypeId(inst, 4); + if (!_.IsFloatScalarOrVectorType(x_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X to be a float scalar or vector"; + } - if (ext_inst_key == OpenCLLIB::Remquo) { - const uint32_t y_type = _.GetOperandTypeId(inst, operand_index++); - if (result_type != y_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected type of operand Y to be equal to Result Type"; - } - } + if (_.GetDimension(x_type) != num_components) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X to have the same number of components " + "as Result Type"; + } + break; + } - const uint32_t p_type = _.GetOperandTypeId(inst, operand_index++); - spv::StorageClass p_storage_class; - uint32_t p_data_type = 0; - if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected the last operand to be a pointer"; - } + case OpenCLLIB::Ldexp: + case OpenCLLIB::Pown: + case OpenCLLIB::Rootn: { + if (!_.IsFloatScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float scalar or vector type"; + } - if (p_storage_class != spv::StorageClass::Generic && - p_storage_class != spv::StorageClass::CrossWorkgroup && - p_storage_class != spv::StorageClass::Workgroup && - p_storage_class != spv::StorageClass::Function) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected storage class of the pointer to be Generic, " - "CrossWorkgroup, Workgroup or Function"; - } + const uint32_t num_components = _.GetDimension(result_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or a vector with 2, " + "3, 4, 8 or 16 components"; + } - if ((!_.IsIntScalarOrVectorType(p_data_type) || - _.GetBitWidth(p_data_type) != 32) && - !_.ContainsUntypedPointer(p_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected data type of the pointer to be a 32-bit int " - "scalar or vector type"; - } + const uint32_t x_type = _.GetOperandTypeId(inst, 4); + if (result_type != x_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected type of operand X to be equal to Result Type"; + } - if (!_.ContainsUntypedPointer(p_type) && - _.GetDimension(p_data_type) != num_components) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected data type of the pointer to have the same number " - "of components as Result Type"; - } - break; + const uint32_t exp_type = _.GetOperandTypeId(inst, 5); + if (!_.IsIntScalarOrVectorType(exp_type) || + _.GetBitWidth(exp_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected the exponent to be a 32-bit int scalar or vector"; } - case OpenCLLIB::Ilogb: { - if (!_.IsIntScalarOrVectorType(result_type) || - _.GetBitWidth(result_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a 32-bit int scalar or vector " - "type"; - } + if (_.GetDimension(exp_type) != num_components) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected the exponent to have the same number of " + "components as Result Type"; + } + break; + } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or a vector with 2, " - "3, 4, 8 or 16 components"; - } + case OpenCLLIB::Nan: { + if (!_.IsFloatScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float scalar or vector type"; + } - const uint32_t x_type = _.GetOperandTypeId(inst, 4); - if (!_.IsFloatScalarOrVectorType(x_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X to be a float scalar or vector"; - } + const uint32_t num_components = _.GetDimension(result_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or a vector with 2, " + "3, 4, 8 or 16 components"; + } - if (_.GetDimension(x_type) != num_components) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X to have the same number of components " - "as Result Type"; - } - break; + const uint32_t nancode_type = _.GetOperandTypeId(inst, 4); + if (!_.IsIntScalarOrVectorType(nancode_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Nancode to be an int scalar or vector type"; } - case OpenCLLIB::Ldexp: - case OpenCLLIB::Pown: - case OpenCLLIB::Rootn: { - if (!_.IsFloatScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float scalar or vector type"; - } + if (_.GetDimension(nancode_type) != num_components) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Nancode to have the same number of components as " + "Result Type"; + } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or a vector with 2, " - "3, 4, 8 or 16 components"; - } + if (_.GetBitWidth(result_type) != _.GetBitWidth(nancode_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Nancode to have the same bit width as Result " + "Type"; + } + break; + } - const uint32_t x_type = _.GetOperandTypeId(inst, 4); - if (result_type != x_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected type of operand X to be equal to Result Type"; - } + case OpenCLLIB::SAbs: + case OpenCLLIB::SAbs_diff: + case OpenCLLIB::SAdd_sat: + case OpenCLLIB::UAdd_sat: + case OpenCLLIB::SHadd: + case OpenCLLIB::UHadd: + case OpenCLLIB::SRhadd: + case OpenCLLIB::URhadd: + case OpenCLLIB::SClamp: + case OpenCLLIB::UClamp: + case OpenCLLIB::Clz: + case OpenCLLIB::Ctz: + case OpenCLLIB::SMad_hi: + case OpenCLLIB::UMad_sat: + case OpenCLLIB::SMad_sat: + case OpenCLLIB::SMax: + case OpenCLLIB::UMax: + case OpenCLLIB::SMin: + case OpenCLLIB::UMin: + case OpenCLLIB::SMul_hi: + case OpenCLLIB::Rotate: + case OpenCLLIB::SSub_sat: + case OpenCLLIB::USub_sat: + case OpenCLLIB::Popcount: + case OpenCLLIB::UAbs: + case OpenCLLIB::UAbs_diff: + case OpenCLLIB::UMul_hi: + case OpenCLLIB::UMad_hi: { + if (!_.IsIntScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be an int scalar or vector type"; + } - const uint32_t exp_type = _.GetOperandTypeId(inst, 5); - if (!_.IsIntScalarOrVectorType(exp_type) || - _.GetBitWidth(exp_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected the exponent to be a 32-bit int scalar or vector"; - } + const uint32_t num_components = _.GetDimension(result_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or a vector with 2, " + "3, 4, 8 or 16 components"; + } - if (_.GetDimension(exp_type) != num_components) { + for (uint32_t operand_index = 4; operand_index < num_operands; + ++operand_index) { + const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); + if (result_type != operand_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected the exponent to have the same number of " - "components as Result Type"; + << GetExtInstName(_, inst) << ": " + << "expected types of all operands to be equal to Result " + "Type"; } - break; + } + break; + } + + case OpenCLLIB::U_Upsample: + case OpenCLLIB::S_Upsample: { + if (!_.IsIntScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be an int scalar or vector " + "type"; } - case OpenCLLIB::Nan: { - if (!_.IsFloatScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float scalar or vector type"; - } + const uint32_t result_num_components = _.GetDimension(result_type); + if (result_num_components > 4 && result_num_components != 8 && + result_num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or a vector with 2, " + "3, 4, 8 or 16 components"; + } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or a vector with 2, " - "3, 4, 8 or 16 components"; - } + const uint32_t result_bit_width = _.GetBitWidth(result_type); + if (result_bit_width != 16 && result_bit_width != 32 && + result_bit_width != 64) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected bit width of Result Type components to be 16, 32 " + "or 64"; + } - const uint32_t nancode_type = _.GetOperandTypeId(inst, 4); - if (!_.IsIntScalarOrVectorType(nancode_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Nancode to be an int scalar or vector type"; - } + const uint32_t hi_type = _.GetOperandTypeId(inst, 4); + const uint32_t lo_type = _.GetOperandTypeId(inst, 5); - if (_.GetDimension(nancode_type) != num_components) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Nancode to have the same number of components as " - "Result Type"; - } + if (hi_type != lo_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Hi and Lo operands to have the same type"; + } + + if (result_num_components != _.GetDimension(hi_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Hi and Lo operands to have the same number of " + "components as Result Type"; + } + + if (result_bit_width != 2 * _.GetBitWidth(hi_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected bit width of components of Hi and Lo operands to " + "be half of the bit width of components of Result Type"; + } + break; + } + + case OpenCLLIB::SMad24: + case OpenCLLIB::UMad24: + case OpenCLLIB::SMul24: + case OpenCLLIB::UMul24: { + if (!_.IsIntScalarOrVectorType(result_type) || + _.GetBitWidth(result_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a 32-bit int scalar or vector " + "type"; + } + + const uint32_t num_components = _.GetDimension(result_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or a vector with 2, " + "3, 4, 8 or 16 components"; + } - if (_.GetBitWidth(result_type) != _.GetBitWidth(nancode_type)) { + for (uint32_t operand_index = 4; operand_index < num_operands; + ++operand_index) { + const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); + if (result_type != operand_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Nancode to have the same bit width as Result " + << GetExtInstName(_, inst) << ": " + << "expected types of all operands to be equal to Result " "Type"; } - break; } + break; + } - case OpenCLLIB::SAbs: - case OpenCLLIB::SAbs_diff: - case OpenCLLIB::SAdd_sat: - case OpenCLLIB::UAdd_sat: - case OpenCLLIB::SHadd: - case OpenCLLIB::UHadd: - case OpenCLLIB::SRhadd: - case OpenCLLIB::URhadd: - case OpenCLLIB::SClamp: - case OpenCLLIB::UClamp: - case OpenCLLIB::Clz: - case OpenCLLIB::Ctz: - case OpenCLLIB::SMad_hi: - case OpenCLLIB::UMad_sat: - case OpenCLLIB::SMad_sat: - case OpenCLLIB::SMax: - case OpenCLLIB::UMax: - case OpenCLLIB::SMin: - case OpenCLLIB::UMin: - case OpenCLLIB::SMul_hi: - case OpenCLLIB::Rotate: - case OpenCLLIB::SSub_sat: - case OpenCLLIB::USub_sat: - case OpenCLLIB::Popcount: - case OpenCLLIB::UAbs: - case OpenCLLIB::UAbs_diff: - case OpenCLLIB::UMul_hi: - case OpenCLLIB::UMad_hi: { - if (!_.IsIntScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be an int scalar or vector type"; - } + case OpenCLLIB::Cross: { + if (!_.IsFloatVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float vector type"; + } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or a vector with 2, " - "3, 4, 8 or 16 components"; - } + const uint32_t num_components = _.GetDimension(result_type); + if (num_components != 3 && num_components != 4) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to have 3 or 4 components"; + } - for (uint32_t operand_index = 4; operand_index < num_operands; - ++operand_index) { - const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); - if (result_type != operand_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected types of all operands to be equal to Result " - "Type"; - } - } - break; + const uint32_t x_type = _.GetOperandTypeId(inst, 4); + const uint32_t y_type = _.GetOperandTypeId(inst, 5); + + if (x_type != result_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X type to be equal to Result Type"; } - case OpenCLLIB::U_Upsample: - case OpenCLLIB::S_Upsample: { - if (!_.IsIntScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be an int scalar or vector " - "type"; - } + if (y_type != result_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Y type to be equal to Result Type"; + } + break; + } - const uint32_t result_num_components = _.GetDimension(result_type); - if (result_num_components > 4 && result_num_components != 8 && - result_num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or a vector with 2, " - "3, 4, 8 or 16 components"; - } + case OpenCLLIB::Distance: + case OpenCLLIB::Fast_distance: { + if (!_.IsFloatScalarType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float scalar type"; + } - const uint32_t result_bit_width = _.GetBitWidth(result_type); - if (result_bit_width != 16 && result_bit_width != 32 && - result_bit_width != 64) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected bit width of Result Type components to be 16, 32 " - "or 64"; - } + const uint32_t p0_type = _.GetOperandTypeId(inst, 4); + if (!_.IsFloatScalarOrVectorType(p0_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P0 to be of float scalar or vector type"; + } - const uint32_t hi_type = _.GetOperandTypeId(inst, 4); - const uint32_t lo_type = _.GetOperandTypeId(inst, 5); + const uint32_t num_components = _.GetDimension(p0_type); + if (num_components > 4) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P0 to have no more than 4 components"; + } - if (hi_type != lo_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Hi and Lo operands to have the same type"; - } + if (result_type != _.GetComponentType(p0_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P0 component type to be equal to " + << "Result Type"; + } - if (result_num_components != _.GetDimension(hi_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Hi and Lo operands to have the same number of " - "components as Result Type"; - } + const uint32_t p1_type = _.GetOperandTypeId(inst, 5); + if (p0_type != p1_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operands P0 and P1 to be of the same type"; + } + break; + } - if (result_bit_width != 2 * _.GetBitWidth(hi_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected bit width of components of Hi and Lo operands to " - "be half of the bit width of components of Result Type"; - } - break; + case OpenCLLIB::Length: + case OpenCLLIB::Fast_length: { + if (!_.IsFloatScalarType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float scalar type"; } - case OpenCLLIB::SMad24: - case OpenCLLIB::UMad24: - case OpenCLLIB::SMul24: - case OpenCLLIB::UMul24: { - if (!_.IsIntScalarOrVectorType(result_type) || - _.GetBitWidth(result_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a 32-bit int scalar or vector " - "type"; - } + const uint32_t p_type = _.GetOperandTypeId(inst, 4); + if (!_.IsFloatScalarOrVectorType(p_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P to be a float scalar or vector"; + } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or a vector with 2, " - "3, 4, 8 or 16 components"; - } + const uint32_t num_components = _.GetDimension(p_type); + if (num_components > 4) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P to have no more than 4 components"; + } - for (uint32_t operand_index = 4; operand_index < num_operands; - ++operand_index) { - const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); - if (result_type != operand_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected types of all operands to be equal to Result " - "Type"; - } - } - break; + if (result_type != _.GetComponentType(p_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P component type to be equal to Result " + "Type"; } + break; + } - case OpenCLLIB::Cross: { - if (!_.IsFloatVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float vector type"; - } + case OpenCLLIB::Normalize: + case OpenCLLIB::Fast_normalize: { + if (!_.IsFloatScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float scalar or vector type"; + } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components != 3 && num_components != 4) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to have 3 or 4 components"; - } + const uint32_t num_components = _.GetDimension(result_type); + if (num_components > 4) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to have no more than 4 components"; + } - const uint32_t x_type = _.GetOperandTypeId(inst, 4); - const uint32_t y_type = _.GetOperandTypeId(inst, 5); + const uint32_t p_type = _.GetOperandTypeId(inst, 4); + if (p_type != result_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P type to be equal to Result Type"; + } + break; + } - if (x_type != result_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X type to be equal to Result Type"; - } + case OpenCLLIB::Bitselect: { + if (!_.IsFloatScalarOrVectorType(result_type) && + !_.IsIntScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be an int or float scalar or " + "vector type"; + } - if (y_type != result_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Y type to be equal to Result Type"; - } - break; + const uint32_t num_components = _.GetDimension(result_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or a vector with 2, " + "3, 4, 8 or 16 components"; } - case OpenCLLIB::Distance: - case OpenCLLIB::Fast_distance: { - if (!_.IsFloatScalarType(result_type)) { + for (uint32_t operand_index = 4; operand_index < num_operands; + ++operand_index) { + const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); + if (result_type != operand_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float scalar type"; + << GetExtInstName(_, inst) << ": " + << "expected types of all operands to be equal to Result " + "Type"; } + } + break; + } - const uint32_t p0_type = _.GetOperandTypeId(inst, 4); - if (!_.IsFloatScalarOrVectorType(p0_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P0 to be of float scalar or vector type"; - } + case OpenCLLIB::Select: { + if (!_.IsFloatScalarOrVectorType(result_type) && + !_.IsIntScalarOrVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be an int or float scalar or " + "vector type"; + } - const uint32_t num_components = _.GetDimension(p0_type); - if (num_components > 4) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P0 to have no more than 4 components"; - } + const uint32_t num_components = _.GetDimension(result_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or a vector with 2, " + "3, 4, 8 or 16 components"; + } - if (result_type != _.GetComponentType(p0_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P0 component type to be equal to " - << "Result Type"; - } + const uint32_t a_type = _.GetOperandTypeId(inst, 4); + const uint32_t b_type = _.GetOperandTypeId(inst, 5); + const uint32_t c_type = _.GetOperandTypeId(inst, 6); - const uint32_t p1_type = _.GetOperandTypeId(inst, 5); - if (p0_type != p1_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operands P0 and P1 to be of the same type"; - } - break; + if (result_type != a_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand A type to be equal to Result Type"; } - case OpenCLLIB::Length: - case OpenCLLIB::Fast_length: { - if (!_.IsFloatScalarType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float scalar type"; - } + if (result_type != b_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand B type to be equal to Result Type"; + } + + if (!_.IsIntScalarOrVectorType(c_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand C to be an int scalar or vector"; + } - const uint32_t p_type = _.GetOperandTypeId(inst, 4); - if (!_.IsFloatScalarOrVectorType(p_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P to be a float scalar or vector"; - } + if (num_components != _.GetDimension(c_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand C to have the same number of components " + "as Result Type"; + } - const uint32_t num_components = _.GetDimension(p_type); - if (num_components > 4) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P to have no more than 4 components"; - } + if (_.GetBitWidth(result_type) != _.GetBitWidth(c_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand C to have the same bit width as Result " + "Type"; + } + break; + } - if (result_type != _.GetComponentType(p_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P component type to be equal to Result " - "Type"; - } - break; + case OpenCLLIB::Vloadn: { + if (!_.IsFloatVectorType(result_type) && + !_.IsIntVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be an int or float vector type"; } - case OpenCLLIB::Normalize: - case OpenCLLIB::Fast_normalize: { - if (!_.IsFloatScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float scalar or vector type"; - } + const uint32_t num_components = _.GetDimension(result_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to have 2, 3, 4, 8 or 16 components"; + } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components > 4) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to have no more than 4 components"; - } + const uint32_t offset_type = _.GetOperandTypeId(inst, 4); + const uint32_t p_type = _.GetOperandTypeId(inst, 5); - const uint32_t p_type = _.GetOperandTypeId(inst, 4); - if (p_type != result_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P type to be equal to Result Type"; - } - break; + const uint32_t size_t_bit_width = GetSizeTBitWidth(_); + if (!size_t_bit_width) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) + << " can only be used with physical addressing models"; } - case OpenCLLIB::Bitselect: { - if (!_.IsFloatScalarOrVectorType(result_type) && - !_.IsIntScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be an int or float scalar or " - "vector type"; - } + if (!_.IsIntScalarType(offset_type) || + _.GetBitWidth(offset_type) != size_t_bit_width) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Offset to be of type size_t (" + << size_t_bit_width + << "-bit integer for the addressing model used in the module)"; + } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or a vector with 2, " - "3, 4, 8 or 16 components"; - } + spv::StorageClass p_storage_class; + uint32_t p_data_type = 0; + if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P to be a pointer"; + } - for (uint32_t operand_index = 4; operand_index < num_operands; - ++operand_index) { - const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index); - if (result_type != operand_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected types of all operands to be equal to Result " - "Type"; - } - } - break; + if (p_storage_class != spv::StorageClass::UniformConstant && + p_storage_class != spv::StorageClass::Generic && + p_storage_class != spv::StorageClass::CrossWorkgroup && + p_storage_class != spv::StorageClass::Workgroup && + p_storage_class != spv::StorageClass::Function) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P storage class to be UniformConstant, " + "Generic, CrossWorkgroup, Workgroup or Function"; } - case OpenCLLIB::Select: { - if (!_.IsFloatScalarOrVectorType(result_type) && - !_.IsIntScalarOrVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be an int or float scalar or " - "vector type"; - } + if (_.GetComponentType(result_type) != p_data_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P data type to be equal to component " + "type of Result Type"; + } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or a vector with 2, " - "3, 4, 8 or 16 components"; - } + const uint32_t n_value = inst->word(7); + if (num_components != n_value) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected literal N to be equal to the number of " + "components of Result Type"; + } + break; + } - const uint32_t a_type = _.GetOperandTypeId(inst, 4); - const uint32_t b_type = _.GetOperandTypeId(inst, 5); - const uint32_t c_type = _.GetOperandTypeId(inst, 6); + case OpenCLLIB::Vstoren: { + if (_.GetIdOpcode(result_type) != spv::Op::OpTypeVoid) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) + << ": expected Result Type to be void"; + } - if (result_type != a_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand A type to be equal to Result Type"; - } + const uint32_t data_type = _.GetOperandTypeId(inst, 4); + const uint32_t offset_type = _.GetOperandTypeId(inst, 5); + const uint32_t p_type = _.GetOperandTypeId(inst, 6); - if (result_type != b_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand B type to be equal to Result Type"; - } + if (!_.IsFloatVectorType(data_type) && !_.IsIntVectorType(data_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Data to be an int or float vector"; + } - if (!_.IsIntScalarOrVectorType(c_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand C to be an int scalar or vector"; - } + const uint32_t num_components = _.GetDimension(data_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Data to have 2, 3, 4, 8 or 16 components"; + } - if (num_components != _.GetDimension(c_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand C to have the same number of components " - "as Result Type"; - } + const uint32_t size_t_bit_width = GetSizeTBitWidth(_); + if (!size_t_bit_width) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) + << " can only be used with physical addressing models"; + } - if (_.GetBitWidth(result_type) != _.GetBitWidth(c_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand C to have the same bit width as Result " - "Type"; - } - break; + if (!_.IsIntScalarType(offset_type) || + _.GetBitWidth(offset_type) != size_t_bit_width) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Offset to be of type size_t (" + << size_t_bit_width + << "-bit integer for the addressing model used in the module)"; } - case OpenCLLIB::Vloadn: { - if (!_.IsFloatVectorType(result_type) && - !_.IsIntVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be an int or float vector type"; - } + spv::StorageClass p_storage_class; + uint32_t p_data_type = 0; + if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P to be a pointer"; + } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to have 2, 3, 4, 8 or 16 components"; - } + if (p_storage_class != spv::StorageClass::Generic && + p_storage_class != spv::StorageClass::CrossWorkgroup && + p_storage_class != spv::StorageClass::Workgroup && + p_storage_class != spv::StorageClass::Function) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P storage class to be Generic, " + "CrossWorkgroup, Workgroup or Function"; + } - const uint32_t offset_type = _.GetOperandTypeId(inst, 4); - const uint32_t p_type = _.GetOperandTypeId(inst, 5); + if (_.GetComponentType(data_type) != p_data_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P data type to be equal to the type of " + "operand Data components"; + } + break; + } - const uint32_t size_t_bit_width = GetSizeTBitWidth(_); - if (!size_t_bit_width) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() - << " can only be used with physical addressing models"; - } + case OpenCLLIB::Vload_half: { + if (!_.IsFloatScalarType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float scalar type"; + } - if (!_.IsIntScalarType(offset_type) || - _.GetBitWidth(offset_type) != size_t_bit_width) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Offset to be of type size_t (" - << size_t_bit_width - << "-bit integer for the addressing model used in the module)"; - } + const uint32_t offset_type = _.GetOperandTypeId(inst, 4); + const uint32_t p_type = _.GetOperandTypeId(inst, 5); - spv::StorageClass p_storage_class; - uint32_t p_data_type = 0; - if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P to be a pointer"; - } + const uint32_t size_t_bit_width = GetSizeTBitWidth(_); + if (!size_t_bit_width) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) + << " can only be used with physical addressing models"; + } - if (p_storage_class != spv::StorageClass::UniformConstant && - p_storage_class != spv::StorageClass::Generic && - p_storage_class != spv::StorageClass::CrossWorkgroup && - p_storage_class != spv::StorageClass::Workgroup && - p_storage_class != spv::StorageClass::Function) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P storage class to be UniformConstant, " - "Generic, CrossWorkgroup, Workgroup or Function"; - } + if (!_.IsIntScalarType(offset_type) || + _.GetBitWidth(offset_type) != size_t_bit_width) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Offset to be of type size_t (" + << size_t_bit_width + << "-bit integer for the addressing model used in the module)"; + } - if (_.GetComponentType(result_type) != p_data_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P data type to be equal to component " - "type of Result Type"; - } + spv::StorageClass p_storage_class; + uint32_t p_data_type = 0; + if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P to be a pointer"; + } - const uint32_t n_value = inst->word(7); - if (num_components != n_value) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected literal N to be equal to the number of " - "components of Result Type"; - } - break; + if (p_storage_class != spv::StorageClass::UniformConstant && + p_storage_class != spv::StorageClass::Generic && + p_storage_class != spv::StorageClass::CrossWorkgroup && + p_storage_class != spv::StorageClass::Workgroup && + p_storage_class != spv::StorageClass::Function) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P storage class to be UniformConstant, " + "Generic, CrossWorkgroup, Workgroup or Function"; } - case OpenCLLIB::Vstoren: { - if (_.GetIdOpcode(result_type) != spv::Op::OpTypeVoid) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": expected Result Type to be void"; - } + if ((!_.IsFloatScalarType(p_data_type) || + _.GetBitWidth(p_data_type) != 16) && + !_.ContainsUntypedPointer(p_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P data type to be 16-bit float scalar"; + } + break; + } - const uint32_t data_type = _.GetOperandTypeId(inst, 4); - const uint32_t offset_type = _.GetOperandTypeId(inst, 5); - const uint32_t p_type = _.GetOperandTypeId(inst, 6); + case OpenCLLIB::Vload_halfn: + case OpenCLLIB::Vloada_halfn: { + if (!_.IsFloatVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a float vector type"; + } - if (!_.IsFloatVectorType(data_type) && !_.IsIntVectorType(data_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Data to be an int or float vector"; - } + const uint32_t num_components = _.GetDimension(result_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to have 2, 3, 4, 8 or 16 components"; + } - const uint32_t num_components = _.GetDimension(data_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Data to have 2, 3, 4, 8 or 16 components"; - } + const uint32_t offset_type = _.GetOperandTypeId(inst, 4); + const uint32_t p_type = _.GetOperandTypeId(inst, 5); - const uint32_t size_t_bit_width = GetSizeTBitWidth(_); - if (!size_t_bit_width) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() - << " can only be used with physical addressing models"; - } + const uint32_t size_t_bit_width = GetSizeTBitWidth(_); + if (!size_t_bit_width) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) + << " can only be used with physical addressing models"; + } - if (!_.IsIntScalarType(offset_type) || - _.GetBitWidth(offset_type) != size_t_bit_width) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Offset to be of type size_t (" - << size_t_bit_width - << "-bit integer for the addressing model used in the module)"; - } + if (!_.IsIntScalarType(offset_type) || + _.GetBitWidth(offset_type) != size_t_bit_width) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Offset to be of type size_t (" + << size_t_bit_width + << "-bit integer for the addressing model used in the module)"; + } - spv::StorageClass p_storage_class; - uint32_t p_data_type = 0; - if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P to be a pointer"; - } + spv::StorageClass p_storage_class; + uint32_t p_data_type = 0; + if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P to be a pointer"; + } - if (p_storage_class != spv::StorageClass::Generic && - p_storage_class != spv::StorageClass::CrossWorkgroup && - p_storage_class != spv::StorageClass::Workgroup && - p_storage_class != spv::StorageClass::Function) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P storage class to be Generic, " - "CrossWorkgroup, Workgroup or Function"; - } + if (p_storage_class != spv::StorageClass::UniformConstant && + p_storage_class != spv::StorageClass::Generic && + p_storage_class != spv::StorageClass::CrossWorkgroup && + p_storage_class != spv::StorageClass::Workgroup && + p_storage_class != spv::StorageClass::Function) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P storage class to be UniformConstant, " + "Generic, CrossWorkgroup, Workgroup or Function"; + } - if (_.GetComponentType(data_type) != p_data_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P data type to be equal to the type of " - "operand Data components"; - } - break; + if ((!_.IsFloatScalarType(p_data_type) || + _.GetBitWidth(p_data_type) != 16) && + !_.ContainsUntypedPointer(p_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P data type to be 16-bit float scalar"; } - case OpenCLLIB::Vload_half: { - if (!_.IsFloatScalarType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float scalar type"; - } + const uint32_t n_value = inst->word(7); + if (num_components != n_value) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected literal N to be equal to the number of " + "components of Result Type"; + } + break; + } - const uint32_t offset_type = _.GetOperandTypeId(inst, 4); - const uint32_t p_type = _.GetOperandTypeId(inst, 5); + case OpenCLLIB::Vstore_half: + case OpenCLLIB::Vstore_half_r: + case OpenCLLIB::Vstore_halfn: + case OpenCLLIB::Vstore_halfn_r: + case OpenCLLIB::Vstorea_halfn: + case OpenCLLIB::Vstorea_halfn_r: { + if (_.GetIdOpcode(result_type) != spv::Op::OpTypeVoid) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) + << ": expected Result Type to be void"; + } - const uint32_t size_t_bit_width = GetSizeTBitWidth(_); - if (!size_t_bit_width) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() - << " can only be used with physical addressing models"; - } + const uint32_t data_type = _.GetOperandTypeId(inst, 4); + const uint32_t offset_type = _.GetOperandTypeId(inst, 5); + const uint32_t p_type = _.GetOperandTypeId(inst, 6); + const uint32_t data_type_bit_width = _.GetBitWidth(data_type); - if (!_.IsIntScalarType(offset_type) || - _.GetBitWidth(offset_type) != size_t_bit_width) { + if (ext_inst_key == OpenCLLIB::Vstore_half || + ext_inst_key == OpenCLLIB::Vstore_half_r) { + if (!_.IsFloatScalarType(data_type) || + (data_type_bit_width != 32 && data_type_bit_width != 64)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Offset to be of type size_t (" - << size_t_bit_width - << "-bit integer for the addressing model used in the module)"; + << GetExtInstName(_, inst) << ": " + << "expected Data to be a 32 or 64-bit float scalar"; } - - spv::StorageClass p_storage_class; - uint32_t p_data_type = 0; - if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { + } else { + if (!_.IsFloatVectorType(data_type) || + (data_type_bit_width != 32 && data_type_bit_width != 64)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P to be a pointer"; + << GetExtInstName(_, inst) << ": " + << "expected Data to be a 32 or 64-bit float vector"; } - if (p_storage_class != spv::StorageClass::UniformConstant && - p_storage_class != spv::StorageClass::Generic && - p_storage_class != spv::StorageClass::CrossWorkgroup && - p_storage_class != spv::StorageClass::Workgroup && - p_storage_class != spv::StorageClass::Function) { + const uint32_t num_components = _.GetDimension(data_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P storage class to be UniformConstant, " - "Generic, CrossWorkgroup, Workgroup or Function"; + << GetExtInstName(_, inst) << ": " + << "expected Data to have 2, 3, 4, 8 or 16 components"; } + } - if ((!_.IsFloatScalarType(p_data_type) || - _.GetBitWidth(p_data_type) != 16) && - !_.ContainsUntypedPointer(p_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P data type to be 16-bit float scalar"; - } - break; + const uint32_t size_t_bit_width = GetSizeTBitWidth(_); + if (!size_t_bit_width) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) + << " can only be used with physical addressing models"; } - case OpenCLLIB::Vload_halfn: - case OpenCLLIB::Vloada_halfn: { - if (!_.IsFloatVectorType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a float vector type"; - } + if (!_.IsIntScalarType(offset_type) || + _.GetBitWidth(offset_type) != size_t_bit_width) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Offset to be of type size_t (" + << size_t_bit_width + << "-bit integer for the addressing model used in the module)"; + } - const uint32_t num_components = _.GetDimension(result_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to have 2, 3, 4, 8 or 16 components"; - } + spv::StorageClass p_storage_class; + uint32_t p_data_type = 0; + if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P to be a pointer"; + } - const uint32_t offset_type = _.GetOperandTypeId(inst, 4); - const uint32_t p_type = _.GetOperandTypeId(inst, 5); + if (p_storage_class != spv::StorageClass::Generic && + p_storage_class != spv::StorageClass::CrossWorkgroup && + p_storage_class != spv::StorageClass::Workgroup && + p_storage_class != spv::StorageClass::Function) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P storage class to be Generic, " + "CrossWorkgroup, Workgroup or Function"; + } - const uint32_t size_t_bit_width = GetSizeTBitWidth(_); - if (!size_t_bit_width) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() - << " can only be used with physical addressing models"; - } + if ((!_.IsFloatScalarType(p_data_type) || + _.GetBitWidth(p_data_type) != 16) && + !_.ContainsUntypedPointer(p_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand P data type to be 16-bit float scalar"; + } - if (!_.IsIntScalarType(offset_type) || - _.GetBitWidth(offset_type) != size_t_bit_width) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Offset to be of type size_t (" - << size_t_bit_width - << "-bit integer for the addressing model used in the module)"; - } + // Rounding mode enum is checked by assembler. + break; + } - spv::StorageClass p_storage_class; - uint32_t p_data_type = 0; - if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P to be a pointer"; - } + case OpenCLLIB::Shuffle: + case OpenCLLIB::Shuffle2: { + if (!_.IsFloatVectorType(result_type) && + !_.IsIntVectorType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be an int or float vector type"; + } - if (p_storage_class != spv::StorageClass::UniformConstant && - p_storage_class != spv::StorageClass::Generic && - p_storage_class != spv::StorageClass::CrossWorkgroup && - p_storage_class != spv::StorageClass::Workgroup && - p_storage_class != spv::StorageClass::Function) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P storage class to be UniformConstant, " - "Generic, CrossWorkgroup, Workgroup or Function"; - } + const uint32_t result_num_components = _.GetDimension(result_type); + if (result_num_components != 2 && result_num_components != 4 && + result_num_components != 8 && result_num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to have 2, 4, 8 or 16 components"; + } - if ((!_.IsFloatScalarType(p_data_type) || - _.GetBitWidth(p_data_type) != 16) && - !_.ContainsUntypedPointer(p_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P data type to be 16-bit float scalar"; - } + uint32_t operand_index = 4; + const uint32_t x_type = _.GetOperandTypeId(inst, operand_index++); - const uint32_t n_value = inst->word(7); - if (num_components != n_value) { + if (ext_inst_key == OpenCLLIB::Shuffle2) { + const uint32_t y_type = _.GetOperandTypeId(inst, operand_index++); + if (x_type != y_type) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected literal N to be equal to the number of " - "components of Result Type"; + << GetExtInstName(_, inst) << ": " + << "expected operands X and Y to be of the same type"; } - break; } - case OpenCLLIB::Vstore_half: - case OpenCLLIB::Vstore_half_r: - case OpenCLLIB::Vstore_halfn: - case OpenCLLIB::Vstore_halfn_r: - case OpenCLLIB::Vstorea_halfn: - case OpenCLLIB::Vstorea_halfn_r: { - if (_.GetIdOpcode(result_type) != spv::Op::OpTypeVoid) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": expected Result Type to be void"; - } + const uint32_t shuffle_mask_type = + _.GetOperandTypeId(inst, operand_index++); - const uint32_t data_type = _.GetOperandTypeId(inst, 4); - const uint32_t offset_type = _.GetOperandTypeId(inst, 5); - const uint32_t p_type = _.GetOperandTypeId(inst, 6); - const uint32_t data_type_bit_width = _.GetBitWidth(data_type); + if (!_.IsFloatVectorType(x_type) && !_.IsIntVectorType(x_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X to be an int or float vector"; + } - if (ext_inst_key == OpenCLLIB::Vstore_half || - ext_inst_key == OpenCLLIB::Vstore_half_r) { - if (!_.IsFloatScalarType(data_type) || - (data_type_bit_width != 32 && data_type_bit_width != 64)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Data to be a 32 or 64-bit float scalar"; - } - } else { - if (!_.IsFloatVectorType(data_type) || - (data_type_bit_width != 32 && data_type_bit_width != 64)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Data to be a 32 or 64-bit float vector"; - } + const uint32_t x_num_components = _.GetDimension(x_type); + if (x_num_components != 2 && x_num_components != 4 && + x_num_components != 8 && x_num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X to have 2, 4, 8 or 16 components"; + } - const uint32_t num_components = _.GetDimension(data_type); - if (num_components > 4 && num_components != 8 && - num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Data to have 2, 3, 4, 8 or 16 components"; - } - } + const uint32_t result_component_type = _.GetComponentType(result_type); - const uint32_t size_t_bit_width = GetSizeTBitWidth(_); - if (!size_t_bit_width) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() - << " can only be used with physical addressing models"; - } + if (result_component_type != _.GetComponentType(x_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand X and Result Type to have equal " + "component types"; + } - if (!_.IsIntScalarType(offset_type) || - _.GetBitWidth(offset_type) != size_t_bit_width) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Offset to be of type size_t (" - << size_t_bit_width - << "-bit integer for the addressing model used in the module)"; - } + if (!_.IsIntVectorType(shuffle_mask_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Shuffle Mask to be an int vector"; + } - spv::StorageClass p_storage_class; - uint32_t p_data_type = 0; - if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P to be a pointer"; - } + if (result_num_components != _.GetDimension(shuffle_mask_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Shuffle Mask to have the same number of " + "components as Result Type"; + } - if (p_storage_class != spv::StorageClass::Generic && - p_storage_class != spv::StorageClass::CrossWorkgroup && - p_storage_class != spv::StorageClass::Workgroup && - p_storage_class != spv::StorageClass::Function) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P storage class to be Generic, " - "CrossWorkgroup, Workgroup or Function"; - } + if (_.GetBitWidth(result_component_type) != + _.GetBitWidth(shuffle_mask_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Shuffle Mask components to have the same " + "bit width as Result Type components"; + } + break; + } - if ((!_.IsFloatScalarType(p_data_type) || - _.GetBitWidth(p_data_type) != 16) && - !_.ContainsUntypedPointer(p_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand P data type to be 16-bit float scalar"; - } + case OpenCLLIB::Printf: { + if (!_.IsIntScalarType(result_type) || _.GetBitWidth(result_type) != 32) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a 32-bit int type"; + } - // Rounding mode enum is checked by assembler. - break; + const uint32_t format_type = _.GetOperandTypeId(inst, 4); + spv::StorageClass format_storage_class; + uint32_t format_data_type = 0; + if (!_.GetPointerTypeInfo(format_type, &format_data_type, + &format_storage_class)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Format to be a pointer"; } - case OpenCLLIB::Shuffle: - case OpenCLLIB::Shuffle2: { - if (!_.IsFloatVectorType(result_type) && - !_.IsIntVectorType(result_type)) { + if (_.HasExtension( + Extension::kSPV_EXT_relaxed_printf_string_address_space)) { + if (format_storage_class != spv::StorageClass::UniformConstant && + // Extension SPV_EXT_relaxed_printf_string_address_space allows + // format strings in Global, Local, Private and Generic address + // spaces + + // Global + format_storage_class != spv::StorageClass::CrossWorkgroup && + // Local + format_storage_class != spv::StorageClass::Workgroup && + // Private + format_storage_class != spv::StorageClass::Function && + // Generic + format_storage_class != spv::StorageClass::Generic) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be an int or float vector type"; + << GetExtInstName(_, inst) << ": " + << "expected Format storage class to be UniformConstant, " + "Crossworkgroup, Workgroup, Function, or Generic"; } - - const uint32_t result_num_components = _.GetDimension(result_type); - if (result_num_components != 2 && result_num_components != 4 && - result_num_components != 8 && result_num_components != 16) { + } else { + if (format_storage_class != spv::StorageClass::UniformConstant) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to have 2, 4, 8 or 16 components"; + << GetExtInstName(_, inst) << ": " + << "expected Format storage class to be UniformConstant"; } + } - uint32_t operand_index = 4; - const uint32_t x_type = _.GetOperandTypeId(inst, operand_index++); + // If pointer points to an array, get the type of an element + if (_.IsIntArrayType(format_data_type)) + format_data_type = _.GetComponentType(format_data_type); - if (ext_inst_key == OpenCLLIB::Shuffle2) { - const uint32_t y_type = _.GetOperandTypeId(inst, operand_index++); - if (x_type != y_type) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operands X and Y to be of the same type"; - } - } + if ((!_.IsIntScalarType(format_data_type) || + _.GetBitWidth(format_data_type) != 8) && + !_.ContainsUntypedPointer(format_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Format data type to be 8-bit int"; + } + break; + } - const uint32_t shuffle_mask_type = - _.GetOperandTypeId(inst, operand_index++); + case OpenCLLIB::Prefetch: { + if (_.GetIdOpcode(result_type) != spv::Op::OpTypeVoid) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) + << ": expected Result Type to be void"; + } - if (!_.IsFloatVectorType(x_type) && !_.IsIntVectorType(x_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X to be an int or float vector"; - } + const uint32_t p_type = _.GetOperandTypeId(inst, 4); + const uint32_t num_elements_type = _.GetOperandTypeId(inst, 5); - const uint32_t x_num_components = _.GetDimension(x_type); - if (x_num_components != 2 && x_num_components != 4 && - x_num_components != 8 && x_num_components != 16) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X to have 2, 4, 8 or 16 components"; - } + spv::StorageClass p_storage_class; + uint32_t p_data_type = 0; + if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Ptr to be a pointer"; + } - const uint32_t result_component_type = _.GetComponentType(result_type); + if (p_storage_class != spv::StorageClass::CrossWorkgroup) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Ptr storage class to be CrossWorkgroup"; + } - if (result_component_type != _.GetComponentType(x_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand X and Result Type to have equal " - "component types"; - } + if (!_.IsFloatScalarOrVectorType(p_data_type) && + !_.IsIntScalarOrVectorType(p_data_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Ptr data type to be int or float scalar or " + "vector"; + } - if (!_.IsIntVectorType(shuffle_mask_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Shuffle Mask to be an int vector"; - } + const uint32_t num_components = _.GetDimension(p_data_type); + if (num_components > 4 && num_components != 8 && num_components != 16) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected Result Type to be a scalar or a vector with 2, " + "3, 4, 8 or 16 components"; + } - if (result_num_components != _.GetDimension(shuffle_mask_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Shuffle Mask to have the same number of " - "components as Result Type"; - } + const uint32_t size_t_bit_width = GetSizeTBitWidth(_); + if (!size_t_bit_width) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) + << " can only be used with physical addressing models"; + } - if (_.GetBitWidth(result_component_type) != - _.GetBitWidth(shuffle_mask_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Shuffle Mask components to have the same " - "bit width as Result Type components"; - } - break; + if (!_.IsIntScalarType(num_elements_type) || + _.GetBitWidth(num_elements_type) != size_t_bit_width) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Num Elements to be of type size_t (" + << size_t_bit_width + << "-bit integer for the addressing model used in the module)"; } + break; + } + } + return SPV_SUCCESS; +} - case OpenCLLIB::Printf: { - if (!_.IsIntScalarType(result_type) || - _.GetBitWidth(result_type) != 32) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a 32-bit int type"; - } +spv_result_t ValidateExtInstDebugInfo100(ValidationState_t& _, + const Instruction* inst) { + const uint32_t result_type = inst->type_id(); + const uint32_t ext_inst_index = inst->word(4); + if (!_.IsVoidType(result_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected result type must be a result id of " << "OpTypeVoid"; + } - const uint32_t format_type = _.GetOperandTypeId(inst, 4); - spv::StorageClass format_storage_class; - uint32_t format_data_type = 0; - if (!_.GetPointerTypeInfo(format_type, &format_data_type, - &format_storage_class)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Format to be a pointer"; - } + const spv_ext_inst_type_t ext_inst_type = + spv_ext_inst_type_t(inst->ext_inst_type()); + const bool vulkanDebugInfo = + ext_inst_type == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100; - if (_.HasExtension( - Extension::kSPV_EXT_relaxed_printf_string_address_space)) { - if (format_storage_class != spv::StorageClass::UniformConstant && - // Extension SPV_EXT_relaxed_printf_string_address_space allows - // format strings in Global, Local, Private and Generic address - // spaces - - // Global - format_storage_class != spv::StorageClass::CrossWorkgroup && - // Local - format_storage_class != spv::StorageClass::Workgroup && - // Private - format_storage_class != spv::StorageClass::Function && - // Generic - format_storage_class != spv::StorageClass::Generic) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Format storage class to be UniformConstant, " - "Crossworkgroup, Workgroup, Function, or Generic"; - } - } else { - if (format_storage_class != spv::StorageClass::UniformConstant) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Format storage class to be UniformConstant"; - } - } + auto num_words = inst->words().size(); - // If pointer points to an array, get the type of an element - if (_.IsIntArrayType(format_data_type)) - format_data_type = _.GetComponentType(format_data_type); + // Handle any non-common NonSemanticShaderDebugInfo instructions. + if (vulkanDebugInfo) { + const NonSemanticShaderDebugInfo100Instructions ext_inst_key = + NonSemanticShaderDebugInfo100Instructions(ext_inst_index); + switch (ext_inst_key) { + // The following block of instructions will be handled by the common + // validation. + case NonSemanticShaderDebugInfo100DebugInfoNone: + case NonSemanticShaderDebugInfo100DebugCompilationUnit: + case NonSemanticShaderDebugInfo100DebugTypePointer: + case NonSemanticShaderDebugInfo100DebugTypeQualifier: + case NonSemanticShaderDebugInfo100DebugTypeArray: + case NonSemanticShaderDebugInfo100DebugTypeVector: + case NonSemanticShaderDebugInfo100DebugTypedef: + case NonSemanticShaderDebugInfo100DebugTypeFunction: + case NonSemanticShaderDebugInfo100DebugTypeEnum: + case NonSemanticShaderDebugInfo100DebugTypeComposite: + case NonSemanticShaderDebugInfo100DebugTypeMember: + case NonSemanticShaderDebugInfo100DebugTypeInheritance: + case NonSemanticShaderDebugInfo100DebugTypePtrToMember: + case NonSemanticShaderDebugInfo100DebugTypeTemplate: + case NonSemanticShaderDebugInfo100DebugTypeTemplateParameter: + case NonSemanticShaderDebugInfo100DebugTypeTemplateTemplateParameter: + case NonSemanticShaderDebugInfo100DebugTypeTemplateParameterPack: + case NonSemanticShaderDebugInfo100DebugGlobalVariable: + case NonSemanticShaderDebugInfo100DebugFunctionDeclaration: + case NonSemanticShaderDebugInfo100DebugFunction: + case NonSemanticShaderDebugInfo100DebugLexicalBlock: + case NonSemanticShaderDebugInfo100DebugLexicalBlockDiscriminator: + case NonSemanticShaderDebugInfo100DebugScope: + case NonSemanticShaderDebugInfo100DebugNoScope: + case NonSemanticShaderDebugInfo100DebugInlinedAt: + case NonSemanticShaderDebugInfo100DebugLocalVariable: + case NonSemanticShaderDebugInfo100DebugInlinedVariable: + case NonSemanticShaderDebugInfo100DebugValue: + case NonSemanticShaderDebugInfo100DebugOperation: + case NonSemanticShaderDebugInfo100DebugExpression: + case NonSemanticShaderDebugInfo100DebugMacroDef: + case NonSemanticShaderDebugInfo100DebugMacroUndef: + case NonSemanticShaderDebugInfo100DebugImportedEntity: + case NonSemanticShaderDebugInfo100DebugSource: + break; - if ((!_.IsIntScalarType(format_data_type) || - _.GetBitWidth(format_data_type) != 8) && - !_.ContainsUntypedPointer(format_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Format data type to be 8-bit int"; - } + // These checks are for operands that are differnet in + // ShaderDebugInfo100 + case NonSemanticShaderDebugInfo100DebugTypeBasic: { + CHECK_CONST_UINT_OPERAND("Flags", 8); break; } - - case OpenCLLIB::Prefetch: { - if (_.GetIdOpcode(result_type) != spv::Op::OpTypeVoid) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": expected Result Type to be void"; - } - - const uint32_t p_type = _.GetOperandTypeId(inst, 4); - const uint32_t num_elements_type = _.GetOperandTypeId(inst, 5); - - spv::StorageClass p_storage_class; - uint32_t p_data_type = 0; - if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Ptr to be a pointer"; + case NonSemanticShaderDebugInfo100DebugDeclare: { + for (uint32_t word_index = 8; word_index < num_words; ++word_index) { + auto index_inst = _.FindDef(inst->word(word_index)); + auto type_id = index_inst != nullptr ? index_inst->type_id() : 0; + if (type_id == 0 || !IsIntScalar(_, type_id, false, false)) + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected index must be scalar integer"; } + break; + } + case NonSemanticShaderDebugInfo100DebugTypeMatrix: { + CHECK_DEBUG_OPERAND("Vector Type", CommonDebugInfoDebugTypeVector, 5); - if (p_storage_class != spv::StorageClass::CrossWorkgroup) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Ptr storage class to be CrossWorkgroup"; - } + CHECK_CONST_UINT_OPERAND("Vector Count", 6); - if (!_.IsFloatScalarOrVectorType(p_data_type) && - !_.IsIntScalarOrVectorType(p_data_type)) { + uint32_t vector_count = inst->word(6); + uint64_t const_val; + if (!_.EvalConstantValUint64(vector_count, &const_val)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Ptr data type to be int or float scalar or " - "vector"; + << GetExtInstName(_, inst) + << ": Vector Count must be 32-bit integer OpConstant"; } - const uint32_t num_components = _.GetDimension(p_data_type); - if (num_components > 4 && num_components != 8 && num_components != 16) { + vector_count = const_val & 0xffffffff; + if (!vector_count || vector_count > 4) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected Result Type to be a scalar or a vector with 2, " - "3, 4, 8 or 16 components"; + << GetExtInstName(_, inst) + << ": Vector Count must be positive " + << "integer less than or equal to 4"; } - - const uint32_t size_t_bit_width = GetSizeTBitWidth(_); - if (!size_t_bit_width) { + break; + } + case NonSemanticShaderDebugInfo100DebugFunctionDefinition: { + CHECK_DEBUG_OPERAND("Function", CommonDebugInfoDebugFunction, 5); + CHECK_OPERAND("Definition", spv::Op::OpFunction, 6); + const auto* current_function = inst->function(); + if (current_function->first_block()->id() != inst->block()->id()) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() - << " can only be used with physical addressing models"; + << GetExtInstName(_, inst) + << ": must be in the entry basic block of the function"; } - if (!_.IsIntScalarType(num_elements_type) || - _.GetBitWidth(num_elements_type) != size_t_bit_width) { + const uint32_t definition_id = inst->word(6); + if (definition_id != current_function->id()) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Num Elements to be of type size_t (" - << size_t_bit_width - << "-bit integer for the addressing model used in the module)"; + << GetExtInstName(_, inst) + << ": operand Definition must point to the OpFunction it is " + "inside"; } break; } - } - } else if (ext_inst_type == SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100 || - ext_inst_type == - SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) { - if (!_.IsVoidType(result_type)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected result type must be a result id of " - << "OpTypeVoid"; - } - - const bool vulkanDebugInfo = - ext_inst_type == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100; - - auto num_words = inst->words().size(); - - // Handle any non-common NonSemanticShaderDebugInfo instructions. - if (vulkanDebugInfo) { - const NonSemanticShaderDebugInfo100Instructions ext_inst_key = - NonSemanticShaderDebugInfo100Instructions(ext_inst_index); - switch (ext_inst_key) { - // The following block of instructions will be handled by the common - // validation. - case NonSemanticShaderDebugInfo100DebugInfoNone: - case NonSemanticShaderDebugInfo100DebugCompilationUnit: - case NonSemanticShaderDebugInfo100DebugTypePointer: - case NonSemanticShaderDebugInfo100DebugTypeQualifier: - case NonSemanticShaderDebugInfo100DebugTypeArray: - case NonSemanticShaderDebugInfo100DebugTypeVector: - case NonSemanticShaderDebugInfo100DebugTypedef: - case NonSemanticShaderDebugInfo100DebugTypeFunction: - case NonSemanticShaderDebugInfo100DebugTypeEnum: - case NonSemanticShaderDebugInfo100DebugTypeComposite: - case NonSemanticShaderDebugInfo100DebugTypeMember: - case NonSemanticShaderDebugInfo100DebugTypeInheritance: - case NonSemanticShaderDebugInfo100DebugTypePtrToMember: - case NonSemanticShaderDebugInfo100DebugTypeTemplate: - case NonSemanticShaderDebugInfo100DebugTypeTemplateParameter: - case NonSemanticShaderDebugInfo100DebugTypeTemplateTemplateParameter: - case NonSemanticShaderDebugInfo100DebugTypeTemplateParameterPack: - case NonSemanticShaderDebugInfo100DebugGlobalVariable: - case NonSemanticShaderDebugInfo100DebugFunctionDeclaration: - case NonSemanticShaderDebugInfo100DebugFunction: - case NonSemanticShaderDebugInfo100DebugLexicalBlock: - case NonSemanticShaderDebugInfo100DebugLexicalBlockDiscriminator: - case NonSemanticShaderDebugInfo100DebugScope: - case NonSemanticShaderDebugInfo100DebugNoScope: - case NonSemanticShaderDebugInfo100DebugInlinedAt: - case NonSemanticShaderDebugInfo100DebugLocalVariable: - case NonSemanticShaderDebugInfo100DebugInlinedVariable: - case NonSemanticShaderDebugInfo100DebugValue: - case NonSemanticShaderDebugInfo100DebugOperation: - case NonSemanticShaderDebugInfo100DebugExpression: - case NonSemanticShaderDebugInfo100DebugMacroDef: - case NonSemanticShaderDebugInfo100DebugMacroUndef: - case NonSemanticShaderDebugInfo100DebugImportedEntity: - case NonSemanticShaderDebugInfo100DebugSource: - break; - - // These checks are for operands that are differnet in - // ShaderDebugInfo100 - case NonSemanticShaderDebugInfo100DebugTypeBasic: { - CHECK_CONST_UINT_OPERAND("Flags", 8); - break; - } - case NonSemanticShaderDebugInfo100DebugDeclare: { - for (uint32_t word_index = 8; word_index < num_words; ++word_index) { - auto index_inst = _.FindDef(inst->word(word_index)); - auto type_id = index_inst != nullptr ? index_inst->type_id() : 0; - if (type_id == 0 || !IsIntScalar(_, type_id, false, false)) - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected index must be scalar integer"; - } - break; + case NonSemanticShaderDebugInfo100DebugLine: { + CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 5); + CHECK_CONST_UINT_OPERAND("Line Start", 6); + CHECK_CONST_UINT_OPERAND("Line End", 7); + CHECK_CONST_UINT_OPERAND("Column Start", 8); + CHECK_CONST_UINT_OPERAND("Column End", 9); + + // above already validates if 32-bit and non-spec constant + // but want to use EvalInt32IfConst to be consistent with other Eval + // locations + bool is_int32 = false, is_const_int32 = false; + uint32_t line_start = 0; + uint32_t line_end = 0; + uint32_t column_start = 0; + uint32_t column_end = 0; + std::tie(is_int32, is_const_int32, line_start) = + _.EvalInt32IfConst(inst->word(6)); + std::tie(is_int32, is_const_int32, line_end) = + _.EvalInt32IfConst(inst->word(7)); + std::tie(is_int32, is_const_int32, column_start) = + _.EvalInt32IfConst(inst->word(8)); + std::tie(is_int32, is_const_int32, column_end) = + _.EvalInt32IfConst(inst->word(9)); + if (line_end < line_start) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": operand Line End (" + << line_end << ") is less than Line Start (" << line_start + << ")"; + } else if (line_start == line_end && column_end < column_start) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": operand Column End (" + << column_end << ") is less than Column Start (" + << column_start << ") when Line Start equals Line End"; } - case NonSemanticShaderDebugInfo100DebugTypeMatrix: { - CHECK_DEBUG_OPERAND("Vector Type", CommonDebugInfoDebugTypeVector, 5); - - CHECK_CONST_UINT_OPERAND("Vector Count", 6); + break; + } + case NonSemanticShaderDebugInfo100DebugSourceContinued: { + CHECK_OPERAND("Text", spv::Op::OpString, 5); + break; + } + case NonSemanticShaderDebugInfo100DebugBuildIdentifier: { + CHECK_OPERAND("Identifier", spv::Op::OpString, 5); + CHECK_CONST_UINT_OPERAND("Flags", 6); + break; + } + case NonSemanticShaderDebugInfo100DebugStoragePath: { + CHECK_OPERAND("Path", spv::Op::OpString, 5); + break; + } + case NonSemanticShaderDebugInfo100DebugEntryPoint: { + CHECK_DEBUG_OPERAND("Entry Point", CommonDebugInfoDebugFunction, 5); + CHECK_DEBUG_OPERAND("Compilation Unit", + CommonDebugInfoDebugCompilationUnit, 6); + CHECK_OPERAND("Compiler Signature", spv::Op::OpString, 7); + CHECK_OPERAND("Command-line Arguments", spv::Op::OpString, 8); + break; + } - uint32_t vector_count = inst->word(6); - uint64_t const_val; - if (!_.EvalConstantValUint64(vector_count, &const_val)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() - << ": Vector Count must be 32-bit integer OpConstant"; - } + // Has no additional checks + case NonSemanticShaderDebugInfo100DebugNoLine: + break; + case NonSemanticShaderDebugInfo100InstructionsMax: + assert(0); + break; + } + } - vector_count = const_val & 0xffffffff; - if (!vector_count || vector_count > 4) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": Vector Count must be positive " - << "integer less than or equal to 4"; - } - break; + // Handle any non-common OpenCL insts, then common + if (ext_inst_type != SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100 || + OpenCLDebugInfo100Instructions(ext_inst_index) != + OpenCLDebugInfo100DebugModuleINTEL) { + const CommonDebugInfoInstructions ext_inst_key = + CommonDebugInfoInstructions(ext_inst_index); + switch (ext_inst_key) { + case CommonDebugInfoDebugInfoNone: + case CommonDebugInfoDebugNoScope: + break; + // The binary parser validates the opcode for DebugInfoNone, + // DebugNoScope, DebugOperation. We just check the parameters to + // DebugOperation are properly constants for vulkan debug info. + case CommonDebugInfoDebugOperation: { + CHECK_CONST_UINT_OPERAND("Operation", 5); + for (uint32_t i = 6; i < num_words; ++i) { + CHECK_CONST_UINT_OPERAND("Operand", i); } - case NonSemanticShaderDebugInfo100DebugFunctionDefinition: { - CHECK_DEBUG_OPERAND("Function", CommonDebugInfoDebugFunction, 5); - CHECK_OPERAND("Definition", spv::Op::OpFunction, 6); - const auto* current_function = inst->function(); - if (current_function->first_block()->id() != inst->block()->id()) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() - << ": must be in the entry basic block of the function"; - } + break; + } + case CommonDebugInfoDebugCompilationUnit: { + CHECK_CONST_UINT_OPERAND("Version", 5); + CHECK_CONST_UINT_OPERAND("DWARF Version", 6); + CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); + CHECK_CONST_UINT_OPERAND("Language", 8); + break; + } + case CommonDebugInfoDebugSource: { + CHECK_OPERAND("File", spv::Op::OpString, 5); + if (num_words == 7) CHECK_OPERAND("Text", spv::Op::OpString, 6); + break; + } + case CommonDebugInfoDebugTypeBasic: { + CHECK_OPERAND("Name", spv::Op::OpString, 5); + CHECK_OPERAND("Size", spv::Op::OpConstant, 6); + CHECK_CONST_UINT_OPERAND("Encoding", 7); + break; + } + case CommonDebugInfoDebugTypePointer: { + auto validate_base_type = + ValidateOperandDebugType(_, "Base Type", inst, 5, false); + if (validate_base_type != SPV_SUCCESS) return validate_base_type; + CHECK_CONST_UINT_OPERAND("Storage Class", 6); + CHECK_CONST_UINT_OPERAND("Flags", 7); + break; + } + case CommonDebugInfoDebugTypeQualifier: { + auto validate_base_type = + ValidateOperandDebugType(_, "Base Type", inst, 5, false); + if (validate_base_type != SPV_SUCCESS) return validate_base_type; + CHECK_CONST_UINT_OPERAND("Type Qualifier", 6); + break; + } + case CommonDebugInfoDebugTypeVector: { + auto validate_base_type = ValidateOperandBaseType(_, inst, 5); + if (validate_base_type != SPV_SUCCESS) return validate_base_type; - const uint32_t definition_id = inst->word(6); - if (definition_id != current_function->id()) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() - << ": operand Definition must point to the OpFunction it is " - "inside"; - } - break; - } - case NonSemanticShaderDebugInfo100DebugLine: { - CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 5); - CHECK_CONST_UINT_OPERAND("Line Start", 6); - CHECK_CONST_UINT_OPERAND("Line End", 7); - CHECK_CONST_UINT_OPERAND("Column Start", 8); - CHECK_CONST_UINT_OPERAND("Column End", 9); - - // above already validates if 32-bit and non-spec constant - // but want to use EvalInt32IfConst to be consistent with other Eval - // locations - bool is_int32 = false, is_const_int32 = false; - uint32_t line_start = 0; - uint32_t line_end = 0; - uint32_t column_start = 0; - uint32_t column_end = 0; - std::tie(is_int32, is_const_int32, line_start) = - _.EvalInt32IfConst(inst->word(6)); - std::tie(is_int32, is_const_int32, line_end) = - _.EvalInt32IfConst(inst->word(7)); - std::tie(is_int32, is_const_int32, column_start) = - _.EvalInt32IfConst(inst->word(8)); - std::tie(is_int32, is_const_int32, column_end) = - _.EvalInt32IfConst(inst->word(9)); - if (line_end < line_start) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": operand Line End (" << line_end - << ") is less than Line Start (" << line_start << ")"; - } else if (line_start == line_end && column_end < column_start) { + CHECK_CONST_UINT_OPERAND("Component Count", 6); + uint32_t component_count = inst->word(6); + if (vulkanDebugInfo) { + uint64_t const_val; + if (!_.EvalConstantValUint64(component_count, &const_val)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": operand Column End (" << column_end - << ") is less than Column Start (" << column_start - << ") when Line Start equals Line End"; + << GetExtInstName(_, inst) + << ": Component Count must be 32-bit integer OpConstant"; } - break; - } - case NonSemanticShaderDebugInfo100DebugSourceContinued: { - CHECK_OPERAND("Text", spv::Op::OpString, 5); - break; - } - case NonSemanticShaderDebugInfo100DebugBuildIdentifier: { - CHECK_OPERAND("Identifier", spv::Op::OpString, 5); - CHECK_CONST_UINT_OPERAND("Flags", 6); - break; - } - case NonSemanticShaderDebugInfo100DebugStoragePath: { - CHECK_OPERAND("Path", spv::Op::OpString, 5); - break; - } - case NonSemanticShaderDebugInfo100DebugEntryPoint: { - CHECK_DEBUG_OPERAND("Entry Point", CommonDebugInfoDebugFunction, 5); - CHECK_DEBUG_OPERAND("Compilation Unit", - CommonDebugInfoDebugCompilationUnit, 6); - CHECK_OPERAND("Compiler Signature", spv::Op::OpString, 7); - CHECK_OPERAND("Command-line Arguments", spv::Op::OpString, 8); - break; + component_count = const_val & 0xffffffff; } - // Has no additional checks - case NonSemanticShaderDebugInfo100DebugNoLine: - break; - case NonSemanticShaderDebugInfo100InstructionsMax: - assert(0); - break; - } - } - - // Handle any non-common OpenCL insts, then common - if (ext_inst_type != SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100 || - OpenCLDebugInfo100Instructions(ext_inst_index) != - OpenCLDebugInfo100DebugModuleINTEL) { - const CommonDebugInfoInstructions ext_inst_key = - CommonDebugInfoInstructions(ext_inst_index); - switch (ext_inst_key) { - case CommonDebugInfoDebugInfoNone: - case CommonDebugInfoDebugNoScope: - break; - // The binary parser validates the opcode for DebugInfoNone, - // DebugNoScope, DebugOperation. We just check the parameters to - // DebugOperation are properly constants for vulkan debug info. - case CommonDebugInfoDebugOperation: { - CHECK_CONST_UINT_OPERAND("Operation", 5); - for (uint32_t i = 6; i < num_words; ++i) { - CHECK_CONST_UINT_OPERAND("Operand", i); - } - break; - } - case CommonDebugInfoDebugCompilationUnit: { - CHECK_CONST_UINT_OPERAND("Version", 5); - CHECK_CONST_UINT_OPERAND("DWARF Version", 6); - CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); - CHECK_CONST_UINT_OPERAND("Language", 8); - break; - } - case CommonDebugInfoDebugSource: { - CHECK_OPERAND("File", spv::Op::OpString, 5); - if (num_words == 7) CHECK_OPERAND("Text", spv::Op::OpString, 6); - break; - } - case CommonDebugInfoDebugTypeBasic: { - CHECK_OPERAND("Name", spv::Op::OpString, 5); - CHECK_OPERAND("Size", spv::Op::OpConstant, 6); - CHECK_CONST_UINT_OPERAND("Encoding", 7); - break; - } - case CommonDebugInfoDebugTypePointer: { - auto validate_base_type = ValidateOperandDebugType( - _, "Base Type", inst, 5, ext_inst_name, false); - if (validate_base_type != SPV_SUCCESS) return validate_base_type; - CHECK_CONST_UINT_OPERAND("Storage Class", 6); - CHECK_CONST_UINT_OPERAND("Flags", 7); - break; - } - case CommonDebugInfoDebugTypeQualifier: { - auto validate_base_type = ValidateOperandDebugType( - _, "Base Type", inst, 5, ext_inst_name, false); - if (validate_base_type != SPV_SUCCESS) return validate_base_type; - CHECK_CONST_UINT_OPERAND("Type Qualifier", 6); - break; + if (!component_count || component_count > 4) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) + << ": Component Count must be positive " + << "integer less than or equal to 4"; } - case CommonDebugInfoDebugTypeVector: { - auto validate_base_type = - ValidateOperandBaseType(_, inst, 5, ext_inst_name); - if (validate_base_type != SPV_SUCCESS) return validate_base_type; - - CHECK_CONST_UINT_OPERAND("Component Count", 6); - uint32_t component_count = inst->word(6); - if (vulkanDebugInfo) { - uint64_t const_val; - if (!_.EvalConstantValUint64(component_count, &const_val)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() - << ": Component Count must be 32-bit integer OpConstant"; + break; + } + case CommonDebugInfoDebugTypeArray: { + auto validate_base_type = + ValidateOperandDebugType(_, "Base Type", inst, 5, false); + if (validate_base_type != SPV_SUCCESS) return validate_base_type; + for (uint32_t i = 6; i < num_words; ++i) { + bool invalid = false; + auto* component_count = _.FindDef(inst->word(i)); + if (IsConstIntScalarTypeWith32Or64Bits(_, component_count)) { + // TODO: We need a spec discussion for the runtime array for + // OpenCL. + if (!vulkanDebugInfo && !component_count->word(3)) { + invalid = true; } - component_count = const_val & 0xffffffff; - } - - if (!component_count || component_count > 4) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": Component Count must be positive " - << "integer less than or equal to 4"; - } - break; - } - case CommonDebugInfoDebugTypeArray: { - auto validate_base_type = ValidateOperandDebugType( - _, "Base Type", inst, 5, ext_inst_name, false); - if (validate_base_type != SPV_SUCCESS) return validate_base_type; - for (uint32_t i = 6; i < num_words; ++i) { - bool invalid = false; - auto* component_count = _.FindDef(inst->word(i)); - if (IsConstIntScalarTypeWith32Or64Bits(_, component_count)) { - // TODO: We need a spec discussion for the runtime array for - // OpenCL. - if (!vulkanDebugInfo && !component_count->word(3)) { + } else if (component_count->words().size() > 6 && + (CommonDebugInfoInstructions(component_count->word(4)) == + CommonDebugInfoDebugLocalVariable || + CommonDebugInfoInstructions(component_count->word(4)) == + CommonDebugInfoDebugGlobalVariable)) { + auto* component_count_type = _.FindDef(component_count->word(6)); + if (component_count_type->words().size() > 7) { + uint32_t encoding = component_count_type->word(7); + if (CommonDebugInfoInstructions(component_count_type->word(4)) != + CommonDebugInfoDebugTypeBasic || + (vulkanDebugInfo && !IsUint32Constant(_, encoding)) || + OpenCLDebugInfo100DebugBaseTypeAttributeEncoding( + vulkanDebugInfo + ? GetUint32Constant(_, encoding) + : encoding) != OpenCLDebugInfo100Unsigned) { invalid = true; - } - } else if (component_count->words().size() > 6 && - (CommonDebugInfoInstructions(component_count->word(4)) == - CommonDebugInfoDebugLocalVariable || - CommonDebugInfoInstructions(component_count->word(4)) == - CommonDebugInfoDebugGlobalVariable)) { - auto* component_count_type = _.FindDef(component_count->word(6)); - if (component_count_type->words().size() > 7) { - uint32_t encoding = component_count_type->word(7); - if (CommonDebugInfoInstructions(component_count_type->word( - 4)) != CommonDebugInfoDebugTypeBasic || - (vulkanDebugInfo && !IsUint32Constant(_, encoding)) || - OpenCLDebugInfo100DebugBaseTypeAttributeEncoding( - vulkanDebugInfo - ? GetUint32Constant(_, encoding) - : encoding) != OpenCLDebugInfo100Unsigned) { + } else { + // DebugTypeBasic for DebugLocalVariable/DebugGlobalVariable + // must have Unsigned encoding and 32 or 64 as its size in + // bits. + Instruction* size_in_bits = + _.FindDef(component_count_type->word(6)); + if (!_.IsIntScalarType(size_in_bits->type_id()) || + (size_in_bits->word(3) != 32 && + size_in_bits->word(3) != 64)) { invalid = true; - } else { - // DebugTypeBasic for DebugLocalVariable/DebugGlobalVariable - // must have Unsigned encoding and 32 or 64 as its size in - // bits. - Instruction* size_in_bits = - _.FindDef(component_count_type->word(6)); - if (!_.IsIntScalarType(size_in_bits->type_id()) || - (size_in_bits->word(3) != 32 && - size_in_bits->word(3) != 64)) { - invalid = true; - } } - } else { - invalid = true; } } else { invalid = true; } - if (invalid) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": Component Count must be " - << "OpConstant with a 32- or 64-bits integer scalar type " - "or " - << "DebugGlobalVariable or DebugLocalVariable with a 32- " - "or " - << "64-bits unsigned integer scalar type"; - } + } else { + invalid = true; + } + if (invalid) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": Component Count must be " + << "OpConstant with a 32- or 64-bits integer scalar type " + "or " + << "DebugGlobalVariable or DebugLocalVariable with a 32- " + "or " + << "64-bits unsigned integer scalar type"; } - break; } - case CommonDebugInfoDebugTypedef: { - CHECK_OPERAND("Name", spv::Op::OpString, 5); - auto validate_base_type = - ValidateOperandBaseType(_, inst, 6, ext_inst_name); - if (validate_base_type != SPV_SUCCESS) return validate_base_type; - CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); - CHECK_CONST_UINT_OPERAND("Line", 8); - CHECK_CONST_UINT_OPERAND("Column", 9); - auto validate_parent = - ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name); - if (validate_parent != SPV_SUCCESS) return validate_parent; - break; + break; + } + case CommonDebugInfoDebugTypedef: { + CHECK_OPERAND("Name", spv::Op::OpString, 5); + auto validate_base_type = ValidateOperandBaseType(_, inst, 6); + if (validate_base_type != SPV_SUCCESS) return validate_base_type; + CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); + CHECK_CONST_UINT_OPERAND("Line", 8); + CHECK_CONST_UINT_OPERAND("Column", 9); + auto validate_parent = + ValidateOperandLexicalScope(_, "Parent", inst, 10); + if (validate_parent != SPV_SUCCESS) return validate_parent; + break; + } + case CommonDebugInfoDebugTypeFunction: { + CHECK_CONST_UINT_OPERAND("Flags", 5); + auto* return_type = _.FindDef(inst->word(6)); + // TODO: We need a spec discussion that we have to allow return and + // parameter types of a DebugTypeFunction to have template parameter. + if (return_type->opcode() != spv::Op::OpTypeVoid) { + auto validate_return = + ValidateOperandDebugType(_, "Return Type", inst, 6, true); + if (validate_return != SPV_SUCCESS) return validate_return; + } + for (uint32_t word_index = 7; word_index < num_words; ++word_index) { + auto validate_param = ValidateOperandDebugType( + _, "Parameter Types", inst, word_index, true); + if (validate_param != SPV_SUCCESS) return validate_param; } - case CommonDebugInfoDebugTypeFunction: { - CHECK_CONST_UINT_OPERAND("Flags", 5); - auto* return_type = _.FindDef(inst->word(6)); - // TODO: We need a spec discussion that we have to allow return and - // parameter types of a DebugTypeFunction to have template parameter. - if (return_type->opcode() != spv::Op::OpTypeVoid) { - auto validate_return = ValidateOperandDebugType( - _, "Return Type", inst, 6, ext_inst_name, true); - if (validate_return != SPV_SUCCESS) return validate_return; - } - for (uint32_t word_index = 7; word_index < num_words; ++word_index) { - auto validate_param = ValidateOperandDebugType( - _, "Parameter Types", inst, word_index, ext_inst_name, true); - if (validate_param != SPV_SUCCESS) return validate_param; - } - break; + break; + } + case CommonDebugInfoDebugTypeEnum: { + CHECK_OPERAND("Name", spv::Op::OpString, 5); + if (!DoesDebugInfoOperandMatchExpectation( + _, + [](CommonDebugInfoInstructions dbg_inst) { + return dbg_inst == CommonDebugInfoDebugInfoNone; + }, + inst, 6)) { + auto validate_underlying_type = + ValidateOperandDebugType(_, "Underlying Types", inst, 6, false); + if (validate_underlying_type != SPV_SUCCESS) + return validate_underlying_type; + } + CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); + CHECK_CONST_UINT_OPERAND("Line", 8); + CHECK_CONST_UINT_OPERAND("Column", 9); + auto validate_parent = + ValidateOperandLexicalScope(_, "Parent", inst, 10); + if (validate_parent != SPV_SUCCESS) return validate_parent; + CHECK_OPERAND("Size", spv::Op::OpConstant, 11); + auto* size = _.FindDef(inst->word(11)); + if (!_.IsIntScalarType(size->type_id()) || !size->word(3)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": expected operand Size is a " + << "positive integer"; + } + CHECK_CONST_UINT_OPERAND("Flags", 12); + for (uint32_t word_index = 13; word_index + 1 < num_words; + word_index += 2) { + CHECK_OPERAND("Value", spv::Op::OpConstant, word_index); + CHECK_OPERAND("Name", spv::Op::OpString, word_index + 1); } - case CommonDebugInfoDebugTypeEnum: { - CHECK_OPERAND("Name", spv::Op::OpString, 5); + break; + } + case CommonDebugInfoDebugTypeComposite: { + CHECK_OPERAND("Name", spv::Op::OpString, 5); + CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); + CHECK_CONST_UINT_OPERAND("Line", 8); + CHECK_CONST_UINT_OPERAND("Column", 9); + auto validate_parent = + ValidateOperandLexicalScope(_, "Parent", inst, 10); + if (validate_parent != SPV_SUCCESS) return validate_parent; + CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11); + if (!DoesDebugInfoOperandMatchExpectation( + _, + [](CommonDebugInfoInstructions dbg_inst) { + return dbg_inst == CommonDebugInfoDebugInfoNone; + }, + inst, 12)) { + CHECK_OPERAND("Size", spv::Op::OpConstant, 12); + } + CHECK_CONST_UINT_OPERAND("Flags", 13); + for (uint32_t word_index = 14; word_index < num_words; ++word_index) { if (!DoesDebugInfoOperandMatchExpectation( _, [](CommonDebugInfoInstructions dbg_inst) { - return dbg_inst == CommonDebugInfoDebugInfoNone; + return dbg_inst == CommonDebugInfoDebugTypeMember || + dbg_inst == CommonDebugInfoDebugFunction || + dbg_inst == CommonDebugInfoDebugTypeInheritance; }, - inst, 6)) { - auto validate_underlying_type = ValidateOperandDebugType( - _, "Underlying Types", inst, 6, ext_inst_name, false); - if (validate_underlying_type != SPV_SUCCESS) - return validate_underlying_type; - } - CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); - CHECK_CONST_UINT_OPERAND("Line", 8); - CHECK_CONST_UINT_OPERAND("Column", 9); - auto validate_parent = - ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name); - if (validate_parent != SPV_SUCCESS) return validate_parent; - CHECK_OPERAND("Size", spv::Op::OpConstant, 11); - auto* size = _.FindDef(inst->word(11)); - if (!_.IsIntScalarType(size->type_id()) || !size->word(3)) { + inst, word_index)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": expected operand Size is a " - << "positive integer"; + << GetExtInstName(_, inst) << ": " + << "expected operand Members " + << "must be DebugTypeMember, DebugFunction, or " + "DebugTypeInheritance"; } + } + break; + } + case CommonDebugInfoDebugTypeMember: { + CHECK_OPERAND("Name", spv::Op::OpString, 5); + // TODO: We need a spec discussion that we have to allow member types + // to have template parameter. + auto validate_type = ValidateOperandDebugType(_, "Type", inst, 6, true); + if (validate_type != SPV_SUCCESS) return validate_type; + CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); + CHECK_CONST_UINT_OPERAND("Line", 8); + CHECK_CONST_UINT_OPERAND("Column", 9); + // NonSemantic.Shader.DebugInfo doesn't have the Parent operand + if (vulkanDebugInfo) { + CHECK_OPERAND("Offset", spv::Op::OpConstant, 10); + CHECK_OPERAND("Size", spv::Op::OpConstant, 11); CHECK_CONST_UINT_OPERAND("Flags", 12); - for (uint32_t word_index = 13; word_index + 1 < num_words; - word_index += 2) { - CHECK_OPERAND("Value", spv::Op::OpConstant, word_index); - CHECK_OPERAND("Name", spv::Op::OpString, word_index + 1); - } - break; + if (num_words == 14) CHECK_OPERAND("Value", spv::Op::OpConstant, 13); + } else { + CHECK_DEBUG_OPERAND("Parent", CommonDebugInfoDebugTypeComposite, 10); + CHECK_OPERAND("Offset", spv::Op::OpConstant, 11); + CHECK_OPERAND("Size", spv::Op::OpConstant, 12); + CHECK_CONST_UINT_OPERAND("Flags", 13); + if (num_words == 15) CHECK_OPERAND("Value", spv::Op::OpConstant, 14); + } + break; + } + case CommonDebugInfoDebugTypeInheritance: { + CHECK_DEBUG_OPERAND("Child", CommonDebugInfoDebugTypeComposite, 5); + auto* debug_inst = _.FindDef(inst->word(5)); + auto composite_type = + OpenCLDebugInfo100DebugCompositeType(debug_inst->word(6)); + if (composite_type != OpenCLDebugInfo100Class && + composite_type != OpenCLDebugInfo100Structure) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Child must be class or struct debug " + "type"; + } + CHECK_DEBUG_OPERAND("Parent", CommonDebugInfoDebugTypeComposite, 6); + debug_inst = _.FindDef(inst->word(6)); + composite_type = + OpenCLDebugInfo100DebugCompositeType(debug_inst->word(6)); + if (composite_type != OpenCLDebugInfo100Class && + composite_type != OpenCLDebugInfo100Structure) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Parent must be class or struct debug " + "type"; } - case CommonDebugInfoDebugTypeComposite: { - CHECK_OPERAND("Name", spv::Op::OpString, 5); - CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); - CHECK_CONST_UINT_OPERAND("Line", 8); - CHECK_CONST_UINT_OPERAND("Column", 9); - auto validate_parent = - ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name); - if (validate_parent != SPV_SUCCESS) return validate_parent; - CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11); + CHECK_OPERAND("Offset", spv::Op::OpConstant, 7); + CHECK_OPERAND("Size", spv::Op::OpConstant, 8); + CHECK_CONST_UINT_OPERAND("Flags", 9); + break; + } + case CommonDebugInfoDebugFunction: { + CHECK_OPERAND("Name", spv::Op::OpString, 5); + CHECK_DEBUG_OPERAND("Type", CommonDebugInfoDebugTypeFunction, 6); + CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); + CHECK_CONST_UINT_OPERAND("Line", 8); + CHECK_CONST_UINT_OPERAND("Column", 9); + auto validate_parent = + ValidateOperandLexicalScope(_, "Parent", inst, 10); + if (validate_parent != SPV_SUCCESS) return validate_parent; + CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11); + CHECK_CONST_UINT_OPERAND("Flags", 12); + CHECK_CONST_UINT_OPERAND("Scope Line", 13); + // NonSemantic.Shader.DebugInfo.100 doesn't include a reference to the + // OpFunction + if (vulkanDebugInfo) { + if (num_words == 15) { + CHECK_DEBUG_OPERAND("Declaration", + CommonDebugInfoDebugFunctionDeclaration, 14); + } + } else { if (!DoesDebugInfoOperandMatchExpectation( _, [](CommonDebugInfoInstructions dbg_inst) { return dbg_inst == CommonDebugInfoDebugInfoNone; }, - inst, 12)) { - CHECK_OPERAND("Size", spv::Op::OpConstant, 12); - } - CHECK_CONST_UINT_OPERAND("Flags", 13); - for (uint32_t word_index = 14; word_index < num_words; ++word_index) { - if (!DoesDebugInfoOperandMatchExpectation( - _, - [](CommonDebugInfoInstructions dbg_inst) { - return dbg_inst == CommonDebugInfoDebugTypeMember || - dbg_inst == CommonDebugInfoDebugFunction || - dbg_inst == CommonDebugInfoDebugTypeInheritance; - }, - inst, word_index)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Members " - << "must be DebugTypeMember, DebugFunction, or " - "DebugTypeInheritance"; - } - } - break; - } - case CommonDebugInfoDebugTypeMember: { - CHECK_OPERAND("Name", spv::Op::OpString, 5); - // TODO: We need a spec discussion that we have to allow member types - // to have template parameter. - auto validate_type = - ValidateOperandDebugType(_, "Type", inst, 6, ext_inst_name, true); - if (validate_type != SPV_SUCCESS) return validate_type; - CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); - CHECK_CONST_UINT_OPERAND("Line", 8); - CHECK_CONST_UINT_OPERAND("Column", 9); - // NonSemantic.Shader.DebugInfo doesn't have the Parent operand - if (vulkanDebugInfo) { - CHECK_OPERAND("Offset", spv::Op::OpConstant, 10); - CHECK_OPERAND("Size", spv::Op::OpConstant, 11); - CHECK_CONST_UINT_OPERAND("Flags", 12); - if (num_words == 14) - CHECK_OPERAND("Value", spv::Op::OpConstant, 13); - } else { - CHECK_DEBUG_OPERAND("Parent", CommonDebugInfoDebugTypeComposite, - 10); - CHECK_OPERAND("Offset", spv::Op::OpConstant, 11); - CHECK_OPERAND("Size", spv::Op::OpConstant, 12); - CHECK_CONST_UINT_OPERAND("Flags", 13); - if (num_words == 15) - CHECK_OPERAND("Value", spv::Op::OpConstant, 14); - } - break; - } - case CommonDebugInfoDebugTypeInheritance: { - CHECK_DEBUG_OPERAND("Child", CommonDebugInfoDebugTypeComposite, 5); - auto* debug_inst = _.FindDef(inst->word(5)); - auto composite_type = - OpenCLDebugInfo100DebugCompositeType(debug_inst->word(6)); - if (composite_type != OpenCLDebugInfo100Class && - composite_type != OpenCLDebugInfo100Structure) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Child must be class or struct debug " - "type"; - } - CHECK_DEBUG_OPERAND("Parent", CommonDebugInfoDebugTypeComposite, 6); - debug_inst = _.FindDef(inst->word(6)); - composite_type = - OpenCLDebugInfo100DebugCompositeType(debug_inst->word(6)); - if (composite_type != OpenCLDebugInfo100Class && - composite_type != OpenCLDebugInfo100Structure) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Parent must be class or struct debug " - "type"; + inst, 14)) { + CHECK_OPERAND("Function", spv::Op::OpFunction, 14); } - CHECK_OPERAND("Offset", spv::Op::OpConstant, 7); - CHECK_OPERAND("Size", spv::Op::OpConstant, 8); - CHECK_CONST_UINT_OPERAND("Flags", 9); - break; - } - case CommonDebugInfoDebugFunction: { - CHECK_OPERAND("Name", spv::Op::OpString, 5); - CHECK_DEBUG_OPERAND("Type", CommonDebugInfoDebugTypeFunction, 6); - CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); - CHECK_CONST_UINT_OPERAND("Line", 8); - CHECK_CONST_UINT_OPERAND("Column", 9); - auto validate_parent = - ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name); - if (validate_parent != SPV_SUCCESS) return validate_parent; - CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11); - CHECK_CONST_UINT_OPERAND("Flags", 12); - CHECK_CONST_UINT_OPERAND("Scope Line", 13); - // NonSemantic.Shader.DebugInfo.100 doesn't include a reference to the - // OpFunction - if (vulkanDebugInfo) { - if (num_words == 15) { - CHECK_DEBUG_OPERAND("Declaration", - CommonDebugInfoDebugFunctionDeclaration, 14); - } - } else { - if (!DoesDebugInfoOperandMatchExpectation( - _, - [](CommonDebugInfoInstructions dbg_inst) { - return dbg_inst == CommonDebugInfoDebugInfoNone; - }, - inst, 14)) { - CHECK_OPERAND("Function", spv::Op::OpFunction, 14); - } - if (num_words == 16) { - CHECK_DEBUG_OPERAND("Declaration", - CommonDebugInfoDebugFunctionDeclaration, 15); - } + if (num_words == 16) { + CHECK_DEBUG_OPERAND("Declaration", + CommonDebugInfoDebugFunctionDeclaration, 15); } - break; - } - case CommonDebugInfoDebugFunctionDeclaration: { - CHECK_OPERAND("Name", spv::Op::OpString, 5); - CHECK_DEBUG_OPERAND("Type", CommonDebugInfoDebugTypeFunction, 6); - CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); - CHECK_CONST_UINT_OPERAND("Line", 8); - CHECK_CONST_UINT_OPERAND("Column", 9); - auto validate_parent = - ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name); - if (validate_parent != SPV_SUCCESS) return validate_parent; - CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11); - CHECK_CONST_UINT_OPERAND("Flags", 12); - break; } - case CommonDebugInfoDebugLexicalBlock: { - CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 5); - CHECK_CONST_UINT_OPERAND("Line", 6); - CHECK_CONST_UINT_OPERAND("Column", 7); - auto validate_parent = - ValidateOperandLexicalScope(_, "Parent", inst, 8, ext_inst_name); - if (validate_parent != SPV_SUCCESS) return validate_parent; - if (num_words == 10) CHECK_OPERAND("Name", spv::Op::OpString, 9); - break; + break; + } + case CommonDebugInfoDebugFunctionDeclaration: { + CHECK_OPERAND("Name", spv::Op::OpString, 5); + CHECK_DEBUG_OPERAND("Type", CommonDebugInfoDebugTypeFunction, 6); + CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); + CHECK_CONST_UINT_OPERAND("Line", 8); + CHECK_CONST_UINT_OPERAND("Column", 9); + auto validate_parent = + ValidateOperandLexicalScope(_, "Parent", inst, 10); + if (validate_parent != SPV_SUCCESS) return validate_parent; + CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11); + CHECK_CONST_UINT_OPERAND("Flags", 12); + break; + } + case CommonDebugInfoDebugLexicalBlock: { + CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 5); + CHECK_CONST_UINT_OPERAND("Line", 6); + CHECK_CONST_UINT_OPERAND("Column", 7); + auto validate_parent = + ValidateOperandLexicalScope(_, "Parent", inst, 8); + if (validate_parent != SPV_SUCCESS) return validate_parent; + if (num_words == 10) CHECK_OPERAND("Name", spv::Op::OpString, 9); + break; + } + case CommonDebugInfoDebugScope: { + auto validate_scope = ValidateOperandLexicalScope(_, "Scope", inst, 5); + if (validate_scope != SPV_SUCCESS) return validate_scope; + if (num_words == 7) { + CHECK_DEBUG_OPERAND("Inlined At", CommonDebugInfoDebugInlinedAt, 6); } - case CommonDebugInfoDebugScope: { - auto validate_scope = - ValidateOperandLexicalScope(_, "Scope", inst, 5, ext_inst_name); - if (validate_scope != SPV_SUCCESS) return validate_scope; - if (num_words == 7) { - CHECK_DEBUG_OPERAND("Inlined At", CommonDebugInfoDebugInlinedAt, 6); - } - break; + break; + } + case CommonDebugInfoDebugLocalVariable: { + CHECK_OPERAND("Name", spv::Op::OpString, 5); + // TODO: We need a spec discussion that we have to allow local + // variable types to have template parameter. + auto validate_type = ValidateOperandDebugType(_, "Type", inst, 6, true); + if (validate_type != SPV_SUCCESS) return validate_type; + CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); + CHECK_CONST_UINT_OPERAND("Line", 8); + CHECK_CONST_UINT_OPERAND("Column", 9); + auto validate_parent = + ValidateOperandLexicalScope(_, "Parent", inst, 10); + if (validate_parent != SPV_SUCCESS) return validate_parent; + CHECK_CONST_UINT_OPERAND("Flags", 11); + if (num_words == 13) { + CHECK_CONST_UINT_OPERAND("ArgNumber", 12); } - case CommonDebugInfoDebugLocalVariable: { - CHECK_OPERAND("Name", spv::Op::OpString, 5); - // TODO: We need a spec discussion that we have to allow local - // variable types to have template parameter. - auto validate_type = - ValidateOperandDebugType(_, "Type", inst, 6, ext_inst_name, true); - if (validate_type != SPV_SUCCESS) return validate_type; - CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); - CHECK_CONST_UINT_OPERAND("Line", 8); - CHECK_CONST_UINT_OPERAND("Column", 9); - auto validate_parent = - ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name); - if (validate_parent != SPV_SUCCESS) return validate_parent; - CHECK_CONST_UINT_OPERAND("Flags", 11); - if (num_words == 13) { - CHECK_CONST_UINT_OPERAND("ArgNumber", 12); - } - break; + break; + } + case CommonDebugInfoDebugDeclare: { + CHECK_DEBUG_OPERAND("Local Variable", CommonDebugInfoDebugLocalVariable, + 5); + auto* operand = _.FindDef(inst->word(6)); + if (operand->opcode() != spv::Op::OpVariable && + operand->opcode() != spv::Op::OpFunctionParameter) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Variable must be a result id of " + "OpVariable or OpFunctionParameter"; } - case CommonDebugInfoDebugDeclare: { - CHECK_DEBUG_OPERAND("Local Variable", - CommonDebugInfoDebugLocalVariable, 5); - auto* operand = _.FindDef(inst->word(6)); - if (operand->opcode() != spv::Op::OpVariable && - operand->opcode() != spv::Op::OpFunctionParameter) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Variable must be a result id of " - "OpVariable or OpFunctionParameter"; - } - CHECK_DEBUG_OPERAND("Expression", CommonDebugInfoDebugExpression, 7); - break; - } - case CommonDebugInfoDebugExpression: { - for (uint32_t word_index = 5; word_index < num_words; ++word_index) { - CHECK_DEBUG_OPERAND("Operation", CommonDebugInfoDebugOperation, - word_index); - } - break; + CHECK_DEBUG_OPERAND("Expression", CommonDebugInfoDebugExpression, 7); + break; + } + case CommonDebugInfoDebugExpression: { + for (uint32_t word_index = 5; word_index < num_words; ++word_index) { + CHECK_DEBUG_OPERAND("Operation", CommonDebugInfoDebugOperation, + word_index); } - case CommonDebugInfoDebugTypeTemplate: { + break; + } + case CommonDebugInfoDebugTypeTemplate: { + if (!DoesDebugInfoOperandMatchExpectation( + _, + [](CommonDebugInfoInstructions dbg_inst) { + return dbg_inst == CommonDebugInfoDebugTypeComposite || + dbg_inst == CommonDebugInfoDebugFunction; + }, + inst, 5)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Target must be DebugTypeComposite " + << "or DebugFunction"; + } + for (uint32_t word_index = 6; word_index < num_words; ++word_index) { if (!DoesDebugInfoOperandMatchExpectation( _, [](CommonDebugInfoInstructions dbg_inst) { - return dbg_inst == CommonDebugInfoDebugTypeComposite || - dbg_inst == CommonDebugInfoDebugFunction; + return dbg_inst == + CommonDebugInfoDebugTypeTemplateParameter || + dbg_inst == + CommonDebugInfoDebugTypeTemplateTemplateParameter; }, - inst, 5)) { + inst, word_index)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Target must be DebugTypeComposite " - << "or DebugFunction"; - } - for (uint32_t word_index = 6; word_index < num_words; ++word_index) { - if (!DoesDebugInfoOperandMatchExpectation( - _, - [](CommonDebugInfoInstructions dbg_inst) { - return dbg_inst == - CommonDebugInfoDebugTypeTemplateParameter || - dbg_inst == - CommonDebugInfoDebugTypeTemplateTemplateParameter; - }, - inst, word_index)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Parameters must be " - << "DebugTypeTemplateParameter or " - << "DebugTypeTemplateTemplateParameter"; - } + << GetExtInstName(_, inst) << ": " + << "expected operand Parameters must be " + << "DebugTypeTemplateParameter or " + << "DebugTypeTemplateTemplateParameter"; } - break; } - case CommonDebugInfoDebugTypeTemplateParameter: { - CHECK_OPERAND("Name", spv::Op::OpString, 5); - auto validate_actual_type = ValidateOperandDebugType( - _, "Actual Type", inst, 6, ext_inst_name, false); - if (validate_actual_type != SPV_SUCCESS) return validate_actual_type; - if (!DoesDebugInfoOperandMatchExpectation( - _, - [](CommonDebugInfoInstructions dbg_inst) { - return dbg_inst == CommonDebugInfoDebugInfoNone; - }, - inst, 7)) { - CHECK_OPERAND("Value", spv::Op::OpConstant, 7); + break; + } + case CommonDebugInfoDebugTypeTemplateParameter: { + CHECK_OPERAND("Name", spv::Op::OpString, 5); + auto validate_actual_type = + ValidateOperandDebugType(_, "Actual Type", inst, 6, false); + if (validate_actual_type != SPV_SUCCESS) return validate_actual_type; + if (!DoesDebugInfoOperandMatchExpectation( + _, + [](CommonDebugInfoInstructions dbg_inst) { + return dbg_inst == CommonDebugInfoDebugInfoNone; + }, + inst, 7)) { + CHECK_OPERAND("Value", spv::Op::OpConstant, 7); + } + CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 8); + CHECK_CONST_UINT_OPERAND("Line", 9); + CHECK_CONST_UINT_OPERAND("Column", 10); + break; + } + case CommonDebugInfoDebugGlobalVariable: { + CHECK_OPERAND("Name", spv::Op::OpString, 5); + auto validate_type = + ValidateOperandDebugType(_, "Type", inst, 6, false); + if (validate_type != SPV_SUCCESS) return validate_type; + CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); + CHECK_CONST_UINT_OPERAND("Line", 8); + CHECK_CONST_UINT_OPERAND("Column", 9); + auto validate_scope = ValidateOperandLexicalScope(_, "Scope", inst, 10); + if (validate_scope != SPV_SUCCESS) return validate_scope; + CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11); + if (!DoesDebugInfoOperandMatchExpectation( + _, + [](CommonDebugInfoInstructions dbg_inst) { + return dbg_inst == CommonDebugInfoDebugInfoNone; + }, + inst, 12)) { + auto* operand = _.FindDef(inst->word(12)); + if (operand->opcode() != spv::Op::OpVariable && + operand->opcode() != spv::Op::OpConstant) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) << ": " + << "expected operand Variable must be a result id of " + "OpVariable or OpConstant or DebugInfoNone"; } - CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 8); - CHECK_CONST_UINT_OPERAND("Line", 9); - CHECK_CONST_UINT_OPERAND("Column", 10); - break; } - case CommonDebugInfoDebugGlobalVariable: { - CHECK_OPERAND("Name", spv::Op::OpString, 5); - auto validate_type = ValidateOperandDebugType(_, "Type", inst, 6, - ext_inst_name, false); - if (validate_type != SPV_SUCCESS) return validate_type; - CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7); - CHECK_CONST_UINT_OPERAND("Line", 8); - CHECK_CONST_UINT_OPERAND("Column", 9); - auto validate_scope = - ValidateOperandLexicalScope(_, "Scope", inst, 10, ext_inst_name); - if (validate_scope != SPV_SUCCESS) return validate_scope; - CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11); - if (!DoesDebugInfoOperandMatchExpectation( - _, - [](CommonDebugInfoInstructions dbg_inst) { - return dbg_inst == CommonDebugInfoDebugInfoNone; - }, - inst, 12)) { - auto* operand = _.FindDef(inst->word(12)); - if (operand->opcode() != spv::Op::OpVariable && - operand->opcode() != spv::Op::OpConstant) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": " - << "expected operand Variable must be a result id of " - "OpVariable or OpConstant or DebugInfoNone"; - } - } - if (num_words == 15) { - CHECK_DEBUG_OPERAND("Static Member Declaration", - CommonDebugInfoDebugTypeMember, 14); - } - break; + if (num_words == 15) { + CHECK_DEBUG_OPERAND("Static Member Declaration", + CommonDebugInfoDebugTypeMember, 14); } - case CommonDebugInfoDebugInlinedAt: { - CHECK_CONST_UINT_OPERAND("Line", 5); - auto validate_scope = - ValidateOperandLexicalScope(_, "Scope", inst, 6, ext_inst_name); - if (validate_scope != SPV_SUCCESS) return validate_scope; - if (num_words == 8) { - CHECK_DEBUG_OPERAND("Inlined", CommonDebugInfoDebugInlinedAt, 7); - } - break; + break; + } + case CommonDebugInfoDebugInlinedAt: { + CHECK_CONST_UINT_OPERAND("Line", 5); + auto validate_scope = ValidateOperandLexicalScope(_, "Scope", inst, 6); + if (validate_scope != SPV_SUCCESS) return validate_scope; + if (num_words == 8) { + CHECK_DEBUG_OPERAND("Inlined", CommonDebugInfoDebugInlinedAt, 7); } - case CommonDebugInfoDebugValue: { - CHECK_DEBUG_OPERAND("Local Variable", - CommonDebugInfoDebugLocalVariable, 5); - CHECK_DEBUG_OPERAND("Expression", CommonDebugInfoDebugExpression, 7); - - for (uint32_t word_index = 8; word_index < num_words; ++word_index) { - // TODO: The following code simply checks if it is a const int - // scalar or a DebugLocalVariable or DebugGlobalVariable, but we - // have to check it using the same validation for Indexes of - // OpAccessChain. - if (!IsConstWithIntScalarType(_, inst, word_index) && - !IsDebugVariableWithIntScalarType(_, inst, word_index)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << ext_inst_name() << ": expected operand Indexes is " - << "OpConstant, DebugGlobalVariable, or " - << "type is OpConstant with an integer scalar type"; - } + break; + } + case CommonDebugInfoDebugValue: { + CHECK_DEBUG_OPERAND("Local Variable", CommonDebugInfoDebugLocalVariable, + 5); + CHECK_DEBUG_OPERAND("Expression", CommonDebugInfoDebugExpression, 7); + + for (uint32_t word_index = 8; word_index < num_words; ++word_index) { + // TODO: The following code simply checks if it is a const int + // scalar or a DebugLocalVariable or DebugGlobalVariable, but we + // have to check it using the same validation for Indexes of + // OpAccessChain. + if (!IsConstWithIntScalarType(_, inst, word_index) && + !IsDebugVariableWithIntScalarType(_, inst, word_index)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << GetExtInstName(_, inst) + << ": expected operand Indexes is " + << "OpConstant, DebugGlobalVariable, or " + << "type is OpConstant with an integer scalar type"; } - break; } - - // TODO: Add validation rules for remaining cases as well. - case CommonDebugInfoDebugTypePtrToMember: - case CommonDebugInfoDebugTypeTemplateTemplateParameter: - case CommonDebugInfoDebugTypeTemplateParameterPack: - case CommonDebugInfoDebugLexicalBlockDiscriminator: - case CommonDebugInfoDebugInlinedVariable: - case CommonDebugInfoDebugMacroDef: - case CommonDebugInfoDebugMacroUndef: - case CommonDebugInfoDebugImportedEntity: - break; - case CommonDebugInfoInstructionsMax: - assert(0); - break; + break; } + + // TODO: Add validation rules for remaining cases as well. + case CommonDebugInfoDebugTypePtrToMember: + case CommonDebugInfoDebugTypeTemplateTemplateParameter: + case CommonDebugInfoDebugTypeTemplateParameterPack: + case CommonDebugInfoDebugLexicalBlockDiscriminator: + case CommonDebugInfoDebugInlinedVariable: + case CommonDebugInfoDebugMacroDef: + case CommonDebugInfoDebugMacroUndef: + case CommonDebugInfoDebugImportedEntity: + break; + case CommonDebugInfoInstructionsMax: + assert(0); + break; } + } + + return SPV_SUCCESS; +} + +spv_result_t ValidateExtInstNonsemanticClspvReflection( + ValidationState_t& _, const Instruction* inst) { + auto import_inst = _.FindDef(inst->GetOperandAs(2)); + const std::string name = import_inst->GetOperandAs(1); + const std::string reflection = "NonSemantic.ClspvReflection."; + char* end_ptr; + auto version_string = name.substr(reflection.size()); + if (version_string.empty()) { + return _.diag(SPV_ERROR_INVALID_DATA, import_inst) + << "Missing NonSemantic.ClspvReflection import version"; + } + uint32_t version = + static_cast(std::strtoul(version_string.c_str(), &end_ptr, 10)); + if (end_ptr && *end_ptr != '\0') { + return _.diag(SPV_ERROR_INVALID_DATA, import_inst) + << "NonSemantic.ClspvReflection import does not encode the " + "version correctly"; + } + if (version == 0 || version > NonSemanticClspvReflectionRevision) { + return _.diag(SPV_ERROR_INVALID_DATA, import_inst) + << "Unknown NonSemantic.ClspvReflection import version"; + } + + return ValidateClspvReflectionInstruction(_, inst, version); +} + +spv_result_t ValidateExtInst(ValidationState_t& _, const Instruction* inst) { + const spv_ext_inst_type_t ext_inst_type = + spv_ext_inst_type_t(inst->ext_inst_type()); + + if (ext_inst_type == SPV_EXT_INST_TYPE_GLSL_STD_450) { + return ValidateExtInstGlslStd450(_, inst); + } else if (ext_inst_type == SPV_EXT_INST_TYPE_OPENCL_STD) { + return ValidateExtInstOpenClStd(_, inst); + } else if (ext_inst_type == SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100 || + ext_inst_type == + SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) { + return ValidateExtInstDebugInfo100(_, inst); } else if (ext_inst_type == SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION) { - auto import_inst = _.FindDef(inst->GetOperandAs(2)); - const std::string name = import_inst->GetOperandAs(1); - const std::string reflection = "NonSemantic.ClspvReflection."; - char* end_ptr; - auto version_string = name.substr(reflection.size()); - if (version_string.empty()) { - return _.diag(SPV_ERROR_INVALID_DATA, import_inst) - << "Missing NonSemantic.ClspvReflection import version"; - } - uint32_t version = static_cast( - std::strtoul(version_string.c_str(), &end_ptr, 10)); - if (end_ptr && *end_ptr != '\0') { - return _.diag(SPV_ERROR_INVALID_DATA, import_inst) - << "NonSemantic.ClspvReflection import does not encode the " - "version correctly"; - } - if (version == 0 || version > NonSemanticClspvReflectionRevision) { - return _.diag(SPV_ERROR_INVALID_DATA, import_inst) - << "Unknown NonSemantic.ClspvReflection import version"; - } - - return ValidateClspvReflectionInstruction(_, inst, version); + return ValidateExtInstNonsemanticClspvReflection(_, inst); } return SPV_SUCCESS; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_function.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_function.cpp index b08c5b4..265cbbd 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_function.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_function.cpp @@ -89,7 +89,10 @@ spv_result_t ValidateFunction(ValidationState_t& _, const Instruction* inst) { spv::Op::OpName, spv::Op::OpCooperativeMatrixPerElementOpNV, spv::Op::OpCooperativeMatrixReduceNV, - spv::Op::OpCooperativeMatrixLoadTensorNV}; + spv::Op::OpCooperativeMatrixLoadTensorNV, + spv::Op::OpConditionalEntryPointINTEL, + }; + for (auto& pair : inst->uses()) { const auto* use = pair.first; if (std::find(acceptable.begin(), acceptable.end(), use->opcode()) == @@ -109,11 +112,6 @@ spv_result_t ValidateFunctionParameter(ValidationState_t& _, // NOTE: Find OpFunction & ensure OpFunctionParameter is not out of place. size_t param_index = 0; size_t inst_num = inst->LineNum() - 1; - if (inst_num == 0) { - return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) - << "Function parameter cannot be the first instruction."; - } - auto func_inst = &_.ordered_instructions()[inst_num]; while (--inst_num) { func_inst = &_.ordered_instructions()[inst_num]; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_graph.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_graph.cpp new file mode 100644 index 0000000..09d53ea --- /dev/null +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_graph.cpp @@ -0,0 +1,547 @@ +// Copyright (c) 2023-2025 Arm Ltd. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Validates correctness of graph instructions. + +#include + +#include "source/opcode.h" +#include "source/val/validate.h" +#include "source/val/validation_state.h" + +namespace spvtools { +namespace val { +namespace { + +bool IsTensorArray(ValidationState_t& _, uint32_t id) { + auto def = _.FindDef(id); + if (!def || (def->opcode() != spv::Op::OpTypeArray && + def->opcode() != spv::Op::OpTypeRuntimeArray)) { + return false; + } + auto tdef = _.FindDef(def->word(2)); + if (!tdef || tdef->opcode() != spv::Op::OpTypeTensorARM) { + return false; + } + return true; +} + +bool IsGraphInterfaceType(ValidationState_t& _, uint32_t id) { + return _.IsTensorType(id) || IsTensorArray(_, id); +} + +bool IsGraph(ValidationState_t& _, uint32_t id) { + auto def = _.FindDef(id); + if (!def || def->opcode() != spv::Op::OpGraphARM) { + return false; + } + return true; +} + +bool IsGraphType(ValidationState_t& _, uint32_t id) { + auto def = _.FindDef(id); + if (!def || def->opcode() != spv::Op::OpTypeGraphARM) { + return false; + } + return true; +} + +const uint32_t kGraphTypeIOStartWord = 3; + +uint32_t GraphTypeInstNumIO(const Instruction* inst) { + return static_cast(inst->words().size()) - kGraphTypeIOStartWord; +} + +uint32_t GraphTypeInstNumInputs(const Instruction* inst) { + return inst->word(2); +} + +uint32_t GraphTypeInstNumOutputs(const Instruction* inst) { + return GraphTypeInstNumIO(inst) - GraphTypeInstNumInputs(inst); +} + +uint32_t GraphTypeInstGetOutputAtIndex(const Instruction* inst, + uint64_t index) { + return inst->word(kGraphTypeIOStartWord + GraphTypeInstNumInputs(inst) + + static_cast(index)); +} + +uint32_t GraphTypeInstGetInputAtIndex(const Instruction* inst, uint64_t index) { + return inst->word(kGraphTypeIOStartWord + static_cast(index)); +} + +spv_result_t ValidateGraphType(ValidationState_t& _, const Instruction* inst) { + // Check there are at least NumInputs types + uint32_t NumInputs = GraphTypeInstNumInputs(inst); + size_t NumIOTypes = GraphTypeInstNumIO(inst); + if (NumIOTypes < NumInputs) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << NumIOTypes << " I/O types were provided but the graph has " + << NumInputs << " inputs."; + } + + // Check there is at least one output + if (NumIOTypes == NumInputs) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "A graph type must have at least one output."; + } + + // Check all I/O types are graph interface type + for (unsigned i = kGraphTypeIOStartWord; i < inst->words().size(); i++) { + auto tid = inst->word(i); + if (!IsGraphInterfaceType(_, tid)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "I/O type " << _.getIdName(tid) + << " is not a Graph Interface Type."; + } + } + + return SPV_SUCCESS; +} + +spv_result_t ValidateGraphConstant(ValidationState_t& _, + const Instruction* inst) { + // Check Result Type + if (!_.IsTensorType(inst->type_id())) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(inst->opcode()) + << " must have a Result Type that is a tensor type."; + } + + // Check the instruction is not preceded by another OpGraphConstantARM with + // the same ID + const uint32_t cst_id = inst->word(3); + size_t inst_num = inst->LineNum() - 1; + while (--inst_num) { + auto prev_inst = &_.ordered_instructions()[inst_num]; + if (prev_inst->opcode() == spv::Op::OpGraphConstantARM) { + const uint32_t prev_cst_id = prev_inst->word(3); + if (prev_cst_id == cst_id) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "No two OpGraphConstantARM instructions may have the same " + "GraphConstantID"; + } + } + } + return SPV_SUCCESS; +} + +spv_result_t ValidateGraphEntryPoint(ValidationState_t& _, + const Instruction* inst) { + // Graph must be an OpGraphARM + uint32_t graph = inst->GetOperandAs(0); + auto graph_inst = _.FindDef(graph); + if (!IsGraph(_, graph)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(inst->opcode()) + << " Graph must be a OpGraphARM but found " + << spvOpcodeString(graph_inst->opcode()) << "."; + } + + // Check number of Interface IDs matches number of I/Os of graph + auto graph_type_inst = _.FindDef(graph_inst->type_id()); + size_t graph_type_num_io = GraphTypeInstNumIO(graph_type_inst); + size_t graph_entry_point_num_interface_id = inst->operands().size() - 2; + if (graph_type_inst->opcode() != spv::Op::OpTypeGraphARM) { + // This is invalid but we want ValidateGraph to report a clear error + // so stop validating the graph entry point instruction + return SPV_SUCCESS; + } + if (graph_type_num_io != graph_entry_point_num_interface_id) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(inst->opcode()) << " Interface list contains " + << graph_entry_point_num_interface_id << " IDs but Graph's type " + << _.getIdName(graph_inst->type_id()) << " has " << graph_type_num_io + << " inputs and outputs."; + } + + // Check Interface IDs + for (uint32_t i = 2; i < inst->operands().size(); i++) { + uint32_t interface_id = inst->GetOperandAs(i); + auto interface_inst = _.FindDef(interface_id); + + // Check interface IDs come from OpVariable + if ((interface_inst->opcode() != spv::Op::OpVariable) || + (interface_inst->GetOperandAs(2) != + spv::StorageClass::UniformConstant)) { + return _.diag(SPV_ERROR_INVALID_DATA, interface_inst) + << spvOpcodeString(inst->opcode()) << " Interface ID " + << _.getIdName(interface_id) + << " must come from OpVariable with UniformConstant Storage " + "Class."; + } + + // Check type of interface variable matches type of the corresponding graph + // I/O + uint32_t corresponding_graph_io_type = + graph_type_inst->GetOperandAs(i); + + uint32_t interface_ptr_type = interface_inst->type_id(); + auto interface_ptr_inst = _.FindDef(interface_ptr_type); + auto interface_pointee_type = interface_ptr_inst->GetOperandAs(2); + if (interface_pointee_type != corresponding_graph_io_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(inst->opcode()) << " Interface ID type " + << _.getIdName(interface_pointee_type) + << " must match the type of the corresponding graph I/O " + << _.getIdName(corresponding_graph_io_type); + } + } + + return SPV_SUCCESS; +} + +spv_result_t ValidateGraph(ValidationState_t& _, const Instruction* inst) { + // Result Type must be an OpTypeGraphARM + if (!IsGraphType(_, inst->type_id())) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(inst->opcode()) + << " Result Type must be an OpTypeGraphARM."; + } + + return SPV_SUCCESS; +} + +spv_result_t ValidateGraphInput(ValidationState_t& _, const Instruction* inst) { + // Check type of InputIndex + auto input_index_inst = _.FindDef(inst->GetOperandAs(2)); + if (!input_index_inst || + !_.IsIntScalarType(input_index_inst->type_id(), 32)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(inst->opcode()) + << " InputIndex must be a 32-bit integer."; + } + + bool has_element_index = inst->operands().size() > 3; + + // Check type of ElementIndex + if (has_element_index) { + auto element_index_inst = _.FindDef(inst->GetOperandAs(3)); + if (!element_index_inst || + !_.IsIntScalarType(element_index_inst->type_id(), 32)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(inst->opcode()) + << " ElementIndex must be a 32-bit integer."; + } + } + + // Find graph definition + size_t inst_num = inst->LineNum() - 1; + auto graph_inst = &_.ordered_instructions()[inst_num]; + while (--inst_num) { + graph_inst = &_.ordered_instructions()[inst_num]; + if (graph_inst->opcode() == spv::Op::OpGraphARM) { + break; + } + } + + // Can the InputIndex be evaluated? + // If not, there's nothing more we can validate here. + uint64_t input_index; + if (!_.EvalConstantValUint64(inst->GetOperandAs(2), &input_index)) { + return SPV_SUCCESS; + } + + auto const graph_type_inst = _.FindDef(graph_inst->type_id()); + size_t graph_type_num_inputs = graph_type_inst->GetOperandAs(1); + + // Check InputIndex is in range + if (input_index >= graph_type_num_inputs) { + std::string disassembly = _.Disassemble(*inst); + return _.diag(SPV_ERROR_INVALID_DATA, nullptr) + << "Type " << _.getIdName(graph_type_inst->id()) << " for graph " + << _.getIdName(graph_inst->id()) << " has " << graph_type_num_inputs + << " inputs but found an OpGraphInputARM instruction with an " + "InputIndex that is " + << input_index << ": " << disassembly; + } + + uint32_t graph_type_input_type = + GraphTypeInstGetInputAtIndex(graph_type_inst, input_index); + + if (has_element_index) { + // Check ElementIndex is allowed + if (!IsTensorArray(_, graph_type_input_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "OpGraphInputARM ElementIndex not allowed when the graph input " + "selected by " + << "InputIndex is not an OpTypeArray or OpTypeRuntimeArray"; + } + + // Check ElementIndex is in range if it can be evaluated and the input is a + // fixed-sized array whose Length can be evaluated + uint64_t element_index; + if (_.IsArrayType(graph_type_input_type) && + _.EvalConstantValUint64(inst->GetOperandAs(3), + &element_index)) { + uint64_t array_length; + auto graph_type_input_type_inst = _.FindDef(graph_type_input_type); + if (_.EvalConstantValUint64( + graph_type_input_type_inst->GetOperandAs(2), + &array_length)) { + if (element_index >= array_length) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "OpGraphInputARM ElementIndex out of range. The type of " + "the graph input being accessed " + << _.getIdName(graph_type_input_type) << " is an array of " + << array_length << " elements but " << "ElementIndex is " + << element_index; + } + } + } + } + + // Check result type matches with graph type + if (has_element_index) { + uint32_t expected_type = _.GetComponentType(graph_type_input_type); + if (inst->type_id() != expected_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Result Type " << _.getIdName(inst->type_id()) + << " of graph input instruction " << _.getIdName(inst->id()) + << " does not match the component type " + << _.getIdName(expected_type) << " of input " << input_index + << " in the graph type."; + } + } else { + if (inst->type_id() != graph_type_input_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Result Type " << _.getIdName(inst->type_id()) + << " of graph input instruction " << _.getIdName(inst->id()) + << " does not match the type " + << _.getIdName(graph_type_input_type) << " of input " + << input_index << " in the graph type."; + } + } + return SPV_SUCCESS; +} + +spv_result_t ValidateGraphSetOutput(ValidationState_t& _, + const Instruction* inst) { + // Check type of OutputIndex + auto output_index_inst = _.FindDef(inst->GetOperandAs(1)); + if (!output_index_inst || + !_.IsIntScalarType(output_index_inst->type_id(), 32)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(inst->opcode()) + << " OutputIndex must be a 32-bit integer."; + } + + bool has_element_index = inst->operands().size() > 2; + + // Check type of ElementIndex + if (has_element_index) { + auto element_index_inst = _.FindDef(inst->GetOperandAs(2)); + if (!element_index_inst || + !_.IsIntScalarType(element_index_inst->type_id(), 32)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(inst->opcode()) + << " ElementIndex must be a 32-bit integer."; + } + } + + // Find graph definition + size_t inst_num = inst->LineNum() - 1; + auto graph_inst = &_.ordered_instructions()[inst_num]; + while (--inst_num) { + graph_inst = &_.ordered_instructions()[inst_num]; + if (graph_inst->opcode() == spv::Op::OpGraphARM) { + break; + } + } + + // Can the OutputIndex be evaluated? + // If not, there's nothing more we can validate here. + uint64_t output_index; + if (!_.EvalConstantValUint64(inst->GetOperandAs(1), + &output_index)) { + return SPV_SUCCESS; + } + + // Check that the OutputIndex is valid with respect to the graph type + auto graph_type_inst = _.FindDef(graph_inst->type_id()); + size_t graph_type_num_outputs = GraphTypeInstNumOutputs(graph_type_inst); + + if (output_index >= graph_type_num_outputs) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(inst->opcode()) << " setting OutputIndex " + << output_index << " but graph only has " << graph_type_num_outputs + << " outputs."; + } + + uint32_t graph_type_output_type = + GraphTypeInstGetOutputAtIndex(graph_type_inst, output_index); + + if (has_element_index) { + // Check ElementIndex is allowed + if (!IsTensorArray(_, graph_type_output_type)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "OpGraphSetOutputARM ElementIndex not allowed when the graph " + "output selected by " + << "OutputIndex is not an OpTypeArray or OpTypeRuntimeArray"; + } + + // Check ElementIndex is in range if it can be evaluated and the output is a + // fixed-sized array whose Length can be evaluated + uint64_t element_index; + if (_.IsArrayType(graph_type_output_type) && + _.EvalConstantValUint64(inst->GetOperandAs(2), + &element_index)) { + uint64_t array_length; + auto graph_type_output_type_inst = _.FindDef(graph_type_output_type); + if (_.EvalConstantValUint64( + graph_type_output_type_inst->GetOperandAs(2), + &array_length)) { + if (element_index >= array_length) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "OpGraphSetOutputARM ElementIndex out of range. The type " + "of the graph output being accessed " + << _.getIdName(graph_type_output_type) << " is an array of " + << array_length << " elements but " << "ElementIndex is " + << element_index; + } + } + } + } + + // Check Value's type matches with graph type + uint32_t value = inst->GetOperandAs(0); + uint32_t value_type = _.FindDef(value)->type_id(); + if (has_element_index) { + uint32_t expected_type = _.GetComponentType(graph_type_output_type); + if (value_type != expected_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "The type " << _.getIdName(value_type) + << " of Value provided to the graph output instruction " + << _.getIdName(value) << " does not match the component type " + << _.getIdName(expected_type) << " of output " << output_index + << " in the graph type."; + } + } else { + if (value_type != graph_type_output_type) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "The type " << _.getIdName(value_type) + << " of Value provided to the graph output instruction " + << _.getIdName(value) << " does not match the type " + << _.getIdName(graph_type_output_type) << " of output " + << output_index << " in the graph type."; + } + } + return SPV_SUCCESS; +} + +bool InputOutputInstructionsHaveDuplicateIndices( + ValidationState_t& _, std::deque& inout_insts, + const Instruction** first_dup) { + std::set> inout_element_indices; + for (auto const inst : inout_insts) { + const bool is_input = inst->opcode() == spv::Op::OpGraphInputARM; + bool has_element_index = inst->operands().size() > (is_input ? 3 : 2); + uint64_t inout_index; + if (!_.EvalConstantValUint64(inst->GetOperandAs(is_input ? 2 : 1), + &inout_index)) { + continue; + } + uint64_t element_index = -1; // -1 means no ElementIndex + if (has_element_index) { + if (!_.EvalConstantValUint64( + inst->GetOperandAs(is_input ? 3 : 2), &element_index)) { + continue; + } + } + auto inout_element_pair = std::make_pair(inout_index, element_index); + auto inout_noelement_pair = std::make_pair(inout_index, -1); + if (inout_element_indices.count(inout_element_pair) || + inout_element_indices.count(inout_noelement_pair)) { + *first_dup = inst; + return true; + } + inout_element_indices.insert(inout_element_pair); + } + return false; +} + +spv_result_t ValidateGraphEnd(ValidationState_t& _, const Instruction* inst) { + size_t end_inst_num = inst->LineNum() - 1; + + // Gather OpGraphInputARM and OpGraphSetOutputARM instructions + std::deque graph_inputs, graph_outputs; + size_t in_inst_num = end_inst_num; + auto graph_inst = &_.ordered_instructions()[in_inst_num]; + while (--in_inst_num) { + graph_inst = &_.ordered_instructions()[in_inst_num]; + if (graph_inst->opcode() == spv::Op::OpGraphInputARM) { + graph_inputs.push_front(graph_inst); + continue; + } + if (graph_inst->opcode() == spv::Op::OpGraphSetOutputARM) { + graph_outputs.push_front(graph_inst); + continue; + } + if (graph_inst->opcode() == spv::Op::OpGraphARM) { + break; + } + } + + const Instruction* first_dup; + + // Check that there are no duplicate InputIndex and ElementIndex values + if (InputOutputInstructionsHaveDuplicateIndices(_, graph_inputs, + &first_dup)) { + return _.diag(SPV_ERROR_INVALID_DATA, first_dup) + << "Two OpGraphInputARM instructions with the same InputIndex " + "must not be part of the same " + << "graph definition unless ElementIndex is present in both with " + "different values."; + } + + // Check that there are no duplicate OutputIndex and ElementIndex values + if (InputOutputInstructionsHaveDuplicateIndices(_, graph_outputs, + &first_dup)) { + return _.diag(SPV_ERROR_INVALID_DATA, first_dup) + << "Two OpGraphSetOutputARM instructions with the same " + "OutputIndex must not be part of the same " + << "graph definition unless ElementIndex is present in both with " + "different values."; + } + + return SPV_SUCCESS; +} + +} // namespace + +// Validates correctness of graph instructions. +spv_result_t GraphPass(ValidationState_t& _, const Instruction* inst) { + switch (inst->opcode()) { + case spv::Op::OpTypeGraphARM: + return ValidateGraphType(_, inst); + case spv::Op::OpGraphConstantARM: + return ValidateGraphConstant(_, inst); + case spv::Op::OpGraphEntryPointARM: + return ValidateGraphEntryPoint(_, inst); + case spv::Op::OpGraphARM: + return ValidateGraph(_, inst); + case spv::Op::OpGraphInputARM: + return ValidateGraphInput(_, inst); + case spv::Op::OpGraphSetOutputARM: + return ValidateGraphSetOutput(_, inst); + case spv::Op::OpGraphEndARM: + return ValidateGraphEnd(_, inst); + default: + break; + } + return SPV_SUCCESS; +} + +} // namespace val +} // namespace spvtools diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_id.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_id.cpp index 00be150..f43e982 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_id.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_id.cpp @@ -115,6 +115,57 @@ spv_result_t CheckIdDefinitionDominateUse(ValidationState_t& _) { return SPV_SUCCESS; } +bool InstructionCanHaveTypeOperand(const Instruction* inst) { + static std::unordered_set instruction_allow_set{ + spv::Op::OpSizeOf, + spv::Op::OpCooperativeMatrixLengthNV, + spv::Op::OpCooperativeMatrixLengthKHR, + spv::Op::OpUntypedArrayLengthKHR, + spv::Op::OpFunction, + spv::Op::OpAsmINTEL, + }; + const auto opcode = inst->opcode(); + bool type_instruction = spvOpcodeGeneratesType(opcode); + bool debug_instruction = spvOpcodeIsDebug(opcode) || inst->IsDebugInfo(); + bool coop_matrix_spec_constant_op_length = + (opcode == spv::Op::OpSpecConstantOp) && + (spv::Op(inst->word(3)) == spv::Op::OpCooperativeMatrixLengthNV || + spv::Op(inst->word(3)) == spv::Op::OpCooperativeMatrixLengthKHR); + return type_instruction || debug_instruction || inst->IsNonSemantic() || + spvOpcodeIsDecoration(opcode) || instruction_allow_set.count(opcode) || + spvOpcodeGeneratesUntypedPointer(opcode) || + coop_matrix_spec_constant_op_length; +} + +bool InstructionRequiresTypeOperand(const Instruction* inst) { + static std::unordered_set instruction_deny_set{ + spv::Op::OpExtInst, + spv::Op::OpExtInstWithForwardRefsKHR, + spv::Op::OpExtInstImport, + spv::Op::OpSelectionMerge, + spv::Op::OpLoopMerge, + spv::Op::OpFunction, + spv::Op::OpSizeOf, + spv::Op::OpCooperativeMatrixLengthNV, + spv::Op::OpCooperativeMatrixLengthKHR, + spv::Op::OpPhi, + spv::Op::OpUntypedArrayLengthKHR, + spv::Op::OpAsmINTEL, + }; + const auto opcode = inst->opcode(); + bool debug_instruction = spvOpcodeIsDebug(opcode) || inst->IsDebugInfo(); + bool coop_matrix_spec_constant_op_length = + opcode == spv::Op::OpSpecConstantOp && + (spv::Op(inst->word(3)) == spv::Op::OpCooperativeMatrixLengthNV || + spv::Op(inst->word(3)) == spv::Op::OpCooperativeMatrixLengthKHR); + + return !debug_instruction && !inst->IsNonSemantic() && + !spvOpcodeIsDecoration(opcode) && !spvOpcodeIsBranch(opcode) && + !instruction_deny_set.count(opcode) && + !spvOpcodeGeneratesUntypedPointer(opcode) && + !coop_matrix_spec_constant_op_length; +} + // Performs SSA validation on the IDs of an instruction. The // can_have_forward_declared_ids functor should return true if the // instruction operand's ID can be forward referenced. @@ -158,44 +209,14 @@ spv_result_t IdPass(ValidationState_t& _, Instruction* inst) { case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: case SPV_OPERAND_TYPE_SCOPE_ID: if (const auto def = _.FindDef(operand_word)) { - const auto opcode = inst->opcode(); if (spvOpcodeGeneratesType(def->opcode()) && - !spvOpcodeGeneratesType(opcode) && !spvOpcodeIsDebug(opcode) && - !inst->IsDebugInfo() && !inst->IsNonSemantic() && - !spvOpcodeIsDecoration(opcode) && opcode != spv::Op::OpFunction && - opcode != spv::Op::OpSizeOf && - opcode != spv::Op::OpCooperativeMatrixLengthNV && - opcode != spv::Op::OpCooperativeMatrixLengthKHR && - !spvOpcodeGeneratesUntypedPointer(opcode) && - opcode != spv::Op::OpUntypedArrayLengthKHR && - !(opcode == spv::Op::OpSpecConstantOp && - (spv::Op(inst->word(3)) == - spv::Op::OpCooperativeMatrixLengthNV || - spv::Op(inst->word(3)) == - spv::Op::OpCooperativeMatrixLengthKHR))) { + !InstructionCanHaveTypeOperand(inst)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Operand " << _.getIdName(operand_word) << " cannot be a type"; - } else if (def->type_id() == 0 && !spvOpcodeGeneratesType(opcode) && - !spvOpcodeIsDebug(opcode) && !inst->IsDebugInfo() && - !inst->IsNonSemantic() && !spvOpcodeIsDecoration(opcode) && - !spvOpcodeIsBranch(opcode) && opcode != spv::Op::OpPhi && - opcode != spv::Op::OpExtInst && - opcode != spv::Op::OpExtInstWithForwardRefsKHR && - opcode != spv::Op::OpExtInstImport && - opcode != spv::Op::OpSelectionMerge && - opcode != spv::Op::OpLoopMerge && - opcode != spv::Op::OpFunction && - opcode != spv::Op::OpSizeOf && - opcode != spv::Op::OpCooperativeMatrixLengthNV && - opcode != spv::Op::OpCooperativeMatrixLengthKHR && - !spvOpcodeGeneratesUntypedPointer(opcode) && - opcode != spv::Op::OpUntypedArrayLengthKHR && - !(opcode == spv::Op::OpSpecConstantOp && - (spv::Op(inst->word(3)) == - spv::Op::OpCooperativeMatrixLengthNV || - spv::Op(inst->word(3)) == - spv::Op::OpCooperativeMatrixLengthKHR))) { + } else if (def->type_id() == 0 && + !spvOpcodeGeneratesType(def->opcode()) && + InstructionRequiresTypeOperand(inst)) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "Operand " << _.getIdName(operand_word) << " requires a type"; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_image.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_image.cpp index a5f91f7..58f22f2 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_image.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_image.cpp @@ -464,7 +464,9 @@ spv_result_t ValidateImageOperands(ValidationState_t& _, return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(10213) << "Image Operand Offset can only be used with " - "OpImage*Gather operations"; + "OpImage*Gather operations." + << _.MissingFeature("maintenance8 feature", + "--allow-offset-texture-operand", false); } } } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_instruction.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_instruction.cpp index 655408d..26273af 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_instruction.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_instruction.cpp @@ -195,7 +195,8 @@ spv_result_t CheckRequiredCapabilities(ValidationState_t& state, // registers a capability with the module *before* checking capabilities. // So in the case of an OpCapability instruction, don't bother checking // enablement by another capability. - if (inst->opcode() != spv::Op::OpCapability) { + if (inst->opcode() != spv::Op::OpCapability && + inst->opcode() != spv::Op::OpConditionalCapabilityINTEL) { const bool enabled_by_cap = state.HasAnyOfCapabilities(enabling_capabilities); if (!enabling_capabilities.empty() && !enabled_by_cap) { @@ -461,10 +462,13 @@ spv_result_t CheckIfKnownExtension(ValidationState_t& _, spv_result_t InstructionPass(ValidationState_t& _, const Instruction* inst) { const spv::Op opcode = inst->opcode(); - if (opcode == spv::Op::OpExtension) { + if (opcode == spv::Op::OpExtension || + opcode == spv::Op::OpConditionalExtensionINTEL) { CheckIfKnownExtension(_, inst); } else if (opcode == spv::Op::OpCapability) { _.RegisterCapability(inst->GetOperandAs(0)); + } else if (opcode == spv::Op::OpConditionalCapabilityINTEL) { + _.RegisterCapability(inst->GetOperandAs(1)); } else if (opcode == spv::Op::OpMemoryModel) { if (_.has_memory_model_specified()) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_interfaces.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_interfaces.cpp index fcb5e32..b80c7d8 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_interfaces.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_interfaces.cpp @@ -166,20 +166,17 @@ spv_result_t NumConsumedLocations(ValidationState_t& _, const Instruction* type, } break; case spv::Op::OpTypeMatrix: - // Matrices consume locations equivalent to arrays. - if (auto error = NumConsumedLocations( - _, _.FindDef(type->GetOperandAs(1)), num_locations)) { - return error; - } + // Matrices consume locations equal to the underlying vector type for + // each column. + NumConsumedLocations(_, _.FindDef(type->GetOperandAs(1)), + num_locations); *num_locations *= type->GetOperandAs(2); break; case spv::Op::OpTypeArray: { // Arrays consume locations equal to the underlying type times the number // of elements in the vector. - if (auto error = NumConsumedLocations( - _, _.FindDef(type->GetOperandAs(1)), num_locations)) { - return error; - } + NumConsumedLocations(_, _.FindDef(type->GetOperandAs(1)), + num_locations); bool is_int = false; bool is_const = false; uint32_t value = 0; @@ -249,31 +246,10 @@ uint32_t NumConsumedComponents(ValidationState_t& _, const Instruction* type) { NumConsumedComponents(_, _.FindDef(type->GetOperandAs(1))); num_components *= type->GetOperandAs(2); break; - case spv::Op::OpTypeMatrix: - // Matrices consume all components of the location. - // Round up to next multiple of 4. - num_components = - NumConsumedComponents(_, _.FindDef(type->GetOperandAs(1))); - num_components *= type->GetOperandAs(2); - num_components = ((num_components + 3) / 4) * 4; - break; - case spv::Op::OpTypeArray: { - // Arrays consume all components of the location. - // Round up to next multiple of 4. - num_components = - NumConsumedComponents(_, _.FindDef(type->GetOperandAs(1))); - - bool is_int = false; - bool is_const = false; - uint32_t value = 0; - // Attempt to evaluate the number of array elements. - std::tie(is_int, is_const, value) = - _.EvalInt32IfConst(type->GetOperandAs(2)); - if (is_int && is_const) num_components *= value; - - num_components = ((num_components + 3) / 4) * 4; - return num_components; - } + case spv::Op::OpTypeArray: + // Skip the array. + return NumConsumedComponents(_, + _.FindDef(type->GetOperandAs(1))); case spv::Op::OpTypePointer: if (_.addressing_model() == spv::AddressingModel::PhysicalStorageBuffer64 && @@ -356,10 +332,9 @@ spv_result_t GetLocationsForVariable( } } - // Vulkan 15.1.3 (Interface Matching): Tessellation control and mesh - // per-vertex outputs and tessellation control, evaluation and geometry - // per-vertex inputs have a layer of arraying that is not included in - // interface matching. + // Vulkan 14.1.3: Tessellation control and mesh per-vertex outputs and + // tessellation control, evaluation and geometry per-vertex inputs have a + // layer of arraying that is not included in interface matching. bool is_arrayed = false; switch (entry_point->GetOperandAs(0)) { case spv::ExecutionModel::TessellationControl: @@ -413,33 +388,51 @@ spv_result_t GetLocationsForVariable( const std::string storage_class = is_output ? "output" : "input"; if (has_location) { + auto sub_type = type; + bool is_int = false; + bool is_const = false; + uint32_t array_size = 1; + // If the variable is still arrayed, mark the locations/components per + // index. + if (type->opcode() == spv::Op::OpTypeArray) { + // Determine the array size if possible and get the element type. + std::tie(is_int, is_const, array_size) = + _.EvalInt32IfConst(type->GetOperandAs(2)); + if (!is_int || !is_const) array_size = 1; + auto sub_type_id = type->GetOperandAs(1); + sub_type = _.FindDef(sub_type_id); + } + uint32_t num_locations = 0; - if (auto error = NumConsumedLocations(_, type, &num_locations)) + if (auto error = NumConsumedLocations(_, sub_type, &num_locations)) return error; - uint32_t num_components = NumConsumedComponents(_, type); + uint32_t num_components = NumConsumedComponents(_, sub_type); - uint32_t start = location * 4; - uint32_t end = (location + num_locations) * 4; - if (num_components % 4 != 0) { - start += component; - end = start + num_components; - } + for (uint32_t array_idx = 0; array_idx < array_size; ++array_idx) { + uint32_t array_location = location + (num_locations * array_idx); + uint32_t start = array_location * 4; + if (kMaxLocations <= start) { + // Too many locations, give up. + break; + } - if (kMaxLocations <= start) { - // Too many locations, give up. - return SPV_SUCCESS; - } + uint32_t end = (array_location + num_locations) * 4; + if (num_components != 0) { + start += component; + end = array_location * 4 + component + num_components; + } - auto locs = locations; - if (has_index && index == 1) locs = output_index1_locations; + auto locs = locations; + if (has_index && index == 1) locs = output_index1_locations; - for (uint32_t i = start; i < end; ++i) { - if (!locs->insert(i).second) { - return _.diag(SPV_ERROR_INVALID_DATA, entry_point) - << (is_output ? _.VkErrorID(8722) : _.VkErrorID(8721)) - << "Entry-point has conflicting " << storage_class - << " location assignment at location " << i / 4 << ", component " - << i % 4; + for (uint32_t i = start; i < end; ++i) { + if (!locs->insert(i).second) { + return _.diag(SPV_ERROR_INVALID_DATA, entry_point) + << (is_output ? _.VkErrorID(8722) : _.VkErrorID(8721)) + << "Entry-point has conflicting " << storage_class + << " location assignment at location " << i / 4 + << ", component " << i % 4; + } } } } else { @@ -498,19 +491,38 @@ spv_result_t GetLocationsForVariable( continue; } - uint32_t end = (location + num_locations) * 4; - if (num_components % 4 != 0) { - start += component; - end = location * 4 + component + num_components; - } - - for (uint32_t l = start; l < end; ++l) { - if (!locations->insert(l).second) { - return _.diag(SPV_ERROR_INVALID_DATA, entry_point) - << (is_output ? _.VkErrorID(8722) : _.VkErrorID(8721)) - << "Entry-point has conflicting " << storage_class - << " location assignment at location " << l / 4 - << ", component " << l % 4; + if (member->opcode() == spv::Op::OpTypeArray && num_components >= 1 && + num_components < 4) { + // When an array has an element that takes less than a location in + // size, calculate the used locations in a strided manner. + for (uint32_t l = location; l < num_locations + location; ++l) { + for (uint32_t c = component; c < component + num_components; ++c) { + uint32_t check = 4 * l + c; + if (!locations->insert(check).second) { + return _.diag(SPV_ERROR_INVALID_DATA, entry_point) + << (is_output ? _.VkErrorID(8722) : _.VkErrorID(8721)) + << "Entry-point has conflicting " << storage_class + << " location assignment at location " << l + << ", component " << c; + } + } + } + } else { + // TODO: There is a hole here is the member is an array of 3- or + // 4-element vectors of 64-bit types. + uint32_t end = (location + num_locations) * 4; + if (num_components != 0) { + start += component; + end = location * 4 + component + num_components; + } + for (uint32_t l = start; l < end; ++l) { + if (!locations->insert(l).second) { + return _.diag(SPV_ERROR_INVALID_DATA, entry_point) + << (is_output ? _.VkErrorID(8722) : _.VkErrorID(8721)) + << "Entry-point has conflicting " << storage_class + << " location assignment at location " << l / 4 + << ", component " << l % 4; + } } } } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_invalid_type.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_invalid_type.cpp index bc4827c..6afc0f8 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_invalid_type.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_invalid_type.cpp @@ -69,12 +69,11 @@ spv_result_t InvalidTypePass(ValidationState_t& _, const Instruction* inst) { case spv::Op::OpGroupNonUniformFMul: case spv::Op::OpGroupNonUniformFMin: { const uint32_t result_type = inst->type_id(); - if (_.IsBfloat16ScalarType(result_type) || - _.IsBfloat16VectorType(result_type)) { + if (_.IsBfloat16Type(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << " doesn't support BFloat16 type."; } - if (_.IsFP8ScalarOrVectorType(result_type)) { + if (_.IsFP8Type(result_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << " doesn't support FP8 E4M3/E5M2 types."; @@ -103,12 +102,11 @@ spv_result_t InvalidTypePass(ValidationState_t& _, const Instruction* inst) { case spv::Op::OpIsNormal: case spv::Op::OpSignBitSet: { const uint32_t operand_type = _.GetOperandTypeId(inst, 2); - if (_.IsBfloat16ScalarType(operand_type) || - _.IsBfloat16VectorType(operand_type)) { + if (_.IsBfloat16Type(operand_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << " doesn't support BFloat16 type."; } - if (_.IsFP8ScalarOrVectorType(operand_type)) { + if (_.IsFP8Type(operand_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << " doesn't support FP8 E4M3/E5M2 types."; @@ -118,12 +116,11 @@ spv_result_t InvalidTypePass(ValidationState_t& _, const Instruction* inst) { case spv::Op::OpGroupNonUniformAllEqual: { const auto value_type = _.GetOperandTypeId(inst, 3); - if (_.IsBfloat16ScalarType(value_type) || - _.IsBfloat16VectorType(value_type)) { + if (_.IsBfloat16Type(value_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << " doesn't support BFloat16 type."; } - if (_.IsFP8ScalarOrVectorType(value_type)) { + if (_.IsFP8Type(value_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << " doesn't support FP8 E4M3/E5M2 types."; @@ -140,12 +137,12 @@ spv_result_t InvalidTypePass(ValidationState_t& _, const Instruction* inst) { uint32_t res_component_type = 0; if (_.GetMatrixTypeInfo(result_type, &res_num_rows, &res_num_cols, &res_col_type, &res_component_type)) { - if (_.IsBfloat16ScalarType(res_component_type)) { + if (_.IsBfloat16Type(res_component_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << " doesn't support BFloat16 type."; } - if (_.IsFP8ScalarOrVectorType(res_component_type)) { + if (_.IsFP8Type(res_component_type)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) << " doesn't support FP8 E4M3/E5M2 types."; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_layout.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_layout.cpp index baf36b8..dcc4e5b 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_layout.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_layout.cpp @@ -342,13 +342,84 @@ spv_result_t FunctionScopedInstructions(ValidationState_t& _, break; } } else { - return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) - << spvOpcodeString(opcode) - << " cannot appear in a function declaration"; + _.ProgressToNextLayoutSectionOrder(); + // All function sections have been processed. Recursively call + // ModuleLayoutPass to process the next section of the module + return ModuleLayoutPass(_, inst); } return SPV_SUCCESS; } +spv_result_t GraphScopedInstructions(ValidationState_t& _, + const Instruction* inst, spv::Op opcode) { + if (_.IsOpcodeInCurrentLayoutSection(opcode)) { + switch (opcode) { + case spv::Op::OpGraphARM: { + if (_.graph_definition_region() > kGraphDefinitionOutside) { + return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) + << "Cannot define a graph in a graph"; + } + _.SetGraphDefinitionRegion(kGraphDefinitionBegin); + } break; + case spv::Op::OpGraphInputARM: { + if ((_.graph_definition_region() != kGraphDefinitionBegin) && + (_.graph_definition_region() != kGraphDefinitionInputs)) { + return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) + << "OpGraphInputARM" + << " must immediately follow an OpGraphARM or OpGraphInputARM " + "instruction."; + } + _.SetGraphDefinitionRegion(kGraphDefinitionInputs); + } break; + case spv::Op::OpGraphSetOutputARM: { + if ((_.graph_definition_region() != kGraphDefinitionBegin) && + (_.graph_definition_region() != kGraphDefinitionInputs) && + (_.graph_definition_region() != kGraphDefinitionBody) && + (_.graph_definition_region() != kGraphDefinitionOutputs)) { + return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) + << "Op" << spvOpcodeString(opcode) + << " must immediately precede an OpGraphEndARM or " + "OpGraphSetOutputARM instruction."; + } + _.SetGraphDefinitionRegion(kGraphDefinitionOutputs); + } break; + case spv::Op::OpGraphEndARM: { + if (_.graph_definition_region() != kGraphDefinitionOutputs) { + return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) + << spvOpcodeString(opcode) + << " must be preceded by at least one OpGraphSetOutputARM " + "instruction"; + } + _.SetGraphDefinitionRegion(kGraphDefinitionOutside); + } break; + case spv::Op::OpGraphEntryPointARM: + if (_.graph_definition_region() != kGraphDefinitionOutside) { + return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) + << spvOpcodeString(opcode) + << " cannot appear in the definition of a graph"; + } + break; + default: + if (_.graph_definition_region() == kGraphDefinitionOutside) { + return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) + << "Op" << spvOpcodeString(opcode) + << " must appear in a graph body"; + } + if (_.graph_definition_region() == kGraphDefinitionOutputs) { + return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) + << spvOpcodeString(opcode) + << " cannot appear after a graph output instruction"; + } + _.SetGraphDefinitionRegion(kGraphDefinitionBody); + break; + } + } else { + return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) + << "Op" << spvOpcodeString(opcode) + << " cannot appear in the graph definitions section"; + } + return SPV_SUCCESS; +} } // namespace // TODO(umar): Check linkage capabilities for function declarations @@ -379,6 +450,11 @@ spv_result_t ModuleLayoutPass(ValidationState_t& _, const Instruction* inst) { return error; } break; + case kLayoutGraphDefinitions: + if (auto error = GraphScopedInstructions(_, inst, opcode)) { + return error; + } + break; } return SPV_SUCCESS; } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_memory.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_memory.cpp index ae7de40..a4d8e8b 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_memory.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_memory.cpp @@ -196,10 +196,10 @@ bool ContainsInvalidBool(ValidationState_t& _, const Instruction* storage, return false; } -std::pair GetStorageClass( - ValidationState_t& _, const Instruction* inst) { - spv::StorageClass dst_sc = spv::StorageClass::Max; - spv::StorageClass src_sc = spv::StorageClass::Max; +std::pair GetPointerTypes(ValidationState_t& _, + const Instruction* inst) { + Instruction* dst_pointer_type = nullptr; + Instruction* src_pointer_type = nullptr; switch (inst->opcode()) { case spv::Op::OpCooperativeMatrixLoadNV: case spv::Op::OpCooperativeMatrixLoadTensorNV: @@ -207,8 +207,7 @@ std::pair GetStorageClass( case spv::Op::OpCooperativeVectorLoadNV: case spv::Op::OpLoad: { auto load_pointer = _.FindDef(inst->GetOperandAs(2)); - auto load_pointer_type = _.FindDef(load_pointer->type_id()); - dst_sc = load_pointer_type->GetOperandAs(1); + dst_pointer_type = _.FindDef(load_pointer->type_id()); break; } case spv::Op::OpCooperativeMatrixStoreNV: @@ -217,25 +216,23 @@ std::pair GetStorageClass( case spv::Op::OpCooperativeVectorStoreNV: case spv::Op::OpStore: { auto store_pointer = _.FindDef(inst->GetOperandAs(0)); - auto store_pointer_type = _.FindDef(store_pointer->type_id()); - dst_sc = store_pointer_type->GetOperandAs(1); + dst_pointer_type = _.FindDef(store_pointer->type_id()); break; } + // Spec: "Matching Storage Class is not required" case spv::Op::OpCopyMemory: case spv::Op::OpCopyMemorySized: { - auto dst = _.FindDef(inst->GetOperandAs(0)); - auto dst_type = _.FindDef(dst->type_id()); - dst_sc = dst_type->GetOperandAs(1); - auto src = _.FindDef(inst->GetOperandAs(1)); - auto src_type = _.FindDef(src->type_id()); - src_sc = src_type->GetOperandAs(1); + auto dst_pointer = _.FindDef(inst->GetOperandAs(0)); + dst_pointer_type = _.FindDef(dst_pointer->type_id()); + auto src_pointer = _.FindDef(inst->GetOperandAs(1)); + src_pointer_type = _.FindDef(src_pointer->type_id()); break; } default: break; } - return std::make_pair(dst_sc, src_sc); + return std::make_pair(dst_pointer_type, src_pointer_type); } // Returns the number of instruction words taken up by a memory access @@ -288,8 +285,17 @@ bool DoesStructContainRTA(const ValidationState_t& _, const Instruction* inst) { spv_result_t CheckMemoryAccess(ValidationState_t& _, const Instruction* inst, uint32_t index) { - spv::StorageClass dst_sc, src_sc; - std::tie(dst_sc, src_sc) = GetStorageClass(_, inst); + Instruction* dst_pointer_type = nullptr; + Instruction* src_pointer_type = nullptr; // only used for OpCopyMemory + std::tie(dst_pointer_type, src_pointer_type) = GetPointerTypes(_, inst); + + const spv::StorageClass dst_sc = + dst_pointer_type ? dst_pointer_type->GetOperandAs(1) + : spv::StorageClass::Max; + const spv::StorageClass src_sc = + src_pointer_type ? src_pointer_type->GetOperandAs(1) + : spv::StorageClass::Max; + if (inst->operands().size() <= index) { // Cases where lack of some operand is invalid if (src_sc == spv::StorageClass::PhysicalStorageBuffer || @@ -390,6 +396,32 @@ spv_result_t CheckMemoryAccess(ValidationState_t& _, const Instruction* inst, << "Memory accesses Aligned operand value " << aligned_value << " is not a power of two."; } + + uint32_t largest_scalar = 0; + if (dst_sc == spv::StorageClass::PhysicalStorageBuffer) { + if (dst_pointer_type->opcode() != spv::Op::OpTypeUntypedPointerKHR) { + largest_scalar = + _.GetLargestScalarType(dst_pointer_type->GetOperandAs(2)); + } else if (inst->type_id() != 0) { + largest_scalar = _.GetLargestScalarType(inst->type_id()); + } else { + // TODO need to handle cases like OpStore and OpCopyMemorySized which + // don't have a result type + } + } + // TODO - Handle Untyped in OpCopyMemory + if (src_sc == spv::StorageClass::PhysicalStorageBuffer && + src_pointer_type->opcode() != spv::Op::OpTypeUntypedPointerKHR) { + largest_scalar = std::max( + largest_scalar, + _.GetLargestScalarType(src_pointer_type->GetOperandAs(2))); + } + if (aligned_value < largest_scalar) { + return _.diag(SPV_ERROR_INVALID_ID, inst) + << _.VkErrorID(6314) << "Memory accesses Aligned operand value " + << aligned_value << " is too small, the largest scalar type is " + << largest_scalar << " bytes."; + } } return SPV_SUCCESS; @@ -435,6 +467,7 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) { } if (spvIsVulkanEnv(_.context()->target_env)) { return _.diag(SPV_ERROR_INVALID_ID, inst) + << _.VkErrorID(11167) << "Vulkan requires that data type be specified"; } } @@ -1555,6 +1588,60 @@ spv_result_t ValidateAccessChain(ValidationState_t& _, return _.diag(SPV_ERROR_INVALID_ID, inst) << "Base type must be a non-pointer type"; } + + const auto ContainsBlock = [&_](const Instruction* type_inst) { + if (type_inst->opcode() == spv::Op::OpTypeStruct) { + if (_.HasDecoration(type_inst->id(), spv::Decoration::Block) || + _.HasDecoration(type_inst->id(), spv::Decoration::BufferBlock)) { + return true; + } + } + return false; + }; + + // Block (and BufferBlock) arrays cannot be reinterpreted via untyped access + // chains. + const bool base_type_block_array = + base_type->opcode() == spv::Op::OpTypeArray && + _.ContainsType(base_type->id(), ContainsBlock, + /* traverse_all_types = */ false); + + const auto base_index = untyped_pointer ? 3 : 2; + const auto base_id = inst->GetOperandAs(base_index); + auto base = _.FindDef(base_id); + // Strictly speaking this misses trivial access chains and function + // parameter chasing, but that would be a significant complication in the + // traversal. + while (base->opcode() == spv::Op::OpCopyObject) { + base = _.FindDef(base->GetOperandAs(2)); + } + const Instruction* base_data_type = nullptr; + if (base->opcode() == spv::Op::OpVariable) { + const auto ptr_type = _.FindDef(base->type_id()); + base_data_type = _.FindDef(ptr_type->GetOperandAs(2)); + } else if (base->opcode() == spv::Op::OpUntypedVariableKHR) { + if (base->operands().size() > 3) { + base_data_type = _.FindDef(base->GetOperandAs(3)); + } + } + + if (base_data_type) { + const bool base_block_array = + base_data_type->opcode() == spv::Op::OpTypeArray && + _.ContainsType(base_data_type->id(), ContainsBlock, + /* traverse_all_types = */ false); + + if (base_type_block_array != base_block_array) { + return _.diag(SPV_ERROR_INVALID_ID, inst) + << "Both Base Type and Base must be Block or BufferBlock arrays " + "or neither can be"; + } else if (base_type_block_array && base_block_array && + base_type->id() != base_data_type->id()) { + return _.diag(SPV_ERROR_INVALID_ID, inst) + << "If Base or Base Type is a Block or BufferBlock array, the " + "other must also be the same array"; + } + } } // Base must be a pointer, pointing to the base of a composite object. @@ -1845,14 +1932,34 @@ spv_result_t ValidatePtrAccessChain(ValidationState_t& _, const bool untyped_pointer = spvOpcodeGeneratesUntypedPointer(inst->opcode()); - const auto base_id = inst->GetOperandAs(2); - const auto base = _.FindDef(base_id); - const auto base_type = untyped_pointer - ? _.FindDef(inst->GetOperandAs(2)) - : _.FindDef(base->type_id()); + const auto base_idx = untyped_pointer ? 3 : 2; + const auto base = _.FindDef(inst->GetOperandAs(base_idx)); + const auto base_type = _.FindDef(base->type_id()); const auto base_type_storage_class = base_type->GetOperandAs(1); + const auto element_idx = untyped_pointer ? 4 : 3; + const auto element = _.FindDef(inst->GetOperandAs(element_idx)); + const auto element_type = _.FindDef(element->type_id()); + if (!element_type || element_type->opcode() != spv::Op::OpTypeInt) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Element must be an integer"; + } + uint64_t element_val = 0; + if (_.EvalConstantValUint64(element->id(), &element_val)) { + if (element_val != 0) { + const auto interp_type = + untyped_pointer ? _.FindDef(inst->GetOperandAs(2)) + : _.FindDef(base_type->GetOperandAs(2)); + if (interp_type->opcode() == spv::Op::OpTypeStruct && + (_.HasDecoration(interp_type->id(), spv::Decoration::Block) || + _.HasDecoration(interp_type->id(), spv::Decoration::BufferBlock))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "Element must be 0 if the interpretation type is a Block- or " + "BufferBlock-decorated structure"; + } + } + } + if (_.HasCapability(spv::Capability::Shader) && (base_type_storage_class == spv::StorageClass::Uniform || base_type_storage_class == spv::StorageClass::StorageBuffer || diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_memory_semantics.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_memory_semantics.cpp index d94d37d..1cee9f1 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_memory_semantics.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_memory_semantics.cpp @@ -32,6 +32,9 @@ spv_result_t ValidateMemorySemantics(ValidationState_t& _, uint32_t value = 0; std::tie(is_int32, is_const_int32, value) = _.EvalInt32IfConst(id); + const bool is_vulkan = spvIsVulkanEnv(_.context()->target_env) || + _.memory_model() == spv::MemoryModel::VulkanKHR; + if (!is_int32) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) @@ -56,6 +59,21 @@ spv_result_t ValidateMemorySemantics(ValidationState_t& _, return SPV_SUCCESS; } + if (value & uint32_t(spv::MemorySemanticsMask::UniformMemory) && + !_.HasCapability(spv::Capability::Shader)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(opcode) + << ": Memory Semantics UniformMemory requires capability Shader"; + } + + if (value & uint32_t(spv::MemorySemanticsMask::OutputMemoryKHR) && + !_.HasCapability(spv::Capability::VulkanMemoryModel)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(opcode) + << ": Memory Semantics OutputMemoryKHR requires capability " + << "VulkanMemoryModelKHR"; + } + const size_t num_memory_order_set_bits = spvtools::utils::CountSetBits( value & uint32_t(spv::MemorySemanticsMask::Acquire | spv::MemorySemanticsMask::Release | @@ -64,197 +82,207 @@ spv_result_t ValidateMemorySemantics(ValidationState_t& _, if (num_memory_order_set_bits > 1) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << spvOpcodeString(opcode) - << ": Memory Semantics can have at most one of the following " - "bits set: Acquire, Release, AcquireRelease or " - "SequentiallyConsistent"; + << _.VkErrorID(10865) << spvOpcodeString(opcode) + << ": Memory Semantics must have at most one non-relaxed " + "memory order bit set"; } - if (_.memory_model() == spv::MemoryModel::VulkanKHR && - value & uint32_t(spv::MemorySemanticsMask::SequentiallyConsistent)) { + if (is_vulkan && + (value & uint32_t(spv::MemorySemanticsMask::SequentiallyConsistent))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "SequentiallyConsistent memory " - "semantics cannot be used with " - "the VulkanKHR memory model."; + << _.VkErrorID(10866) << spvOpcodeString(opcode) + << ": Memory Semantics with SequentiallyConsistent memory order " + "must not be used in the Vulkan API"; } - if (value & uint32_t(spv::MemorySemanticsMask::MakeAvailableKHR) && - !_.HasCapability(spv::Capability::VulkanMemoryModelKHR)) { + if ((opcode == spv::Op::OpAtomicStore || + opcode == spv::Op::OpAtomicFlagClear) && + (value & uint32_t(spv::MemorySemanticsMask::Acquire) || + value & uint32_t(spv::MemorySemanticsMask::AcquireRelease))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << spvOpcodeString(opcode) - << ": Memory Semantics MakeAvailableKHR requires capability " - << "VulkanMemoryModelKHR"; + << _.VkErrorID(10867) << spvOpcodeString(opcode) + << ": MemorySemantics must not use Acquire or AcquireRelease " + "memory order with " + << spvOpcodeString(opcode); } - if (value & uint32_t(spv::MemorySemanticsMask::MakeVisibleKHR) && - !_.HasCapability(spv::Capability::VulkanMemoryModelKHR)) { + if (opcode == spv::Op::OpAtomicLoad && + (value & uint32_t(spv::MemorySemanticsMask::Release) || + value & uint32_t(spv::MemorySemanticsMask::AcquireRelease))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << spvOpcodeString(opcode) - << ": Memory Semantics MakeVisibleKHR requires capability " - << "VulkanMemoryModelKHR"; + << _.VkErrorID(10868) << spvOpcodeString(opcode) + << ": MemorySemantics must not use Release or AcquireRelease " + "memory order with " + << spvOpcodeString(opcode); } - if (value & uint32_t(spv::MemorySemanticsMask::OutputMemoryKHR) && - !_.HasCapability(spv::Capability::VulkanMemoryModelKHR)) { + // In OpenCL, a relaxed fence has no effect but is not explicitly forbidden + if (is_vulkan && opcode == spv::Op::OpMemoryBarrier && + !num_memory_order_set_bits) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << spvOpcodeString(opcode) - << ": Memory Semantics OutputMemoryKHR requires capability " - << "VulkanMemoryModelKHR"; + << _.VkErrorID(10869) << spvOpcodeString(opcode) + << ": MemorySemantics must not use Relaxed memory order with " + << spvOpcodeString(opcode); } - if (value & uint32_t(spv::MemorySemanticsMask::Volatile)) { - if (!_.HasCapability(spv::Capability::VulkanMemoryModelKHR)) { + if (is_vulkan) { + const bool includes_storage_class = + value & uint32_t(spv::MemorySemanticsMask::UniformMemory | + spv::MemorySemanticsMask::WorkgroupMemory | + spv::MemorySemanticsMask::ImageMemory | + spv::MemorySemanticsMask::OutputMemoryKHR); + + if (num_memory_order_set_bits && !includes_storage_class) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << spvOpcodeString(opcode) - << ": Memory Semantics Volatile requires capability " - "VulkanMemoryModelKHR"; + << _.VkErrorID(10870) << spvOpcodeString(opcode) + << ": Memory Semantics with a non-relaxed memory order (Acquire, " + "Release, or AcquireRelease) must have at least one " + "Vulkan-supported storage class semantics bit set " + "(UniformMemory, WorkgroupMemory, ImageMemory, or " + "OutputMemory)"; } - if (!spvOpcodeIsAtomicOp(inst->opcode())) { + if (!num_memory_order_set_bits && includes_storage_class) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "Memory Semantics Volatile can only be used with atomic " - "instructions"; + << _.VkErrorID(10871) << spvOpcodeString(opcode) + << ": Memory Semantics with at least one Vulkan-supported " + "storage class semantics bit set (UniformMemory, " + "WorkgroupMemory, ImageMemory, or OutputMemory) must use " + "a non-relaxed memory order (Acquire, Release, or " + "AcquireRelease)"; } } - if (value & uint32_t(spv::MemorySemanticsMask::UniformMemory) && - !_.HasCapability(spv::Capability::Shader)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << spvOpcodeString(opcode) - << ": Memory Semantics UniformMemory requires capability Shader"; - } - - // Checking for spv::Capability::AtomicStorage is intentionally not done here. - // See https://github.com/KhronosGroup/glslang/issues/1618 for the reasoning - // why. - - if (value & uint32_t(spv::MemorySemanticsMask::MakeAvailableKHR | - spv::MemorySemanticsMask::MakeVisibleKHR)) { - const bool includes_storage_class = - value & uint32_t(spv::MemorySemanticsMask::UniformMemory | - spv::MemorySemanticsMask::SubgroupMemory | - spv::MemorySemanticsMask::WorkgroupMemory | - spv::MemorySemanticsMask::CrossWorkgroupMemory | - spv::MemorySemanticsMask::AtomicCounterMemory | - spv::MemorySemanticsMask::ImageMemory | - spv::MemorySemanticsMask::OutputMemoryKHR); - - if (!includes_storage_class) { + if (value & uint32_t(spv::MemorySemanticsMask::MakeAvailableKHR)) { + if (!_.HasCapability(spv::Capability::VulkanMemoryModel)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << spvOpcodeString(opcode) - << ": expected Memory Semantics to include a storage class"; + << ": Memory Semantics MakeAvailableKHR requires capability " + << "VulkanMemoryModelKHR"; + } + if (!(value & uint32_t(spv::MemorySemanticsMask::Release | + spv::MemorySemanticsMask::AcquireRelease))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << _.VkErrorID(10872) << spvOpcodeString(opcode) + << ": Memory Semantics with MakeAvailable bit set must use " + "Release or AcquireRelease memory order"; } } - if (value & uint32_t(spv::MemorySemanticsMask::MakeVisibleKHR) && - !(value & uint32_t(spv::MemorySemanticsMask::Acquire | - spv::MemorySemanticsMask::AcquireRelease))) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << spvOpcodeString(opcode) - << ": MakeVisibleKHR Memory Semantics also requires either Acquire " - "or AcquireRelease Memory Semantics"; + if (value & uint32_t(spv::MemorySemanticsMask::MakeVisibleKHR)) { + if (!_.HasCapability(spv::Capability::VulkanMemoryModel)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(opcode) + << ": Memory Semantics MakeVisibleKHR requires capability " + << "VulkanMemoryModelKHR"; + } + if (!(value & uint32_t(spv::MemorySemanticsMask::Acquire | + spv::MemorySemanticsMask::AcquireRelease))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << _.VkErrorID(10873) << spvOpcodeString(opcode) + << ": Memory Semantics with MakeVisible bit set must use Acquire " + "or AcquireRelease memory order"; + } } - if (value & uint32_t(spv::MemorySemanticsMask::MakeAvailableKHR) && - !(value & uint32_t(spv::MemorySemanticsMask::Release | - spv::MemorySemanticsMask::AcquireRelease))) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << spvOpcodeString(opcode) - << ": MakeAvailableKHR Memory Semantics also requires either " - "Release or AcquireRelease Memory Semantics"; + if (value & uint32_t(spv::MemorySemanticsMask::Volatile)) { + if (!_.HasCapability(spv::Capability::VulkanMemoryModel)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << spvOpcodeString(opcode) + << ": Memory Semantics Volatile requires capability " + "VulkanMemoryModelKHR"; + } + if (!spvOpcodeIsAtomicOp(inst->opcode())) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << _.VkErrorID(10874) << spvOpcodeString(opcode) + << ": Memory Semantics with Volatile bit set must not be used " + "with barrier instructions"; + } } - if (spvIsVulkanEnv(_.context()->target_env)) { - const bool includes_storage_class = - value & uint32_t(spv::MemorySemanticsMask::UniformMemory | - spv::MemorySemanticsMask::WorkgroupMemory | - spv::MemorySemanticsMask::ImageMemory | - spv::MemorySemanticsMask::OutputMemoryKHR); - - if (opcode == spv::Op::OpMemoryBarrier && !num_memory_order_set_bits) { + if ((opcode == spv::Op::OpAtomicCompareExchange || + opcode == spv::Op::OpAtomicCompareExchangeWeak) && + operand_index == 5) { + if (value & uint32_t(spv::MemorySemanticsMask::Release) || + value & uint32_t(spv::MemorySemanticsMask::AcquireRelease)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << _.VkErrorID(4732) << spvOpcodeString(opcode) - << ": Vulkan specification requires Memory Semantics to have " - "one of the following bits set: Acquire, Release, " - "AcquireRelease or SequentiallyConsistent"; - } else if (opcode != spv::Op::OpMemoryBarrier && - num_memory_order_set_bits) { - // should leave only atomics and control barriers for Vulkan env - bool memory_is_int32 = false, memory_is_const_int32 = false; - uint32_t memory_value = 0; - std::tie(memory_is_int32, memory_is_const_int32, memory_value) = - _.EvalInt32IfConst(memory_scope); - if (memory_is_int32 && - spv::Scope(memory_value) == spv::Scope::Invocation) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << _.VkErrorID(4641) << spvOpcodeString(opcode) - << ": Vulkan specification requires Memory Semantics to be None " - "if used with Invocation Memory Scope"; - } + << _.VkErrorID(10875) << spvOpcodeString(opcode) + << " Unequal Memory Semantics must not use Release or " + "AcquireRelease memory order"; } - if (opcode == spv::Op::OpMemoryBarrier && !includes_storage_class) { + bool is_equal_int32 = false; + bool is_equal_const = false; + uint32_t equal_value = 0; + std::tie(is_equal_int32, is_equal_const, equal_value) = + _.EvalInt32IfConst(inst->GetOperandAs(4)); + + const auto equal_mask_seq_cst = + uint32_t(spv::MemorySemanticsMask::SequentiallyConsistent); + const auto equal_mask_acquire = uint32_t( + // Allow EqualMemorySemantics Release with UnequalMemorySemantics + // Acquire, since the C standard doesn't clearly forbid it. + spv::MemorySemanticsMask::SequentiallyConsistent | + spv::MemorySemanticsMask::AcquireRelease | + spv::MemorySemanticsMask::Release | spv::MemorySemanticsMask::Acquire); + + if (((value & uint32_t(spv::MemorySemanticsMask::SequentiallyConsistent)) && + !(equal_value & equal_mask_seq_cst)) || + ((value & uint32_t(spv::MemorySemanticsMask::Acquire)) && + !(equal_value & equal_mask_acquire))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << _.VkErrorID(4733) << spvOpcodeString(opcode) - << ": expected Memory Semantics to include a Vulkan-supported " - "storage class"; + << _.VkErrorID(10876) << spvOpcodeString(opcode) + << " Unequal Memory Semantics must not use a stronger memory " + "order than the corresponding Equal Memory Semantics"; } - if (opcode == spv::Op::OpControlBarrier && value) { - if (!num_memory_order_set_bits) { + if (is_vulkan) { + auto storage_class_semantics_mask = + uint32_t(spv::MemorySemanticsMask::UniformMemory | + spv::MemorySemanticsMask::WorkgroupMemory | + spv::MemorySemanticsMask::ImageMemory | + spv::MemorySemanticsMask::OutputMemoryKHR); + + if (value & ~equal_value & storage_class_semantics_mask) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << _.VkErrorID(10609) << spvOpcodeString(opcode) - << ": Vulkan specification requires non-zero Memory Semantics " - "to have one of the following bits set: Acquire, Release, " - "AcquireRelease or SequentiallyConsistent"; + << _.VkErrorID(10877) << spvOpcodeString(opcode) + << " Unequal Memory Semantics must not have any " + "Vulkan-supported storage class semantics bit set " + "(UniformMemory, WorkgroupMemory, ImageMemory, or " + "OutputMemory) unless this bit is also set in the " + "corresponding Equal Memory Semantics"; } - if (!includes_storage_class) { + + if (value & ~equal_value & + uint32_t(spv::MemorySemanticsMask::MakeVisibleKHR)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << _.VkErrorID(4650) << spvOpcodeString(opcode) - << ": expected Memory Semantics to include a Vulkan-supported " - "storage class if Memory Semantics is not None"; + << _.VkErrorID(10878) << spvOpcodeString(opcode) + << " Unequal Memory Semantics must not have MakeVisible bit set " + "unless this bit is also set in the corresponding Equal " + "Memory Semantics"; } - } - } - - if (opcode == spv::Op::OpAtomicFlagClear && - (value & uint32_t(spv::MemorySemanticsMask::Acquire) || - value & uint32_t(spv::MemorySemanticsMask::AcquireRelease))) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "Memory Semantics Acquire and AcquireRelease cannot be used " - "with " - << spvOpcodeString(opcode); - } - if (opcode == spv::Op::OpAtomicCompareExchange && operand_index == 5 && - (value & uint32_t(spv::MemorySemanticsMask::Release) || - value & uint32_t(spv::MemorySemanticsMask::AcquireRelease))) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << spvOpcodeString(opcode) - << ": Memory Semantics Release and AcquireRelease cannot be " - "used " - "for operand Unequal"; - } - - if (spvIsVulkanEnv(_.context()->target_env)) { - if (opcode == spv::Op::OpAtomicLoad && - (value & uint32_t(spv::MemorySemanticsMask::Release) || - value & uint32_t(spv::MemorySemanticsMask::AcquireRelease) || - value & uint32_t(spv::MemorySemanticsMask::SequentiallyConsistent))) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << _.VkErrorID(4731) - << "Vulkan spec disallows OpAtomicLoad with Memory Semantics " - "Release, AcquireRelease and SequentiallyConsistent"; + if ((equal_value & uint32_t(spv::MemorySemanticsMask::Volatile)) ^ + (value & uint32_t(spv::MemorySemanticsMask::Volatile))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << _.VkErrorID(10879) << spvOpcodeString(opcode) + << " Unequal Memory Semantics must have Volatile bit set if and " + "only if this bit is also set in the corresponding Equal " + "Memory Semantics"; + } } + } - if (opcode == spv::Op::OpAtomicStore && - (value & uint32_t(spv::MemorySemanticsMask::Acquire) || - value & uint32_t(spv::MemorySemanticsMask::AcquireRelease) || - value & uint32_t(spv::MemorySemanticsMask::SequentiallyConsistent))) { + if (is_vulkan && num_memory_order_set_bits) { + bool memory_is_int32 = false, memory_is_const_int32 = false; + uint32_t memory_value = 0; + std::tie(memory_is_int32, memory_is_const_int32, memory_value) = + _.EvalInt32IfConst(memory_scope); + if (memory_is_int32 && spv::Scope(memory_value) == spv::Scope::Invocation) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << _.VkErrorID(4730) - << "Vulkan spec disallows OpAtomicStore with Memory Semantics " - "Acquire, AcquireRelease and SequentiallyConsistent"; + << _.VkErrorID(4641) << spvOpcodeString(opcode) + << ": Vulkan specification requires Memory Semantics to be " + "Relaxed if used with Invocation Memory Scope"; } } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_mode_setting.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_mode_setting.cpp index 24b9db9..0de4943 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_mode_setting.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_mode_setting.cpp @@ -59,20 +59,22 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { } const auto* execution_modes = _.GetExecutionModes(entry_point_id); + auto has_mode = [&execution_modes](spv::ExecutionMode mode) { + return execution_modes && execution_modes->count(mode); + }; + if (_.HasCapability(spv::Capability::Shader)) { switch (execution_model) { case spv::ExecutionModel::Fragment: - if (execution_modes && - execution_modes->count(spv::ExecutionMode::OriginUpperLeft) && - execution_modes->count(spv::ExecutionMode::OriginLowerLeft)) { + if (has_mode(spv::ExecutionMode::OriginUpperLeft) && + has_mode(spv::ExecutionMode::OriginLowerLeft)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Fragment execution model entry points can only specify " "one of OriginUpperLeft or OriginLowerLeft execution " "modes."; } - if (!execution_modes || - (!execution_modes->count(spv::ExecutionMode::OriginUpperLeft) && - !execution_modes->count(spv::ExecutionMode::OriginLowerLeft))) { + if (!has_mode(spv::ExecutionMode::OriginUpperLeft) && + !has_mode(spv::ExecutionMode::OriginLowerLeft)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Fragment execution model entry points require either an " "OriginUpperLeft or OriginLowerLeft execution mode."; @@ -285,36 +287,31 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { } } + bool has_workgroup_size = false; + bool has_local_size_id = false; + for (auto& i : _.ordered_instructions()) { + if (i.opcode() == spv::Op::OpFunction) break; + if (i.opcode() == spv::Op::OpDecorate && i.operands().size() > 2) { + if (i.GetOperandAs(1) == spv::Decoration::BuiltIn && + i.GetOperandAs(2) == spv::BuiltIn::WorkgroupSize) { + has_workgroup_size = true; + } + } + if (i.opcode() == spv::Op::OpExecutionModeId) { + if (i.GetOperandAs(1) == + spv::ExecutionMode::LocalSizeId) { + has_local_size_id = true; + } + } + } + if (spvIsVulkanEnv(_.context()->target_env)) { switch (execution_model) { case spv::ExecutionModel::GLCompute: - if (!execution_modes || - !execution_modes->count(spv::ExecutionMode::LocalSize)) { - bool ok = false; - for (auto& i : _.ordered_instructions()) { - if (i.opcode() == spv::Op::OpDecorate) { - if (i.operands().size() > 2) { - if (i.GetOperandAs(1) == - spv::Decoration::BuiltIn && - i.GetOperandAs(2) == - spv::BuiltIn::WorkgroupSize) { - ok = true; - break; - } - } - } - if (i.opcode() == spv::Op::OpExecutionModeId) { - const auto mode = i.GetOperandAs(1); - if (mode == spv::ExecutionMode::LocalSizeId) { - ok = true; - break; - } - } - } + if (!has_mode(spv::ExecutionMode::LocalSize)) { + bool ok = has_workgroup_size || has_local_size_id; if (!ok && _.HasCapability(spv::Capability::TileShadingQCOM)) { - ok = - execution_modes && - execution_modes->count(spv::ExecutionMode::TileShadingRateQCOM); + ok = has_mode(spv::ExecutionMode::TileShadingRateQCOM); } if (!ok) { return _.diag(SPV_ERROR_INVALID_DATA, inst) @@ -332,25 +329,20 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { } if (_.HasCapability(spv::Capability::TileShadingQCOM)) { - if (execution_modes) { - if (execution_modes->count( - spv::ExecutionMode::TileShadingRateQCOM) && - (execution_modes->count(spv::ExecutionMode::LocalSize) || - execution_modes->count(spv::ExecutionMode::LocalSizeId))) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "If the TileShadingRateQCOM execution mode is used, " - << "LocalSize and LocalSizeId must not be specified."; - } - if (execution_modes->count( - spv::ExecutionMode::NonCoherentTileAttachmentReadQCOM)) { - return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "The NonCoherentTileAttachmentQCOM execution mode must " - "not be used in any stage other than fragment."; - } + if (has_mode(spv::ExecutionMode::TileShadingRateQCOM) && + (has_mode(spv::ExecutionMode::LocalSize) || + has_mode(spv::ExecutionMode::LocalSizeId))) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "If the TileShadingRateQCOM execution mode is used, " + << "LocalSize and LocalSizeId must not be specified."; + } + if (has_mode(spv::ExecutionMode::NonCoherentTileAttachmentReadQCOM)) { + return _.diag(SPV_ERROR_INVALID_DATA, inst) + << "The NonCoherentTileAttachmentQCOM execution mode must " + "not be used in any stage other than fragment."; } } else { - if (execution_modes && - execution_modes->count(spv::ExecutionMode::TileShadingRateQCOM)) { + if (has_mode(spv::ExecutionMode::TileShadingRateQCOM)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "If the TileShadingRateQCOM execution mode is used, the " "TileShadingQCOM capability must be enabled."; @@ -358,16 +350,13 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { } break; default: - if (execution_modes && - execution_modes->count(spv::ExecutionMode::TileShadingRateQCOM)) { + if (has_mode(spv::ExecutionMode::TileShadingRateQCOM)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The TileShadingRateQCOM execution mode must not be used " "in any stage other than compute."; } if (execution_model != spv::ExecutionModel::Fragment) { - if (execution_modes && - execution_modes->count( - spv::ExecutionMode::NonCoherentTileAttachmentReadQCOM)) { + if (has_mode(spv::ExecutionMode::NonCoherentTileAttachmentReadQCOM)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "The NonCoherentTileAttachmentQCOM execution mode must " "not be used in any stage other than fragment."; @@ -378,9 +367,7 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { "any stage other than compute or fragment."; } } else { - if (execution_modes && - execution_modes->count( - spv::ExecutionMode::NonCoherentTileAttachmentReadQCOM)) { + if (has_mode(spv::ExecutionMode::NonCoherentTileAttachmentReadQCOM)) { if (!_.HasCapability(spv::Capability::TileShadingQCOM)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "If the NonCoherentTileAttachmentReadQCOM execution " @@ -393,7 +380,9 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { } } - if (_.EntryPointHasLocalSizeOrId(entry_point_id)) { + // WorkgroupSize decoration takes precedence over any LocalSize or LocalSizeId + // execution mode, so the values can be ignored + if (_.EntryPointHasLocalSizeOrId(entry_point_id) && !has_workgroup_size) { const Instruction* local_size_inst = _.EntryPointLocalSizeOrId(entry_point_id); if (local_size_inst) { @@ -402,7 +391,8 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { const uint32_t operand_y = local_size_inst->GetOperandAs(3); const uint32_t operand_z = local_size_inst->GetOperandAs(4); if (mode == spv::ExecutionMode::LocalSize) { - if ((operand_x * operand_y * operand_z) == 0) { + const uint64_t product_size = operand_x * operand_y * operand_z; + if (product_size == 0) { return _.diag(SPV_ERROR_INVALID_DATA, local_size_inst) << "Local Size execution mode must not have a product of zero " "(X " @@ -410,6 +400,32 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { << operand_x << ", Y = " << operand_y << ", Z = " << operand_z << ")."; } + if (has_mode(spv::ExecutionMode::DerivativeGroupQuadsKHR)) { + if (operand_x % 2 != 0 || operand_y % 2 != 0) { + return _.diag(SPV_ERROR_INVALID_DATA, local_size_inst) + << _.VkErrorID(10151) + << "Local Size execution mode dimensions is " + "(X = " + << operand_x << ", Y = " << operand_y + << ") but Entry Point id " << entry_point_id + << " also has an DerivativeGroupQuadsKHR execution mode, so " + "both dimensions must be a multiple of 2"; + } + } + if (has_mode(spv::ExecutionMode::DerivativeGroupLinearKHR)) { + if (product_size % 4 != 0) { + return _.diag(SPV_ERROR_INVALID_DATA, local_size_inst) + << _.VkErrorID(10152) + << "Local Size execution mode dimensions is (X = " + << operand_x << ", Y = " << operand_y + << ", Z = " << operand_z << ") but Entry Point id " + << entry_point_id + << " also has an DerivativeGroupLinearKHR execution mode, " + "so " + "the product (" + << product_size << ") must be a multiple of 4"; + } + } } else if (mode == spv::ExecutionMode::LocalSizeId) { // can only validate product if static and not spec constant // (This is done for us in EvalConstantValUint64) @@ -417,13 +433,42 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { bool static_x = _.EvalConstantValUint64(operand_x, &x_size); bool static_y = _.EvalConstantValUint64(operand_y, &y_size); bool static_z = _.EvalConstantValUint64(operand_z, &z_size); - if (static_x && static_y && static_z && - ((x_size * y_size * z_size) == 0)) { - return _.diag(SPV_ERROR_INVALID_DATA, local_size_inst) - << "Local Size Id execution mode must not have a product of " - "zero " - "(X = " - << x_size << ", Y = " << y_size << ", Z = " << z_size << ")."; + if (static_x && static_y && static_z) { + const uint64_t product_size = x_size * y_size * z_size; + if (product_size == 0) { + return _.diag(SPV_ERROR_INVALID_DATA, local_size_inst) + << "LocalSizeId execution mode must not have a product of " + "zero " + "(X = " + << x_size << ", Y = " << y_size << ", Z = " << z_size + << ")."; + } + if (has_mode(spv::ExecutionMode::DerivativeGroupQuadsKHR)) { + if (x_size % 2 != 0 || y_size % 2 != 0) { + return _.diag(SPV_ERROR_INVALID_DATA, local_size_inst) + << _.VkErrorID(10151) + << "LocalSizeId execution mode dimensions is " + "(X = " + << x_size << ", Y = " << y_size << ") but Entry Point id " + << entry_point_id + << " also has an DerivativeGroupQuadsKHR execution mode, " + "so " + "both dimensions must be a multiple of 2"; + } + } + if (has_mode(spv::ExecutionMode::DerivativeGroupLinearKHR)) { + if (product_size % 4 != 0) { + return _.diag(SPV_ERROR_INVALID_DATA, local_size_inst) + << _.VkErrorID(10152) + << "LocalSizeId execution mode dimensions is (X = " + << x_size << ", Y = " << y_size << ", Z = " << z_size + << ") but Entry Point id " << entry_point_id + << " also has an DerivativeGroupLinearKHR execution mode, " + "so " + "the product (" + << product_size << ") must be a multiple of 4"; + } + } } } } @@ -557,6 +602,7 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _, "Operands that are not id operands."; } + const bool is_vulkan_env = (spvIsVulkanEnv(_.context()->target_env)); const auto* models = _.GetExecutionModels(entry_point_id); switch (mode) { case spv::ExecutionMode::Invocations: @@ -667,7 +713,7 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _, "tessellation execution model."; } } - if (spvIsVulkanEnv(_.context()->target_env)) { + if (is_vulkan_env) { if (_.HasCapability(spv::Capability::MeshShadingEXT) && inst->GetOperandAs(2) == 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) @@ -690,8 +736,7 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _, "execution " "model."; } - if (mode == spv::ExecutionMode::OutputPrimitivesEXT && - spvIsVulkanEnv(_.context()->target_env)) { + if (mode == spv::ExecutionMode::OutputPrimitivesEXT && is_vulkan_env) { if (_.HasCapability(spv::Capability::MeshShadingEXT) && inst->GetOperandAs(2) == 0) { return _.diag(SPV_ERROR_INVALID_DATA, inst) @@ -761,9 +806,15 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _, break; case spv::ExecutionMode::LocalSize: case spv::ExecutionMode::LocalSizeId: - if (mode == spv::ExecutionMode::LocalSizeId && !_.IsLocalSizeIdAllowed()) + if (mode == spv::ExecutionMode::LocalSizeId && + !_.IsLocalSizeIdAllowed()) { return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "LocalSizeId mode is not allowed by the current environment."; + << "LocalSizeId mode is not allowed by the current environment." + << (is_vulkan_env + ? _.MissingFeature("maintenance4 feature", + "--allow-localsizeid", false) + : ""); + } if (!std::all_of( models->begin(), models->end(), @@ -812,7 +863,7 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _, } } - if (spvIsVulkanEnv(_.context()->target_env)) { + if (is_vulkan_env) { if (mode == spv::ExecutionMode::OriginLowerLeft) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4653) diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_non_uniform.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_non_uniform.cpp index fd422a5..9711865 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_non_uniform.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_non_uniform.cpp @@ -130,7 +130,7 @@ spv_result_t ValidateGroupNonUniformBroadcastShuffle(ValidationState_t& _, if (!spvOpcodeIsConstant(id_op)) { std::string operand = GetOperandName(inst->opcode()); return _.diag(SPV_ERROR_INVALID_DATA, inst) - << "Before SPIR-V 1.5, " << operand + << "In SPIR-V 1.4 or earlier, " << operand << " must be a constant instruction"; } } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_scopes.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_scopes.cpp index 6b49353..c7ef5f2 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_scopes.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_scopes.cpp @@ -94,7 +94,7 @@ spv_result_t ValidateExecutionScope(ValidationState_t& _, // Vulkan specific rules if (spvIsVulkanEnv(_.context()->target_env)) { - // Vulkan 1.1 specific rules + // Subgroups were not added until 1.1 if (_.context()->target_env != SPV_ENV_VULKAN_1_0) { // Scope for Non Uniform Group Operations must be limited to Subgroup if ((spvOpcodeIsNonUniformGroupOperation(opcode) && diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_tensor.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_tensor.cpp index 4906aa2..0b54129 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_tensor.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_tensor.cpp @@ -83,8 +83,7 @@ spv_result_t ValidateTensorRead(ValidationState_t& _, const Instruction* inst) { auto op_coord = inst->word(4); auto inst_coord = _.FindDef(op_coord); auto tensor_rank = GetTensorTypeRank(_, inst_tensor->type_id()); - if (tensor_rank == 0 || - !_.IsIntArrayType(inst_coord->type_id(), tensor_rank)) { + if (!_.IsIntArrayType(inst_coord->type_id(), tensor_rank)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinates to be an array whose Element Type is an " "integer type and whose Length is equal to the Rank of Tensor."; @@ -143,8 +142,7 @@ spv_result_t ValidateTensorWrite(ValidationState_t& _, auto op_coord = inst->word(2); auto inst_coord = _.FindDef(op_coord); auto tensor_rank = GetTensorTypeRank(_, inst_tensor->type_id()); - if (tensor_rank == 0 || - !_.IsIntArrayType(inst_coord->type_id(), tensor_rank)) { + if (!_.IsIntArrayType(inst_coord->type_id(), tensor_rank)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Expected Coordinates to be an array whose Element Type is an " "integer type and whose Length is equal to the Rank of Tensor."; diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_type.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_type.cpp index 7a3105a..786a224 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validate_type.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validate_type.cpp @@ -140,7 +140,7 @@ spv_result_t ValidateTypeFloat(ValidationState_t& _, const Instruction* inst) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "8-bit floating point type requires an encoding."; } - const spvtools::OperandDesc* desc; + const spvtools::OperandDesc* desc = nullptr; const std::set known_encodings{ spv::FPEncoding::Float8E4M3EXT, spv::FPEncoding::Float8E5M2EXT}; spv_result_t status = spvtools::LookupOperand(SPV_OPERAND_TYPE_FPENCODING, @@ -433,10 +433,9 @@ spv_result_t ValidateTypeStruct(ValidationState_t& _, const Instruction* inst) { << "Structure " << _.getIdName(member_type_id) << " contains members with BuiltIn decoration. Therefore this " << "structure may not be contained as a member of another " - << "structure " - << "type. Structure " << _.getIdName(struct_id) - << " contains structure " << _.getIdName(member_type_id) - << "."; + << "structure " << "type. Structure " + << _.getIdName(struct_id) << " contains structure " + << _.getIdName(member_type_id) << "."; } if (spvIsVulkanEnv(_.context()->target_env) && @@ -562,6 +561,9 @@ spv_result_t ValidateTypePointer(ValidationState_t& _, // a storage image. if (sampled == 2) _.RegisterPointerToStorageImage(inst->id()); } + if (type->opcode() == spv::Op::OpTypeTensorARM) { + _.RegisterPointerToTensor(inst->id()); + } } if (!_.IsValidStorageClass(storage_class)) { @@ -614,6 +616,7 @@ spv_result_t ValidateTypeFunction(ValidationState_t& _, for (auto& pair : inst->uses()) { const auto* use = pair.first; if (use->opcode() != spv::Op::OpFunction && + use->opcode() != spv::Op::OpAsmINTEL && !spvOpcodeIsDebug(use->opcode()) && !use->IsNonSemantic() && !spvOpcodeIsDecoration(use->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, use) diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validation_state.cpp b/libs/bgfx/3rdparty/spirv-tools/source/val/validation_state.cpp index f302841..e7d7a0b 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validation_state.cpp +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validation_state.cpp @@ -42,14 +42,17 @@ ModuleLayoutSection InstructionLayoutSection( switch (op) { case spv::Op::OpCapability: + case spv::Op::OpConditionalCapabilityINTEL: return kLayoutCapabilities; case spv::Op::OpExtension: + case spv::Op::OpConditionalExtensionINTEL: return kLayoutExtensions; case spv::Op::OpExtInstImport: return kLayoutExtInstImport; case spv::Op::OpMemoryModel: return kLayoutMemoryModel; case spv::Op::OpEntryPoint: + case spv::Op::OpConditionalEntryPointINTEL: return kLayoutEntryPoint; case spv::Op::OpExecutionMode: case spv::Op::OpExecutionModeId: @@ -85,6 +88,9 @@ ModuleLayoutSection InstructionLayoutSection( // spv::Op::OpExtInst is only allowed in types section for certain // extended instruction sets. This will be checked separately. if (current_section == kLayoutTypes) return kLayoutTypes; + // SpvOpExtInst is allowed in graph definitions. + if (current_section == kLayoutGraphDefinitions) + return kLayoutGraphDefinitions; return kLayoutFunctionDefinitions; case spv::Op::OpLine: case spv::Op::OpNoLine: @@ -99,6 +105,16 @@ ModuleLayoutSection InstructionLayoutSection( return kLayoutFunctionDefinitions; case spv::Op::OpSamplerImageAddressingModeNV: return kLayoutSamplerImageAddressMode; + case spv::Op::OpGraphEntryPointARM: + case spv::Op::OpGraphARM: + case spv::Op::OpGraphInputARM: + case spv::Op::OpGraphSetOutputARM: + case spv::Op::OpGraphEndARM: + return kLayoutGraphDefinitions; + case spv::Op::OpCompositeExtract: + if (current_section == kLayoutGraphDefinitions) + return kLayoutGraphDefinitions; + return kLayoutFunctionDefinitions; default: break; } @@ -174,6 +190,7 @@ ValidationState_t::ValidationState_t(const spv_const_context ctx, pointer_size_and_alignment_(0), sampler_image_addressing_mode_(0), in_function_(false), + graph_definition_region_(kGraphDefinitionOutside), num_of_warnings_(0), max_num_of_warnings_(max_warnings) { assert(opt && "Validator options may not be Null."); @@ -362,6 +379,10 @@ bool ValidationState_t::in_block() const { module_functions_.back().current_block() != nullptr; } +GraphDefinitionRegion ValidationState_t::graph_definition_region() const { + return graph_definition_region_; +} + void ValidationState_t::RegisterCapability(spv::Capability cap) { // Avoid redundant work. Otherwise the recursion could induce work // quadrdatic in the capability dependency depth. (Ok, not much, but @@ -532,6 +553,13 @@ spv_result_t ValidationState_t::RegisterFunctionEnd() { return SPV_SUCCESS; } +void ValidationState_t::SetGraphDefinitionRegion(GraphDefinitionRegion region) { + assert((region == kGraphDefinitionOutside && + graph_definition_region_ == kGraphDefinitionOutputs) || + region >= graph_definition_region_); + graph_definition_region_ = region; +} + Instruction* ValidationState_t::AddOrderedInstruction( const spv_parsed_instruction_t* inst) { ordered_instructions_.emplace_back(inst); @@ -875,9 +903,12 @@ uint32_t ValidationState_t::GetComponentType(uint32_t id) const { case spv::Op::OpTypeFloat: case spv::Op::OpTypeInt: case spv::Op::OpTypeBool: + case spv::Op::OpTypePointer: + case spv::Op::OpTypeUntypedPointerKHR: return id; case spv::Op::OpTypeArray: + case spv::Op::OpTypeRuntimeArray: return inst->word(2); case spv::Op::OpTypeVector: @@ -939,11 +970,20 @@ uint32_t ValidationState_t::GetBitWidth(uint32_t id) const { const Instruction* inst = FindDef(component_type_id); assert(inst); - if (inst->opcode() == spv::Op::OpTypeFloat || - inst->opcode() == spv::Op::OpTypeInt) - return inst->word(2); - - if (inst->opcode() == spv::Op::OpTypeBool) return 1; + switch (inst->opcode()) { + case spv::Op::OpTypeFloat: + case spv::Op::OpTypeInt: + return inst->word(2); + case spv::Op::OpTypeBool: + return 1; + case spv::Op::OpTypePointer: + case spv::Op::OpTypeUntypedPointerKHR: + assert(inst->GetOperandAs(1) == + spv::StorageClass::PhysicalStorageBuffer); + return 64; // all pointers to another PSB is 64-bit + default: + break; + } assert(0); return 0; @@ -958,6 +998,23 @@ bool ValidationState_t::IsScalarType(uint32_t id) const { return IsIntScalarType(id) || IsFloatScalarType(id) || IsBoolScalarType(id); } +bool ValidationState_t::IsArrayType(uint32_t id, uint64_t length) const { + const Instruction* inst = FindDef(id); + if (!inst || inst->opcode() != spv::Op::OpTypeArray) { + return false; + } + if (length != 0) { + const auto len_id = inst->GetOperandAs(2); + const auto len = FindDef(len_id); + uint64_t len_value = 0; + if (!len || !spvOpcodeIsConstant(len->opcode()) || + (EvalConstantValUint64(len_id, &len_value) && (length != len_value))) { + return false; + } + } + return true; +} + bool ValidationState_t::IsBfloat16ScalarType(uint32_t id) const { const Instruction* inst = FindDef(id); if (inst && inst->opcode() == spv::Op::OpTypeFloat) { @@ -984,6 +1041,24 @@ bool ValidationState_t::IsBfloat16VectorType(uint32_t id) const { return false; } +bool ValidationState_t::IsBfloat16CoopMatType(uint32_t id) const { + const Instruction* inst = FindDef(id); + if (!inst) { + return false; + } + + if (inst->opcode() == spv::Op::OpTypeCooperativeMatrixKHR) { + return IsBfloat16ScalarType(inst->word(2)); + } + + return false; +} + +bool ValidationState_t::IsBfloat16Type(uint32_t id) const { + return IsBfloat16ScalarType(id) || IsBfloat16VectorType(id) || + IsBfloat16CoopMatType(id); +} + bool ValidationState_t::IsFP8ScalarType(uint32_t id) const { const Instruction* inst = FindDef(id); if (inst && inst->opcode() == spv::Op::OpTypeFloat) { @@ -1011,28 +1086,32 @@ bool ValidationState_t::IsFP8VectorType(uint32_t id) const { return false; } -bool ValidationState_t::IsFP8ScalarOrVectorType(uint32_t id) const { - return IsFP8ScalarType(id) || IsFP8VectorType(id); -} - -bool ValidationState_t::IsFloatScalarType(uint32_t id) const { - const Instruction* inst = FindDef(id); - return inst && inst->opcode() == spv::Op::OpTypeFloat; -} - -bool ValidationState_t::IsFloatArrayType(uint32_t id) const { +bool ValidationState_t::IsFP8CoopMatType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { return false; } - if (inst->opcode() == spv::Op::OpTypeArray) { - return IsFloatScalarType(GetComponentType(id)); + if (inst->opcode() == spv::Op::OpTypeCooperativeMatrixKHR) { + return IsFP8ScalarType(inst->word(2)); } return false; } +bool ValidationState_t::IsFP8Type(uint32_t id) const { + return IsFP8ScalarType(id) || IsFP8VectorType(id) || IsFP8CoopMatType(id); +} + +bool ValidationState_t::IsFloatScalarType(uint32_t id) const { + const Instruction* inst = FindDef(id); + return inst && inst->opcode() == spv::Op::OpTypeFloat; +} + +bool ValidationState_t::IsFloatArrayType(uint32_t id) const { + return IsArrayType(id) && IsFloatScalarType(GetComponentType(id)); +} + bool ValidationState_t::IsFloatVectorType(uint32_t id) const { const Instruction* inst = FindDef(id); if (!inst) { @@ -1077,36 +1156,27 @@ bool ValidationState_t::IsFloatScalarOrVectorType(uint32_t id) const { return false; } -bool ValidationState_t::IsIntScalarType(uint32_t id) const { - const Instruction* inst = FindDef(id); - return inst && inst->opcode() == spv::Op::OpTypeInt; -} - -bool ValidationState_t::IsIntArrayType(uint32_t id, uint64_t length) const { +bool ValidationState_t::IsIntScalarType(uint32_t id, uint32_t width) const { const Instruction* inst = FindDef(id); - if (!inst) { + bool is_int = inst && inst->opcode() == spv::Op::OpTypeInt; + if (!is_int) { return false; } - - if (inst->opcode() != spv::Op::OpTypeArray) { - return false; - } - - if (!IsIntScalarType(GetComponentType(id))) { + if ((width != 0) && (width != inst->word(2))) { return false; } + return true; +} - if (length != 0) { - const auto len_id = inst->GetOperandAs(2); - const auto len = FindDef(len_id); - uint64_t len_value = 0; - if (!len || !spvOpcodeIsConstant(len->opcode()) || - (EvalConstantValUint64(len_id, &len_value) && (length != len_value))) { - return false; - } - } +bool ValidationState_t::IsIntScalarTypeWithSignedness( + uint32_t id, uint32_t signedness) const { + const Instruction* inst = FindDef(id); + return inst && inst->opcode() == spv::Op::OpTypeInt && + inst->word(3) == signedness; +} - return true; +bool ValidationState_t::IsIntArrayType(uint32_t id, uint64_t length) const { + return IsArrayType(id, length) && IsIntScalarType(GetComponentType(id)); } bool ValidationState_t::IsIntVectorType(uint32_t id) const { @@ -1140,8 +1210,7 @@ bool ValidationState_t::IsIntScalarOrVectorType(uint32_t id) const { } bool ValidationState_t::IsUnsignedIntScalarType(uint32_t id) const { - const Instruction* inst = FindDef(id); - return inst && inst->opcode() == spv::Op::OpTypeInt && inst->word(3) == 0; + return IsIntScalarTypeWithSignedness(id, 0); } bool ValidationState_t::IsUnsignedIntVectorType(uint32_t id) const { @@ -1312,6 +1381,28 @@ bool ValidationState_t::GetPointerTypeInfo( return true; } +uint32_t ValidationState_t::GetLargestScalarType(uint32_t id) const { + const Instruction* inst = FindDef(id); + + switch (inst->opcode()) { + case spv::Op::OpTypeStruct: { + uint32_t size = 0; + for (uint32_t i = 1; i < inst->operands().size(); ++i) { + const uint32_t member_size = + GetLargestScalarType(inst->GetOperandAs(i)); + size = std::max(size, member_size); + } + return size; + } + case spv::Op::OpTypeArray: + return GetLargestScalarType(inst->GetOperandAs(1)); + case spv::Op::OpTypeVector: + return GetLargestScalarType(inst->GetOperandAs(1)); + default: + return GetBitWidth(id) / 8; + } +} + bool ValidationState_t::IsAccelerationStructureType(uint32_t id) const { const Instruction* inst = FindDef(id); return inst && inst->opcode() == spv::Op::OpTypeAccelerationStructureKHR; @@ -1411,6 +1502,11 @@ bool ValidationState_t::IsUnsignedIntCooperativeVectorNVType( return IsUnsignedIntScalarType(FindDef(id)->word(2)); } +bool ValidationState_t::IsTensorType(uint32_t id) const { + const Instruction* inst = FindDef(id); + return inst && inst->opcode() == spv::Op::OpTypeTensorARM; +} + spv_result_t ValidationState_t::CooperativeMatrixShapesMatch( const Instruction* inst, uint32_t result_type_id, uint32_t m2, bool is_conversion, bool swap_row_col) { @@ -1445,8 +1541,7 @@ spv_result_t ValidationState_t::CooperativeMatrixShapesMatch( if (m1_is_const_int32 && m2_is_const_int32 && m1_value != m2_value) { return diag(SPV_ERROR_INVALID_DATA, inst) - << "Expected scopes of Matrix and Result Type to be " - << "identical"; + << "Expected scopes of Matrix and Result Type to be " << "identical"; } std::tie(m1_is_int32, m1_is_const_int32, m1_value) = @@ -1949,6 +2044,14 @@ bool ValidationState_t::IsValidStorageClass( return true; } +std::string ValidationState_t::MissingFeature(const std::string& feature, + const std::string& cmdline, + bool hint) const { + return "\nThis is " + (hint ? std::string("may be ") : "") + + "allowed if you enable the " + feature + " (or use the " + cmdline + + " command line flag)"; +} + #define VUID_WRAP(vuid) "[" #vuid "] " // Currently no 2 VUID share the same id, so no need for |reference| @@ -2211,6 +2314,8 @@ std::string ValidationState_t::VkErrorID(uint32_t id, return VUID_WRAP(VUID-Position-Position-04321); case 4330: return VUID_WRAP(VUID-PrimitiveId-PrimitiveId-04330); + case 4333: + return VUID_WRAP(VUID-PrimitiveId-Fragment-04333); case 4334: return VUID_WRAP(VUID-PrimitiveId-PrimitiveId-04334); case 4336: @@ -2399,10 +2504,6 @@ std::string ValidationState_t::VkErrorID(uint32_t id, return VUID_WRAP(VUID-StandaloneSpirv-None-04644); case 4645: return VUID_WRAP(VUID-StandaloneSpirv-None-04645); - case 10609: - return VUID_WRAP(VUID-StandaloneSpirv-OpControlBarrier-10609); - case 4650: - return VUID_WRAP(VUID-StandaloneSpirv-OpControlBarrier-04650); case 4651: return VUID_WRAP(VUID-StandaloneSpirv-OpVariable-04651); case 4652: @@ -2469,14 +2570,6 @@ std::string ValidationState_t::VkErrorID(uint32_t id, return VUID_WRAP(VUID-StandaloneSpirv-PhysicalStorageBuffer64-04710); case 4711: return VUID_WRAP(VUID-StandaloneSpirv-OpTypeForwardPointer-04711); - case 4730: - return VUID_WRAP(VUID-StandaloneSpirv-OpAtomicStore-04730); - case 4731: - return VUID_WRAP(VUID-StandaloneSpirv-OpAtomicLoad-04731); - case 4732: - return VUID_WRAP(VUID-StandaloneSpirv-OpMemoryBarrier-04732); - case 4733: - return VUID_WRAP(VUID-StandaloneSpirv-OpMemoryBarrier-04733); case 4734: return VUID_WRAP(VUID-StandaloneSpirv-OpVariable-04734); case 4744: @@ -2485,8 +2578,6 @@ std::string ValidationState_t::VkErrorID(uint32_t id, return VUID_WRAP(VUID-StandaloneSpirv-OpImage-04777); case 4780: return VUID_WRAP(VUID-StandaloneSpirv-Result-04780); - case 4781: - return VUID_WRAP(VUID-StandaloneSpirv-Base-04781); case 4915: return VUID_WRAP(VUID-StandaloneSpirv-Location-04915); case 4916: @@ -2511,6 +2602,8 @@ std::string ValidationState_t::VkErrorID(uint32_t id, return VUID_WRAP(VUID-StandaloneSpirv-Flat-06202); case 6214: return VUID_WRAP(VUID-StandaloneSpirv-OpTypeImage-06214); + case 6314: + return VUID_WRAP(VUID-StandaloneSpirv-PhysicalStorageBuffer64-06314); case 6491: return VUID_WRAP(VUID-StandaloneSpirv-DescriptorSet-06491); case 6671: @@ -2621,6 +2714,10 @@ std::string ValidationState_t::VkErrorID(uint32_t id, return VUID_WRAP(VUID-StandaloneSpirv-OpEntryPoint-09658); case 9659: return VUID_WRAP(VUID-StandaloneSpirv-OpEntryPoint-09659); + case 10151: + return VUID_WRAP(VUID-StandaloneSpirv-DerivativeGroupQuadsKHR-10151); + case 10152: + return VUID_WRAP(VUID-StandaloneSpirv-DerivativeGroupLinearKHR-10152); case 10213: // This use to be a standalone, but maintenance8 will set allow_offset_texture_operand now return VUID_WRAP(VUID-RuntimeSpirv-Offset-10213); @@ -2628,10 +2725,71 @@ std::string ValidationState_t::VkErrorID(uint32_t id, return VUID_WRAP(VUID-StandaloneSpirv-OpTypeFloat-10370); case 10583: return VUID_WRAP(VUID-StandaloneSpirv-Component-10583); + case 10589: + return VUID_WRAP(VUID-CullPrimitiveEXT-CullPrimitiveEXT-10589); + case 10590: + return VUID_WRAP(VUID-CullPrimitiveEXT-CullPrimitiveEXT-10590); + case 10591: + return VUID_WRAP(VUID-CullPrimitiveEXT-CullPrimitiveEXT-10591); + case 10592: + return VUID_WRAP(VUID-Layer-Layer-10592); + case 10593: + return VUID_WRAP(VUID-Layer-Layer-10593); + case 10594: + return VUID_WRAP(VUID-Layer-Layer-10594); + case 10598: + return VUID_WRAP(VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-10598); + case 10599: + return VUID_WRAP(VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-10599); + case 10600: + return VUID_WRAP(VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-10600); + case 10601: + return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-10601); + case 10602: + return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-10602); + case 10603: + return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-10603); case 10684: return VUID_WRAP(VUID-StandaloneSpirv-None-10684); case 10685: return VUID_WRAP(VUID-StandaloneSpirv-None-10685); + case 10824: + // This use to be a standalone, but maintenance9 will set allow_vulkan_32_bit_bitwise now + return VUID_WRAP(VUID-RuntimeSpirv-None-10824); + case 10865: + return VUID_WRAP(VUID-StandaloneSpirv-MemorySemantics-10865); + case 10866: + return VUID_WRAP(VUID-StandaloneSpirv-MemorySemantics-10866); + case 10867: + return VUID_WRAP(VUID-StandaloneSpirv-MemorySemantics-10867); + case 10868: + return VUID_WRAP(VUID-StandaloneSpirv-MemorySemantics-10868); + case 10869: + return VUID_WRAP(VUID-StandaloneSpirv-MemorySemantics-10869); + case 10870: + return VUID_WRAP(VUID-StandaloneSpirv-MemorySemantics-10870); + case 10871: + return VUID_WRAP(VUID-StandaloneSpirv-MemorySemantics-10871); + case 10872: + return VUID_WRAP(VUID-StandaloneSpirv-MemorySemantics-10872); + case 10873: + return VUID_WRAP(VUID-StandaloneSpirv-MemorySemantics-10873); + case 10874: + return VUID_WRAP(VUID-StandaloneSpirv-MemorySemantics-10874); + case 10875: + return VUID_WRAP(VUID-StandaloneSpirv-UnequalMemorySemantics-10875); + case 10876: + return VUID_WRAP(VUID-StandaloneSpirv-UnequalMemorySemantics-10876); + case 10877: + return VUID_WRAP(VUID-StandaloneSpirv-UnequalMemorySemantics-10877); + case 10878: + return VUID_WRAP(VUID-StandaloneSpirv-UnequalMemorySemantics-10878); + case 10879: + return VUID_WRAP(VUID-StandaloneSpirv-UnequalMemorySemantics-10879); + case 10880: + return VUID_WRAP(VUID-StandaloneSpirv-TessLevelInner-10880); + case 11167: + return VUID_WRAP(VUID-StandaloneSpirv-OpUntypedVariableKHR-11167); default: return ""; // unknown id } diff --git a/libs/bgfx/3rdparty/spirv-tools/source/val/validation_state.h b/libs/bgfx/3rdparty/spirv-tools/source/val/validation_state.h index 366fb84..7305f26 100644 --- a/libs/bgfx/3rdparty/spirv-tools/source/val/validation_state.h +++ b/libs/bgfx/3rdparty/spirv-tools/source/val/validation_state.h @@ -50,6 +50,7 @@ enum ModuleLayoutSection { kLayoutExtInstImport, /// < Section 2.4 #3 kLayoutMemoryModel, /// < Section 2.4 #4 kLayoutSamplerImageAddressMode, /// < Section 2.4 #5 + /// (SPV_NV_bindless_texture) kLayoutEntryPoint, /// < Section 2.4 #6 kLayoutExecutionMode, /// < Section 2.4 #7 kLayoutDebug1, /// < Section 2.4 #8 > 1 @@ -58,7 +59,18 @@ enum ModuleLayoutSection { kLayoutAnnotations, /// < Section 2.4 #9 kLayoutTypes, /// < Section 2.4 #10 kLayoutFunctionDeclarations, /// < Section 2.4 #11 - kLayoutFunctionDefinitions /// < Section 2.4 #12 + kLayoutFunctionDefinitions, /// < Section 2.4 #12 + kLayoutGraphDefinitions /// < Section 2.4 #13 (SPV_ARM_graph) +}; + +/// This enum represents the regions of a graph definition. The relative +/// ordering of the values is significant. +enum GraphDefinitionRegion { + kGraphDefinitionOutside, + kGraphDefinitionBegin, + kGraphDefinitionInputs, + kGraphDefinitionBody, + kGraphDefinitionOutputs, }; /// This class manages the state of the SPIR-V validation as it is being parsed. @@ -213,6 +225,9 @@ class ValidationState_t { /// instruction bool in_block() const; + /// Returns the region of a graph definition we are in. + GraphDefinitionRegion graph_definition_region() const; + struct EntryPointDescription { std::string name; std::vector interfaces; @@ -313,6 +328,16 @@ class ValidationState_t { /// ComputeFunctionToEntryPointMapping. void ComputeRecursiveEntryPoints(); + /// Registers |id| as a graph entry point. + void RegisterGraphEntryPoint(const uint32_t id) { + graph_entry_points_.push_back(id); + } + + /// Returns a list of graph entry point graph ids + const std::vector& graph_entry_points() const { + return graph_entry_points_; + } + /// Returns all the entry points that can call |func|. const std::vector& FunctionEntryPoints(uint32_t func) const; @@ -350,6 +375,9 @@ class ValidationState_t { /// Register a function end instruction spv_result_t RegisterFunctionEnd(); + /// Sets the region of a graph definition we're in. + void SetGraphDefinitionRegion(GraphDefinitionRegion region); + /// Returns true if the capability is enabled in the module. bool HasCapability(spv::Capability cap) const { return module_capabilities_.contains(cap); @@ -632,23 +660,26 @@ class ValidationState_t { bool GetStructMemberTypes(uint32_t struct_type_id, std::vector* member_types) const; - // Returns true iff |id| is a type corresponding to the name of the function. + // Returns true if |id| is a type corresponding to the name of the function. // Only works for types not for objects. bool IsVoidType(uint32_t id) const; bool IsScalarType(uint32_t id) const; bool IsBfloat16ScalarType(uint32_t id) const; bool IsBfloat16VectorType(uint32_t id) const; + bool IsBfloat16CoopMatType(uint32_t id) const; + bool IsBfloat16Type(uint32_t id) const; bool IsFP8ScalarType(uint32_t id) const; bool IsFP8VectorType(uint32_t id) const; - bool IsFP8ScalarOrVectorType(uint32_t id) const; + bool IsFP8CoopMatType(uint32_t id) const; + bool IsFP8Type(uint32_t id) const; bool IsFloatScalarType(uint32_t id) const; bool IsFloatArrayType(uint32_t id) const; bool IsFloatVectorType(uint32_t id) const; bool IsFloat16Vector2Or4Type(uint32_t id) const; bool IsFloatScalarOrVectorType(uint32_t id) const; bool IsFloatMatrixType(uint32_t id) const; - bool IsIntScalarType(uint32_t id) const; - bool IsIntArrayType(uint32_t id, uint64_t length = 0) const; + bool IsIntScalarType(uint32_t id, uint32_t width = 0) const; + bool IsIntScalarTypeWithSignedness(uint32_t id, uint32_t signedness) const; bool IsIntVectorType(uint32_t id) const; bool IsIntScalarOrVectorType(uint32_t id) const; bool IsUnsignedIntScalarType(uint32_t id) const; @@ -675,6 +706,36 @@ class ValidationState_t { bool IsFloatCooperativeVectorNVType(uint32_t id) const; bool IsIntCooperativeVectorNVType(uint32_t id) const; bool IsUnsignedIntCooperativeVectorNVType(uint32_t id) const; + bool IsTensorType(uint32_t id) const; + // When |length| is not 0, return true only if the array length is equal to + // |length| and the array length is not defined by a specialization constant. + bool IsArrayType(uint32_t id, uint64_t length = 0) const; + bool IsIntArrayType(uint32_t id, uint64_t length = 0) const; + template + bool IsIntNOrFP32OrFP16(unsigned int type_id) { + return this->ContainsType( + type_id, + [](const Instruction* inst) { + if (inst->opcode() == spv::Op::OpTypeInt) { + return inst->GetOperandAs(1) == N; + } else if (inst->opcode() == spv::Op::OpTypeFloat) { + if (inst->operands().size() > 2) { + // Not IEEE + return false; + } + auto width = inst->GetOperandAs(1); + return width == 32 || width == 16; + } + return false; + }, + /* traverse_all_types = */ false); + } + + // Will walk the type to find the largest scalar value size. + // Returns value is in bytes. + // This is designed to pass in the %type from a PSB pointer + // %ptr = OpTypePointer PhysicalStorageBuffer %type + uint32_t GetLargestScalarType(uint32_t id) const; // Returns true if |id| is a type id that contains |type| (or integer or // floating point type) of |width| bits. @@ -715,6 +776,17 @@ class ValidationState_t { bool GetPointerTypeInfo(uint32_t id, uint32_t* data_type, spv::StorageClass* storage_class) const; + // Returns the value assocated with id via 'value' if id is an OpConstant + template + bool GetConstantValueAs(unsigned int id, T& value) { + const auto inst = FindDef(id); + uint64_t ui64_val = 0u; + bool status = (inst && spvOpcodeIsConstant(inst->opcode()) && + EvalConstantValUint64(id, &ui64_val)); + if (status == true) value = static_cast(ui64_val); + return status; + } + // Is the ID the type of a pointer to a uniform block: Block-decorated struct // in uniform storage class? The result is only valid after internal method // CheckDecorationsOfBuffers has been called. @@ -772,6 +844,16 @@ class ValidationState_t { pointer_to_storage_image_.insert(type_id); } + // Is the ID the type of a pointer to a tensor? That is, the pointee + // type is a tensor type. + bool IsPointerToTensor(uint32_t type_id) const { + return pointer_to_tensor_.find(type_id) != pointer_to_tensor_.cend(); + } + // Save the ID of a pointer to a tensor. + void RegisterPointerToTensor(uint32_t type_id) { + pointer_to_tensor_.insert(type_id); + } + // Tries to evaluate a any scalar integer OpConstant as uint64. // OpConstantNull is defined as zero for scalar int (will return true) // OpSpecConstant* return false since their values cannot be relied upon @@ -844,6 +926,12 @@ class ValidationState_t { // Validates the storage class for the target environment. bool IsValidStorageClass(spv::StorageClass storage_class) const; + // Helps formulate a mesesage to user that setting one of the validator + // options might make their SPIR-V actually valid The |hint| option is because + // some checks are intertwined with each other, so hard to give confirmation + std::string MissingFeature(const std::string& feature, + const std::string& cmdline, bool hint) const; + // Takes a Vulkan Valid Usage ID (VUID) as |id| and optional |reference| and // will return a non-empty string only if ID is known and targeting Vulkan. // VUIDs are found in the Vulkan-Docs repo in the form "[[VUID-ref-ref-id]]" @@ -939,6 +1027,9 @@ class ValidationState_t { /// graph that recurses. std::set recursive_entry_points_; + /// IDs that are graph entry points, ie, arguments to OpGraphEntryPointARM. + std::vector graph_entry_points_; + /// Functions IDs that are target of OpFunctionCall. std::unordered_set function_call_targets_; @@ -981,9 +1072,13 @@ class ValidationState_t { /// bit width of sampler/image type variables. Valid values are 32 and 64 uint32_t sampler_image_addressing_mode_; - /// NOTE: See correspoding getter functions + /// NOTE: See corresponding getter functions bool in_function_; + /// Where in a graph definition we are + /// NOTE: See corresponding getter/setter functions + GraphDefinitionRegion graph_definition_region_; + /// The state of optional features. These are determined by capabilities /// declared by the module and the environment. Feature features_; @@ -1030,6 +1125,9 @@ class ValidationState_t { // The IDs of types of pointers to storage images. This is populated in the // TypePass. std::unordered_set pointer_to_storage_image_; + // The IDs of types of pointers to tensors. This is populated in the + // TypePass. + std::unordered_set pointer_to_tensor_; /// Maps ids to friendly names. std::unique_ptr friendly_mapper_; diff --git a/libs/bgfx/examples/common/args.h b/libs/bgfx/examples/common/args.h new file mode 100644 index 0000000..c417575 --- /dev/null +++ b/libs/bgfx/examples/common/args.h @@ -0,0 +1,66 @@ +/* + * Copyright 2011-2025 Branimir Karadzic. All rights reserved. + * License: http://www.opensource.org/licenses/BSD-2-Clause + */ + +#include +#include + +/// +struct Args +{ + Args(int _argc, const char* const* _argv) + : m_type(bgfx::RendererType::Count) + , m_pciId(BGFX_PCI_ID_NONE) + { + bx::CommandLine cmdLine(_argc, (const char**)_argv); + + if (cmdLine.hasArg("gl") ) + { + m_type = bgfx::RendererType::OpenGL; + } + else if (cmdLine.hasArg("vk") ) + { + m_type = bgfx::RendererType::Vulkan; + } + else if (cmdLine.hasArg("noop") ) + { + m_type = bgfx::RendererType::Noop; + } + else if (cmdLine.hasArg("d3d11") ) + { + m_type = bgfx::RendererType::Direct3D11; + } + else if (cmdLine.hasArg("d3d12") ) + { + m_type = bgfx::RendererType::Direct3D12; + } + else if (BX_ENABLED(BX_PLATFORM_OSX) ) + { + if (cmdLine.hasArg("mtl") ) + { + m_type = bgfx::RendererType::Metal; + } + } + + if (cmdLine.hasArg("amd") ) + { + m_pciId = BGFX_PCI_ID_AMD; + } + else if (cmdLine.hasArg("nvidia") ) + { + m_pciId = BGFX_PCI_ID_NVIDIA; + } + else if (cmdLine.hasArg("intel") ) + { + m_pciId = BGFX_PCI_ID_INTEL; + } + else if (cmdLine.hasArg("sw") ) + { + m_pciId = BGFX_PCI_ID_SOFTWARE_RASTERIZER; + } + } + + bgfx::RendererType::Enum m_type; + uint16_t m_pciId; +}; diff --git a/libs/bgfx/examples/common/bgfx_utils.h b/libs/bgfx/examples/common/bgfx_utils.h index 2e9dc72..fb46843 100644 --- a/libs/bgfx/examples/common/bgfx_utils.h +++ b/libs/bgfx/examples/common/bgfx_utils.h @@ -16,6 +16,7 @@ #include namespace stl = tinystl; +#include "args.h" /// void* load(const bx::FilePath& _filePath, uint32_t* _size = NULL); @@ -152,13 +153,4 @@ bx::StringView getName(bgfx::RendererType::Enum _type); /// Name to bgfx::RendererType::Enum. bgfx::RendererType::Enum getType(const bx::StringView& _name); -/// -struct Args -{ - Args(int _argc, const char* const* _argv); - - bgfx::RendererType::Enum m_type; - uint16_t m_pciId; -}; - #endif // BGFX_UTILS_H_HEADER_GUARD diff --git a/libs/bgfx/include/bgfx/bgfx.h b/libs/bgfx/include/bgfx/bgfx.h index 01e1b54..7d833e7 100644 --- a/libs/bgfx/include/bgfx/bgfx.h +++ b/libs/bgfx/include/bgfx/bgfx.h @@ -170,6 +170,10 @@ namespace bgfx ETC2, //!< ETC2 RGB8 ETC2A, //!< ETC2 RGBA8 ETC2A1, //!< ETC2 RGB8A1 + EACR11, //!< EAC R11 UNORM + EACR11S, //!< EAC R11 SNORM + EACRG11, //!< EAC RG11 UNORM + EACRG11S, //!< EAC RG11 SNORM PTC12, //!< PVRTC1 RGB 2BPP PTC14, //!< PVRTC1 RGB 4BPP PTC12A, //!< PVRTC1 RGBA 2BPP @@ -284,6 +288,23 @@ namespace bgfx }; }; + /// Uniform frequency enum. + /// + /// @attention C99's equivalent binding is `bgfx_bgfx_uniform_freq_t`. + /// + struct UniformFreq + { + /// Uniform frequency: + enum Enum + { + Draw, //!< Changing per draw call. + View, //!< Changing per view. + Frame, //!< Changing per frame. + + Count + }; + }; + /// Backbuffer ratio enum. /// /// @attention C99's equivalent binding is `bgfx_backbuffer_ratio_t`. @@ -403,23 +424,43 @@ namespace bgfx }; }; + /// Shading Rate. + /// + /// @attention C99's equivalent binding is `bgfx_bgfx_shading_rate_t`. + /// + struct ShadingRate + { + /// Shading rate: + enum Enum + { + Rate1x1, + Rate1x2, + Rate2x1, + Rate2x2, + Rate2x4, + Rate4x2, + Rate4x4, + + Count + }; + }; + /// Native window handle type. /// /// @attention C99's equivalent binding is `bgfx_native_window_handle_type_t`. /// - struct NativeWindowHandleType { - enum Enum - { - Default = 0, //!< Platform default handle type (X11 on Linux). - Wayland, //!< Wayland. + enum Enum + { + Default = 0, //!< Platform default handle type (X11 on Linux). + Wayland, //!< Wayland. - Count - }; + Count + }; }; - static const uint16_t kInvalidHandle = UINT16_MAX; + constexpr uint16_t kInvalidHandle = UINT16_MAX; BGFX_HANDLE(DynamicIndexBufferHandle) BGFX_HANDLE(DynamicVertexBufferHandle) @@ -658,13 +699,14 @@ namespace bgfx { Resolution(); - TextureFormat::Enum format; //!< Backbuffer format. - uint32_t width; //!< Backbuffer width. - uint32_t height; //!< Backbuffer height. - uint32_t reset; //!< Reset parameters. - uint8_t numBackBuffers; //!< Number of back buffers. - uint8_t maxFrameLatency; //!< Maximum frame latency. - uint8_t debugTextScale; //!< Scale factor for debug text. + TextureFormat::Enum formatColor; //!< Backbuffer color format. + TextureFormat::Enum formatDepthStencil; //!< Backbuffer depth/stencil format. + uint32_t width; //!< Backbuffer width. + uint32_t height; //!< Backbuffer height. + uint32_t reset; //!< Reset parameters. + uint8_t numBackBuffers; //!< Number of back buffers. + uint8_t maxFrameLatency; //!< Maximum frame latency. + uint8_t debugTextScale; //!< Scale factor for debug text. }; /// Initialization parameters used by `bgfx::init`. @@ -714,10 +756,11 @@ namespace bgfx { Limits(); - uint16_t maxEncoders; //!< Maximum number of encoder threads. - uint32_t minResourceCbSize; //!< Minimum resource command buffer size. - uint32_t transientVbSize; //!< Maximum transient vertex buffer size. - uint32_t transientIbSize; //!< Maximum transient index buffer size. + uint16_t maxEncoders; //!< Maximum number of encoder threads. + uint32_t minResourceCbSize; //!< Minimum resource command buffer size. + uint32_t maxTransientVbSize; //!< Maximum transient vertex buffer size. + uint32_t maxTransientIbSize; //!< Maximum transient index buffer size. + uint32_t minUniformBufferSize; //!< Mimimum uniform buffer size. }; Limits limits; //!< Configurable runtime limits. @@ -816,8 +859,9 @@ namespace bgfx uint32_t maxOcclusionQueries; //!< Maximum number of occlusion query handles. uint32_t maxEncoders; //!< Maximum number of encoder threads. uint32_t minResourceCbSize; //!< Minimum resource command buffer size. - uint32_t transientVbSize; //!< Maximum transient vertex buffer size. - uint32_t transientIbSize; //!< Maximum transient index buffer size. + uint32_t maxTransientVbSize; //!< Maximum transient vertex buffer size. + uint32_t maxTransientIbSize; //!< Maximum transient index buffer size. + uint32_t minUniformBufferSize; //!< Mimimum uniform buffer size. }; Limits limits; //!< Renderer runtime limits. @@ -3256,6 +3300,48 @@ namespace bgfx , uint16_t _num = 1 ); + /// Create shader uniform parameter. + /// + /// @param[in] _name Uniform name in shader. + /// @param[in] _freq Uniform change frequency (See: `bgfx::UniformFreq`). + /// @param[in] _type Type of uniform (See: `bgfx::UniformType`). + /// @param[in] _num Number of elements in array. + /// + /// @returns Handle to uniform object. + /// + /// @remarks + /// 1. Uniform names are unique. It's valid to call `bgfx::createUniform` + /// multiple times with the same uniform name. The library will always + /// return the same handle, but the handle reference count will be + /// incremented. This means that the same number of `bgfx::destroyUniform` + /// must be called to properly destroy the uniform. + /// 2. Predefined uniforms (declared in `bgfx_shader.sh`): + /// - `u_viewRect vec4(x, y, width, height)` - view rectangle for current + /// view, in pixels. + /// - `u_viewTexel vec4(1.0/width, 1.0/height, undef, undef)` - inverse + /// width and height + /// - `u_view mat4` - view matrix + /// - `u_invView mat4` - inverted view matrix + /// - `u_proj mat4` - projection matrix + /// - `u_invProj mat4` - inverted projection matrix + /// - `u_viewProj mat4` - concatenated view projection matrix + /// - `u_invViewProj mat4` - concatenated inverted view projection matrix + /// - `u_model mat4[BGFX_CONFIG_MAX_BONES]` - array of model matrices. + /// - `u_modelView mat4` - concatenated model view matrix, only first + /// model matrix from array is used. + /// - `u_invModelView mat4` - inverted concatenated model view matrix. + /// - `u_modelViewProj mat4` - concatenated model view projection matrix. + /// - `u_alphaRef float` - alpha reference value for alpha test. + /// + /// @attention C99's equivalent binding is `bgfx_create_uniform_with_freq`. + /// + UniformHandle createUniform( + const char* _name + , UniformFreq::Enum _freq + , UniformType::Enum _type + , uint16_t _num = 1 + ); + /// Retrieve uniform info. /// /// @param[in] _handle Handle to uniform object. @@ -3544,6 +3630,19 @@ namespace bgfx , const ViewId* _remap = NULL ); + /// Set view shading rate. + /// + /// @param[in] _id View id. + /// @param[in] _shadingRate Shading rate. + /// + /// @attention Availability depends on: `BGFX_CAPS_VARIABLE_RATE_SHADING`. + /// @attention C99's equivalent binding is `bgfx_set_view_shading_rate`. + /// + void setViewShadingRate( + ViewId _id + , ShadingRate::Enum _shadingRate = ShadingRate::Rate1x1 + ); + /// Reset all view settings to default. /// /// @param[in] _id View id. @@ -3704,6 +3803,40 @@ namespace bgfx , uint16_t _num = 1 ); + /// Set shader uniform parameter for view. + /// + /// @param[in] _id View id. + /// @param[in] _handle Uniform. + /// @param[in] _value Pointer to uniform data. + /// @param[in] _num Number of elements. Passing `UINT16_MAX` will + /// use the _num passed on uniform creation. + /// + /// @attention Uniform must be created with `bgfx::UniformFreq::View` argument. + /// @attention C99's equivalent binding is `bgfx_set_view_uniform`. + /// + void setViewUniform( + ViewId _id + , UniformHandle _handle + , const void* _value + , uint16_t _num = 1 + ); + + /// Set shader uniform parameter for frame. + /// + /// @param[in] _handle Uniform. + /// @param[in] _value Pointer to uniform data. + /// @param[in] _num Number of elements. Passing `UINT16_MAX` will + /// use the _num passed on uniform creation. + /// + /// @attention Uniform must be created with `bgfx::UniformFreq::View` argument. + /// @attention C99's equivalent binding is `bgfx_set_frame_uniform`. + /// + void setFrameUniform( + UniformHandle _handle + , const void* _value + , uint16_t _num = 1 + ); + /// Set index buffer for draw primitive. /// /// @param[in] _handle Index buffer. diff --git a/libs/bgfx/include/bgfx/c99/bgfx.h b/libs/bgfx/include/bgfx/c99/bgfx.h index 1033ee7..d485ce3 100644 --- a/libs/bgfx/include/bgfx/c99/bgfx.h +++ b/libs/bgfx/include/bgfx/c99/bgfx.h @@ -182,91 +182,95 @@ typedef enum bgfx_texture_format BGFX_TEXTURE_FORMAT_ETC2, /** ( 8) ETC2 RGB8 */ BGFX_TEXTURE_FORMAT_ETC2A, /** ( 9) ETC2 RGBA8 */ BGFX_TEXTURE_FORMAT_ETC2A1, /** (10) ETC2 RGB8A1 */ - BGFX_TEXTURE_FORMAT_PTC12, /** (11) PVRTC1 RGB 2BPP */ - BGFX_TEXTURE_FORMAT_PTC14, /** (12) PVRTC1 RGB 4BPP */ - BGFX_TEXTURE_FORMAT_PTC12A, /** (13) PVRTC1 RGBA 2BPP */ - BGFX_TEXTURE_FORMAT_PTC14A, /** (14) PVRTC1 RGBA 4BPP */ - BGFX_TEXTURE_FORMAT_PTC22, /** (15) PVRTC2 RGBA 2BPP */ - BGFX_TEXTURE_FORMAT_PTC24, /** (16) PVRTC2 RGBA 4BPP */ - BGFX_TEXTURE_FORMAT_ATC, /** (17) ATC RGB 4BPP */ - BGFX_TEXTURE_FORMAT_ATCE, /** (18) ATCE RGBA 8 BPP explicit alpha */ - BGFX_TEXTURE_FORMAT_ATCI, /** (19) ATCI RGBA 8 BPP interpolated alpha */ - BGFX_TEXTURE_FORMAT_ASTC4X4, /** (20) ASTC 4x4 8.0 BPP */ - BGFX_TEXTURE_FORMAT_ASTC5X4, /** (21) ASTC 5x4 6.40 BPP */ - BGFX_TEXTURE_FORMAT_ASTC5X5, /** (22) ASTC 5x5 5.12 BPP */ - BGFX_TEXTURE_FORMAT_ASTC6X5, /** (23) ASTC 6x5 4.27 BPP */ - BGFX_TEXTURE_FORMAT_ASTC6X6, /** (24) ASTC 6x6 3.56 BPP */ - BGFX_TEXTURE_FORMAT_ASTC8X5, /** (25) ASTC 8x5 3.20 BPP */ - BGFX_TEXTURE_FORMAT_ASTC8X6, /** (26) ASTC 8x6 2.67 BPP */ - BGFX_TEXTURE_FORMAT_ASTC8X8, /** (27) ASTC 8x8 2.00 BPP */ - BGFX_TEXTURE_FORMAT_ASTC10X5, /** (28) ASTC 10x5 2.56 BPP */ - BGFX_TEXTURE_FORMAT_ASTC10X6, /** (29) ASTC 10x6 2.13 BPP */ - BGFX_TEXTURE_FORMAT_ASTC10X8, /** (30) ASTC 10x8 1.60 BPP */ - BGFX_TEXTURE_FORMAT_ASTC10X10, /** (31) ASTC 10x10 1.28 BPP */ - BGFX_TEXTURE_FORMAT_ASTC12X10, /** (32) ASTC 12x10 1.07 BPP */ - BGFX_TEXTURE_FORMAT_ASTC12X12, /** (33) ASTC 12x12 0.89 BPP */ - BGFX_TEXTURE_FORMAT_UNKNOWN, /** (34) Compressed formats above. */ - BGFX_TEXTURE_FORMAT_R1, /** (35) */ - BGFX_TEXTURE_FORMAT_A8, /** (36) */ - BGFX_TEXTURE_FORMAT_R8, /** (37) */ - BGFX_TEXTURE_FORMAT_R8I, /** (38) */ - BGFX_TEXTURE_FORMAT_R8U, /** (39) */ - BGFX_TEXTURE_FORMAT_R8S, /** (40) */ - BGFX_TEXTURE_FORMAT_R16, /** (41) */ - BGFX_TEXTURE_FORMAT_R16I, /** (42) */ - BGFX_TEXTURE_FORMAT_R16U, /** (43) */ - BGFX_TEXTURE_FORMAT_R16F, /** (44) */ - BGFX_TEXTURE_FORMAT_R16S, /** (45) */ - BGFX_TEXTURE_FORMAT_R32I, /** (46) */ - BGFX_TEXTURE_FORMAT_R32U, /** (47) */ - BGFX_TEXTURE_FORMAT_R32F, /** (48) */ - BGFX_TEXTURE_FORMAT_RG8, /** (49) */ - BGFX_TEXTURE_FORMAT_RG8I, /** (50) */ - BGFX_TEXTURE_FORMAT_RG8U, /** (51) */ - BGFX_TEXTURE_FORMAT_RG8S, /** (52) */ - BGFX_TEXTURE_FORMAT_RG16, /** (53) */ - BGFX_TEXTURE_FORMAT_RG16I, /** (54) */ - BGFX_TEXTURE_FORMAT_RG16U, /** (55) */ - BGFX_TEXTURE_FORMAT_RG16F, /** (56) */ - BGFX_TEXTURE_FORMAT_RG16S, /** (57) */ - BGFX_TEXTURE_FORMAT_RG32I, /** (58) */ - BGFX_TEXTURE_FORMAT_RG32U, /** (59) */ - BGFX_TEXTURE_FORMAT_RG32F, /** (60) */ - BGFX_TEXTURE_FORMAT_RGB8, /** (61) */ - BGFX_TEXTURE_FORMAT_RGB8I, /** (62) */ - BGFX_TEXTURE_FORMAT_RGB8U, /** (63) */ - BGFX_TEXTURE_FORMAT_RGB8S, /** (64) */ - BGFX_TEXTURE_FORMAT_RGB9E5F, /** (65) */ - BGFX_TEXTURE_FORMAT_BGRA8, /** (66) */ - BGFX_TEXTURE_FORMAT_RGBA8, /** (67) */ - BGFX_TEXTURE_FORMAT_RGBA8I, /** (68) */ - BGFX_TEXTURE_FORMAT_RGBA8U, /** (69) */ - BGFX_TEXTURE_FORMAT_RGBA8S, /** (70) */ - BGFX_TEXTURE_FORMAT_RGBA16, /** (71) */ - BGFX_TEXTURE_FORMAT_RGBA16I, /** (72) */ - BGFX_TEXTURE_FORMAT_RGBA16U, /** (73) */ - BGFX_TEXTURE_FORMAT_RGBA16F, /** (74) */ - BGFX_TEXTURE_FORMAT_RGBA16S, /** (75) */ - BGFX_TEXTURE_FORMAT_RGBA32I, /** (76) */ - BGFX_TEXTURE_FORMAT_RGBA32U, /** (77) */ - BGFX_TEXTURE_FORMAT_RGBA32F, /** (78) */ - BGFX_TEXTURE_FORMAT_B5G6R5, /** (79) */ - BGFX_TEXTURE_FORMAT_R5G6B5, /** (80) */ - BGFX_TEXTURE_FORMAT_BGRA4, /** (81) */ - BGFX_TEXTURE_FORMAT_RGBA4, /** (82) */ - BGFX_TEXTURE_FORMAT_BGR5A1, /** (83) */ - BGFX_TEXTURE_FORMAT_RGB5A1, /** (84) */ - BGFX_TEXTURE_FORMAT_RGB10A2, /** (85) */ - BGFX_TEXTURE_FORMAT_RG11B10F, /** (86) */ - BGFX_TEXTURE_FORMAT_UNKNOWNDEPTH, /** (87) Depth formats below. */ - BGFX_TEXTURE_FORMAT_D16, /** (88) */ - BGFX_TEXTURE_FORMAT_D24, /** (89) */ - BGFX_TEXTURE_FORMAT_D24S8, /** (90) */ - BGFX_TEXTURE_FORMAT_D32, /** (91) */ - BGFX_TEXTURE_FORMAT_D16F, /** (92) */ - BGFX_TEXTURE_FORMAT_D24F, /** (93) */ - BGFX_TEXTURE_FORMAT_D32F, /** (94) */ - BGFX_TEXTURE_FORMAT_D0S8, /** (95) */ + BGFX_TEXTURE_FORMAT_EACR11, /** (11) EAC R11 UNORM */ + BGFX_TEXTURE_FORMAT_EACR11S, /** (12) EAC R11 SNORM */ + BGFX_TEXTURE_FORMAT_EACRG11, /** (13) EAC RG11 UNORM */ + BGFX_TEXTURE_FORMAT_EACRG11S, /** (14) EAC RG11 SNORM */ + BGFX_TEXTURE_FORMAT_PTC12, /** (15) PVRTC1 RGB 2BPP */ + BGFX_TEXTURE_FORMAT_PTC14, /** (16) PVRTC1 RGB 4BPP */ + BGFX_TEXTURE_FORMAT_PTC12A, /** (17) PVRTC1 RGBA 2BPP */ + BGFX_TEXTURE_FORMAT_PTC14A, /** (18) PVRTC1 RGBA 4BPP */ + BGFX_TEXTURE_FORMAT_PTC22, /** (19) PVRTC2 RGBA 2BPP */ + BGFX_TEXTURE_FORMAT_PTC24, /** (20) PVRTC2 RGBA 4BPP */ + BGFX_TEXTURE_FORMAT_ATC, /** (21) ATC RGB 4BPP */ + BGFX_TEXTURE_FORMAT_ATCE, /** (22) ATCE RGBA 8 BPP explicit alpha */ + BGFX_TEXTURE_FORMAT_ATCI, /** (23) ATCI RGBA 8 BPP interpolated alpha */ + BGFX_TEXTURE_FORMAT_ASTC4X4, /** (24) ASTC 4x4 8.0 BPP */ + BGFX_TEXTURE_FORMAT_ASTC5X4, /** (25) ASTC 5x4 6.40 BPP */ + BGFX_TEXTURE_FORMAT_ASTC5X5, /** (26) ASTC 5x5 5.12 BPP */ + BGFX_TEXTURE_FORMAT_ASTC6X5, /** (27) ASTC 6x5 4.27 BPP */ + BGFX_TEXTURE_FORMAT_ASTC6X6, /** (28) ASTC 6x6 3.56 BPP */ + BGFX_TEXTURE_FORMAT_ASTC8X5, /** (29) ASTC 8x5 3.20 BPP */ + BGFX_TEXTURE_FORMAT_ASTC8X6, /** (30) ASTC 8x6 2.67 BPP */ + BGFX_TEXTURE_FORMAT_ASTC8X8, /** (31) ASTC 8x8 2.00 BPP */ + BGFX_TEXTURE_FORMAT_ASTC10X5, /** (32) ASTC 10x5 2.56 BPP */ + BGFX_TEXTURE_FORMAT_ASTC10X6, /** (33) ASTC 10x6 2.13 BPP */ + BGFX_TEXTURE_FORMAT_ASTC10X8, /** (34) ASTC 10x8 1.60 BPP */ + BGFX_TEXTURE_FORMAT_ASTC10X10, /** (35) ASTC 10x10 1.28 BPP */ + BGFX_TEXTURE_FORMAT_ASTC12X10, /** (36) ASTC 12x10 1.07 BPP */ + BGFX_TEXTURE_FORMAT_ASTC12X12, /** (37) ASTC 12x12 0.89 BPP */ + BGFX_TEXTURE_FORMAT_UNKNOWN, /** (38) Compressed formats above. */ + BGFX_TEXTURE_FORMAT_R1, /** (39) */ + BGFX_TEXTURE_FORMAT_A8, /** (40) */ + BGFX_TEXTURE_FORMAT_R8, /** (41) */ + BGFX_TEXTURE_FORMAT_R8I, /** (42) */ + BGFX_TEXTURE_FORMAT_R8U, /** (43) */ + BGFX_TEXTURE_FORMAT_R8S, /** (44) */ + BGFX_TEXTURE_FORMAT_R16, /** (45) */ + BGFX_TEXTURE_FORMAT_R16I, /** (46) */ + BGFX_TEXTURE_FORMAT_R16U, /** (47) */ + BGFX_TEXTURE_FORMAT_R16F, /** (48) */ + BGFX_TEXTURE_FORMAT_R16S, /** (49) */ + BGFX_TEXTURE_FORMAT_R32I, /** (50) */ + BGFX_TEXTURE_FORMAT_R32U, /** (51) */ + BGFX_TEXTURE_FORMAT_R32F, /** (52) */ + BGFX_TEXTURE_FORMAT_RG8, /** (53) */ + BGFX_TEXTURE_FORMAT_RG8I, /** (54) */ + BGFX_TEXTURE_FORMAT_RG8U, /** (55) */ + BGFX_TEXTURE_FORMAT_RG8S, /** (56) */ + BGFX_TEXTURE_FORMAT_RG16, /** (57) */ + BGFX_TEXTURE_FORMAT_RG16I, /** (58) */ + BGFX_TEXTURE_FORMAT_RG16U, /** (59) */ + BGFX_TEXTURE_FORMAT_RG16F, /** (60) */ + BGFX_TEXTURE_FORMAT_RG16S, /** (61) */ + BGFX_TEXTURE_FORMAT_RG32I, /** (62) */ + BGFX_TEXTURE_FORMAT_RG32U, /** (63) */ + BGFX_TEXTURE_FORMAT_RG32F, /** (64) */ + BGFX_TEXTURE_FORMAT_RGB8, /** (65) */ + BGFX_TEXTURE_FORMAT_RGB8I, /** (66) */ + BGFX_TEXTURE_FORMAT_RGB8U, /** (67) */ + BGFX_TEXTURE_FORMAT_RGB8S, /** (68) */ + BGFX_TEXTURE_FORMAT_RGB9E5F, /** (69) */ + BGFX_TEXTURE_FORMAT_BGRA8, /** (70) */ + BGFX_TEXTURE_FORMAT_RGBA8, /** (71) */ + BGFX_TEXTURE_FORMAT_RGBA8I, /** (72) */ + BGFX_TEXTURE_FORMAT_RGBA8U, /** (73) */ + BGFX_TEXTURE_FORMAT_RGBA8S, /** (74) */ + BGFX_TEXTURE_FORMAT_RGBA16, /** (75) */ + BGFX_TEXTURE_FORMAT_RGBA16I, /** (76) */ + BGFX_TEXTURE_FORMAT_RGBA16U, /** (77) */ + BGFX_TEXTURE_FORMAT_RGBA16F, /** (78) */ + BGFX_TEXTURE_FORMAT_RGBA16S, /** (79) */ + BGFX_TEXTURE_FORMAT_RGBA32I, /** (80) */ + BGFX_TEXTURE_FORMAT_RGBA32U, /** (81) */ + BGFX_TEXTURE_FORMAT_RGBA32F, /** (82) */ + BGFX_TEXTURE_FORMAT_B5G6R5, /** (83) */ + BGFX_TEXTURE_FORMAT_R5G6B5, /** (84) */ + BGFX_TEXTURE_FORMAT_BGRA4, /** (85) */ + BGFX_TEXTURE_FORMAT_RGBA4, /** (86) */ + BGFX_TEXTURE_FORMAT_BGR5A1, /** (87) */ + BGFX_TEXTURE_FORMAT_RGB5A1, /** (88) */ + BGFX_TEXTURE_FORMAT_RGB10A2, /** (89) */ + BGFX_TEXTURE_FORMAT_RG11B10F, /** (90) */ + BGFX_TEXTURE_FORMAT_UNKNOWNDEPTH, /** (91) Depth formats below. */ + BGFX_TEXTURE_FORMAT_D16, /** (92) */ + BGFX_TEXTURE_FORMAT_D24, /** (93) */ + BGFX_TEXTURE_FORMAT_D24S8, /** (94) */ + BGFX_TEXTURE_FORMAT_D32, /** (95) */ + BGFX_TEXTURE_FORMAT_D16F, /** (96) */ + BGFX_TEXTURE_FORMAT_D24F, /** (97) */ + BGFX_TEXTURE_FORMAT_D32F, /** (98) */ + BGFX_TEXTURE_FORMAT_D0S8, /** (99) */ BGFX_TEXTURE_FORMAT_COUNT @@ -288,6 +292,20 @@ typedef enum bgfx_uniform_type } bgfx_uniform_type_t; +/** + * Uniform frequency enum. + * + */ +typedef enum bgfx_uniform_freq +{ + BGFX_UNIFORM_FREQ_DRAW, /** ( 0) Changing per draw call. */ + BGFX_UNIFORM_FREQ_VIEW, /** ( 1) Changing per view. */ + BGFX_UNIFORM_FREQ_FRAME, /** ( 2) Changing per frame. */ + + BGFX_UNIFORM_FREQ_COUNT + +} bgfx_uniform_freq_t; + /** * Backbuffer ratio enum. * @@ -389,6 +407,24 @@ typedef enum bgfx_view_mode } bgfx_view_mode_t; +/** + * Shading Rate. + * + */ +typedef enum bgfx_shading_rate +{ + BGFX_SHADING_RATE_RATE_1X_1, /** ( 0) 1x1 */ + BGFX_SHADING_RATE_RATE_1X_2, /** ( 1) 1x2 */ + BGFX_SHADING_RATE_RATE_2X_1, /** ( 2) 2x1 */ + BGFX_SHADING_RATE_RATE_2X_2, /** ( 3) 2x2 */ + BGFX_SHADING_RATE_RATE_2X_4, /** ( 4) 2x4 */ + BGFX_SHADING_RATE_RATE_4X_2, /** ( 5) 4x2 */ + BGFX_SHADING_RATE_RATE_4X_4, /** ( 6) 4x4 */ + + BGFX_SHADING_RATE_COUNT + +} bgfx_shading_rate_t; + /** * Native window handle type. * @@ -538,8 +574,9 @@ typedef struct bgfx_caps_limits_s uint32_t maxOcclusionQueries; /** Maximum number of occlusion query handles. */ uint32_t maxEncoders; /** Maximum number of encoder threads. */ uint32_t minResourceCbSize; /** Minimum resource command buffer size. */ - uint32_t transientVbSize; /** Maximum transient vertex buffer size. */ - uint32_t transientIbSize; /** Maximum transient index buffer size. */ + uint32_t maxTransientVbSize; /** Maximum transient vertex buffer size. */ + uint32_t maxTansientIbSize; /** Maximum transient index buffer size. */ + uint32_t minUniformBufferSize; /** Mimimum uniform buffer size. */ } bgfx_caps_limits_t; @@ -645,7 +682,8 @@ typedef struct bgfx_platform_data_s */ typedef struct bgfx_resolution_s { - bgfx_texture_format_t format; /** Backbuffer format. */ + bgfx_texture_format_t formatColor; /** Backbuffer color format. */ + bgfx_texture_format_t formatDepthStencil; /** Backbuffer depth/stencil format. */ uint32_t width; /** Backbuffer width. */ uint32_t height; /** Backbuffer height. */ uint32_t reset; /** Reset parameters. */ @@ -663,8 +701,9 @@ typedef struct bgfx_init_limits_s { uint16_t maxEncoders; /** Maximum number of encoder threads. */ uint32_t minResourceCbSize; /** Minimum resource command buffer size. */ - uint32_t transientVbSize; /** Maximum transient vertex buffer size. */ - uint32_t transientIbSize; /** Maximum transient index buffer size. */ + uint32_t maxTransientVbSize; /** Maximum transient vertex buffer size. */ + uint32_t maxTransientIbSize; /** Maximum transient index buffer size. */ + uint32_t minUniformBufferSize; /** Mimimum uniform buffer size. */ } bgfx_init_limits_t; @@ -2179,6 +2218,42 @@ BGFX_C_API void bgfx_destroy_frame_buffer(bgfx_frame_buffer_handle_t _handle); */ BGFX_C_API bgfx_uniform_handle_t bgfx_create_uniform(const char* _name, bgfx_uniform_type_t _type, uint16_t _num); +/** + * Create shader uniform parameter. + * @remarks + * 1. Uniform names are unique. It's valid to call `bgfx::createUniform` + * multiple times with the same uniform name. The library will always + * return the same handle, but the handle reference count will be + * incremented. This means that the same number of `bgfx::destroyUniform` + * must be called to properly destroy the uniform. + * 2. Predefined uniforms (declared in `bgfx_shader.sh`): + * - `u_viewRect vec4(x, y, width, height)` - view rectangle for current + * view, in pixels. + * - `u_viewTexel vec4(1.0/width, 1.0/height, undef, undef)` - inverse + * width and height + * - `u_view mat4` - view matrix + * - `u_invView mat4` - inverted view matrix + * - `u_proj mat4` - projection matrix + * - `u_invProj mat4` - inverted projection matrix + * - `u_viewProj mat4` - concatenated view projection matrix + * - `u_invViewProj mat4` - concatenated inverted view projection matrix + * - `u_model mat4[BGFX_CONFIG_MAX_BONES]` - array of model matrices. + * - `u_modelView mat4` - concatenated model view matrix, only first + * model matrix from array is used. + * - `u_invModelView mat4` - inverted concatenated model view matrix. + * - `u_modelViewProj mat4` - concatenated model view projection matrix. + * - `u_alphaRef float` - alpha reference value for alpha test. + * + * @param[in] _name Uniform name in shader. + * @param[in] _freq Uniform change frequency (See: `bgfx::UniformFreq`). + * @param[in] _type Type of uniform (See: `bgfx::UniformType`). + * @param[in] _num Number of elements in array. + * + * @returns Handle to uniform object. + * + */ +BGFX_C_API bgfx_uniform_handle_t bgfx_create_uniform_with_freq(const char* _name, bgfx_uniform_freq_t _freq, bgfx_uniform_type_t _type, uint16_t _num); + /** * Retrieve uniform info. * @@ -2388,10 +2463,20 @@ BGFX_C_API void bgfx_set_view_transform(bgfx_view_id_t _id, const void* _view, c */ BGFX_C_API void bgfx_set_view_order(bgfx_view_id_t _id, uint16_t _num, const bgfx_view_id_t* _order); +/** + * Set view shading rate. + * @attention Availability depends on: `BGFX_CAPS_VARIABLE_RATE_SHADING`. + * + * @param[in] _id View id. + * @param[in] _shadingRate Shading rate. + * + */ +BGFX_C_API void bgfx_set_view_shading_rate(bgfx_view_id_t _id, bgfx_shading_rate_t _shadingRate); + /** * Reset all view settings to default. * - * @param[in] _id + * @param[in] _id _id View id. * */ BGFX_C_API void bgfx_reset_view(bgfx_view_id_t _id); @@ -2542,6 +2627,31 @@ BGFX_C_API uint32_t bgfx_encoder_alloc_transform(bgfx_encoder_t* _this, bgfx_tra */ BGFX_C_API void bgfx_encoder_set_uniform(bgfx_encoder_t* _this, bgfx_uniform_handle_t _handle, const void* _value, uint16_t _num); +/** + * Set shader uniform parameter for view. + * @attention Uniform must be created with `bgfx::UniformFreq::View` argument. + * + * @param[in] _id View id. + * @param[in] _handle Uniform. + * @param[in] _value Pointer to uniform data. + * @param[in] _num Number of elements. Passing `UINT16_MAX` will + * use the _num passed on uniform creation. + * + */ +BGFX_C_API void bgfx_set_view_uniform(bgfx_view_id_t _id, bgfx_uniform_handle_t _handle, const void* _value, uint16_t _num); + +/** + * Set shader uniform parameter for frame. + * @attention Uniform must be created with `bgfx::UniformFreq::View` argument. + * + * @param[in] _handle Uniform. + * @param[in] _value Pointer to uniform data. + * @param[in] _num Number of elements. Passing `UINT16_MAX` will + * use the _num passed on uniform creation. + * + */ +BGFX_C_API void bgfx_set_frame_uniform(bgfx_uniform_handle_t _handle, const void* _value, uint16_t _num); + /** * Set index buffer for draw primitive. * @@ -2679,7 +2789,7 @@ BGFX_C_API void bgfx_encoder_set_instance_data_from_dynamic_vertex_buffer(bgfx_e * with gl_InstanceID. * @attention Availability depends on: `BGFX_CAPS_VERTEX_ID`. * - * @param[in] _numInstances + * @param[in] _numInstances Number of instances. * */ BGFX_C_API void bgfx_encoder_set_instance_count(bgfx_encoder_t* _this, uint32_t _numInstances); @@ -2952,12 +3062,13 @@ BGFX_C_API const bgfx_internal_data_t* bgfx_get_internal_data(void); * * @param[in] _handle Texture handle. * @param[in] _ptr Native API pointer to texture. + * @param[in] _layerIndex Layer index for texture arrays (only implemented for D3D11). * * @returns Native API pointer to texture. If result is 0, texture is not created * yet from the main thread. * */ -BGFX_C_API uintptr_t bgfx_override_internal_texture_ptr(bgfx_texture_handle_t _handle, uintptr_t _ptr); +BGFX_C_API uintptr_t bgfx_override_internal_texture_ptr(bgfx_texture_handle_t _handle, uintptr_t _ptr, uint16_t _layerIndex); /** * Override internal texture by creating new texture. Previously created @@ -3264,7 +3375,7 @@ BGFX_C_API void bgfx_set_instance_data_from_dynamic_vertex_buffer(bgfx_dynamic_v * with gl_InstanceID. * @attention Availability depends on: `BGFX_CAPS_VERTEX_ID`. * - * @param[in] _numInstances + * @param[in] _numInstances Number of instances. * */ BGFX_C_API void bgfx_set_instance_count(uint32_t _numInstances); @@ -3572,6 +3683,7 @@ typedef enum bgfx_function_id BGFX_FUNCTION_ID_GET_TEXTURE, BGFX_FUNCTION_ID_DESTROY_FRAME_BUFFER, BGFX_FUNCTION_ID_CREATE_UNIFORM, + BGFX_FUNCTION_ID_CREATE_UNIFORM_WITH_FREQ, BGFX_FUNCTION_ID_GET_UNIFORM_INFO, BGFX_FUNCTION_ID_DESTROY_UNIFORM, BGFX_FUNCTION_ID_CREATE_OCCLUSION_QUERY, @@ -3590,6 +3702,7 @@ typedef enum bgfx_function_id BGFX_FUNCTION_ID_SET_VIEW_FRAME_BUFFER, BGFX_FUNCTION_ID_SET_VIEW_TRANSFORM, BGFX_FUNCTION_ID_SET_VIEW_ORDER, + BGFX_FUNCTION_ID_SET_VIEW_SHADING_RATE, BGFX_FUNCTION_ID_RESET_VIEW, BGFX_FUNCTION_ID_ENCODER_BEGIN, BGFX_FUNCTION_ID_ENCODER_END, @@ -3603,6 +3716,8 @@ typedef enum bgfx_function_id BGFX_FUNCTION_ID_ENCODER_SET_TRANSFORM_CACHED, BGFX_FUNCTION_ID_ENCODER_ALLOC_TRANSFORM, BGFX_FUNCTION_ID_ENCODER_SET_UNIFORM, + BGFX_FUNCTION_ID_SET_VIEW_UNIFORM, + BGFX_FUNCTION_ID_SET_FRAME_UNIFORM, BGFX_FUNCTION_ID_ENCODER_SET_INDEX_BUFFER, BGFX_FUNCTION_ID_ENCODER_SET_DYNAMIC_INDEX_BUFFER, BGFX_FUNCTION_ID_ENCODER_SET_TRANSIENT_INDEX_BUFFER, @@ -3778,6 +3893,7 @@ struct bgfx_interface_vtbl bgfx_texture_handle_t (*get_texture)(bgfx_frame_buffer_handle_t _handle, uint8_t _attachment); void (*destroy_frame_buffer)(bgfx_frame_buffer_handle_t _handle); bgfx_uniform_handle_t (*create_uniform)(const char* _name, bgfx_uniform_type_t _type, uint16_t _num); + bgfx_uniform_handle_t (*create_uniform_with_freq)(const char* _name, bgfx_uniform_freq_t _freq, bgfx_uniform_type_t _type, uint16_t _num); void (*get_uniform_info)(bgfx_uniform_handle_t _handle, bgfx_uniform_info_t * _info); void (*destroy_uniform)(bgfx_uniform_handle_t _handle); bgfx_occlusion_query_handle_t (*create_occlusion_query)(void); @@ -3796,6 +3912,7 @@ struct bgfx_interface_vtbl void (*set_view_frame_buffer)(bgfx_view_id_t _id, bgfx_frame_buffer_handle_t _handle); void (*set_view_transform)(bgfx_view_id_t _id, const void* _view, const void* _proj); void (*set_view_order)(bgfx_view_id_t _id, uint16_t _num, const bgfx_view_id_t* _order); + void (*set_view_shading_rate)(bgfx_view_id_t _id, bgfx_shading_rate_t _shadingRate); void (*reset_view)(bgfx_view_id_t _id); bgfx_encoder_t* (*encoder_begin)(bool _forThread); void (*encoder_end)(bgfx_encoder_t* _encoder); @@ -3809,6 +3926,8 @@ struct bgfx_interface_vtbl void (*encoder_set_transform_cached)(bgfx_encoder_t* _this, uint32_t _cache, uint16_t _num); uint32_t (*encoder_alloc_transform)(bgfx_encoder_t* _this, bgfx_transform_t* _transform, uint16_t _num); void (*encoder_set_uniform)(bgfx_encoder_t* _this, bgfx_uniform_handle_t _handle, const void* _value, uint16_t _num); + void (*set_view_uniform)(bgfx_view_id_t _id, bgfx_uniform_handle_t _handle, const void* _value, uint16_t _num); + void (*set_frame_uniform)(bgfx_uniform_handle_t _handle, const void* _value, uint16_t _num); void (*encoder_set_index_buffer)(bgfx_encoder_t* _this, bgfx_index_buffer_handle_t _handle, uint32_t _firstIndex, uint32_t _numIndices); void (*encoder_set_dynamic_index_buffer)(bgfx_encoder_t* _this, bgfx_dynamic_index_buffer_handle_t _handle, uint32_t _firstIndex, uint32_t _numIndices); void (*encoder_set_transient_index_buffer)(bgfx_encoder_t* _this, const bgfx_transient_index_buffer_t* _tib, uint32_t _firstIndex, uint32_t _numIndices); @@ -3843,7 +3962,7 @@ struct bgfx_interface_vtbl bgfx_render_frame_t (*render_frame)(int32_t _msecs); void (*set_platform_data)(const bgfx_platform_data_t * _data); const bgfx_internal_data_t* (*get_internal_data)(void); - uintptr_t (*override_internal_texture_ptr)(bgfx_texture_handle_t _handle, uintptr_t _ptr); + uintptr_t (*override_internal_texture_ptr)(bgfx_texture_handle_t _handle, uintptr_t _ptr, uint16_t _layerIndex); uintptr_t (*override_internal_texture)(bgfx_texture_handle_t _handle, uint16_t _width, uint16_t _height, uint8_t _numMips, bgfx_texture_format_t _format, uint64_t _flags); void (*set_marker)(const char* _name, int32_t _len); void (*set_state)(uint64_t _state, uint32_t _rgba); diff --git a/libs/bgfx/include/bgfx/defines.h b/libs/bgfx/include/bgfx/defines.h index 9a9f116..45c4ced 100644 --- a/libs/bgfx/include/bgfx/defines.h +++ b/libs/bgfx/include/bgfx/defines.h @@ -15,7 +15,7 @@ #ifndef BGFX_DEFINES_H_HEADER_GUARD #define BGFX_DEFINES_H_HEADER_GUARD -#define BGFX_API_VERSION UINT32_C(129) +#define BGFX_API_VERSION UINT32_C(135) /** * Color RGB/alpha/depth write. When it's not specified write will be disabled. @@ -277,15 +277,15 @@ #define BGFX_DEBUG_TEXT UINT32_C(0x00000008) //!< Enable debug text display. #define BGFX_DEBUG_PROFILER UINT32_C(0x00000010) //!< Enable profiler. This causes per-view statistics to be collected, available through `bgfx::Stats::ViewStats`. This is unrelated to the profiler functions in `bgfx::CallbackI`. -#define BGFX_BUFFER_COMPUTE_FORMAT_8X1 UINT16_C(0x0001) //!< 1 8-bit value -#define BGFX_BUFFER_COMPUTE_FORMAT_8X2 UINT16_C(0x0002) //!< 2 8-bit values -#define BGFX_BUFFER_COMPUTE_FORMAT_8X4 UINT16_C(0x0003) //!< 4 8-bit values -#define BGFX_BUFFER_COMPUTE_FORMAT_16X1 UINT16_C(0x0004) //!< 1 16-bit value -#define BGFX_BUFFER_COMPUTE_FORMAT_16X2 UINT16_C(0x0005) //!< 2 16-bit values -#define BGFX_BUFFER_COMPUTE_FORMAT_16X4 UINT16_C(0x0006) //!< 4 16-bit values -#define BGFX_BUFFER_COMPUTE_FORMAT_32X1 UINT16_C(0x0007) //!< 1 32-bit value -#define BGFX_BUFFER_COMPUTE_FORMAT_32X2 UINT16_C(0x0008) //!< 2 32-bit values -#define BGFX_BUFFER_COMPUTE_FORMAT_32X4 UINT16_C(0x0009) //!< 4 32-bit values +#define BGFX_BUFFER_COMPUTE_FORMAT_8X1 UINT16_C(0x0001) //!< 1 x 8-bit value +#define BGFX_BUFFER_COMPUTE_FORMAT_8X2 UINT16_C(0x0002) //!< 2 x 8-bit values +#define BGFX_BUFFER_COMPUTE_FORMAT_8X4 UINT16_C(0x0003) //!< 4 x 8-bit values +#define BGFX_BUFFER_COMPUTE_FORMAT_16X1 UINT16_C(0x0004) //!< 1 x 16-bit value +#define BGFX_BUFFER_COMPUTE_FORMAT_16X2 UINT16_C(0x0005) //!< 2 x 16-bit values +#define BGFX_BUFFER_COMPUTE_FORMAT_16X4 UINT16_C(0x0006) //!< 4 x 16-bit values +#define BGFX_BUFFER_COMPUTE_FORMAT_32X1 UINT16_C(0x0007) //!< 1 x 32-bit value +#define BGFX_BUFFER_COMPUTE_FORMAT_32X2 UINT16_C(0x0008) //!< 2 x 32-bit values +#define BGFX_BUFFER_COMPUTE_FORMAT_32X4 UINT16_C(0x0009) //!< 4 x 32-bit values #define BGFX_BUFFER_COMPUTE_FORMAT_SHIFT 0 #define BGFX_BUFFER_COMPUTE_FORMAT_MASK UINT16_C(0x000f) @@ -489,10 +489,11 @@ #define BGFX_CAPS_TEXTURE_2D_ARRAY UINT64_C(0x0000000001000000) //!< 2D texture array is supported. #define BGFX_CAPS_TEXTURE_3D UINT64_C(0x0000000002000000) //!< 3D textures are supported. #define BGFX_CAPS_TRANSPARENT_BACKBUFFER UINT64_C(0x0000000004000000) //!< Transparent back buffer supported. -#define BGFX_CAPS_VERTEX_ATTRIB_HALF UINT64_C(0x0000000008000000) //!< Vertex attribute half-float is supported. -#define BGFX_CAPS_VERTEX_ATTRIB_UINT10 UINT64_C(0x0000000010000000) //!< Vertex attribute 10_10_10_2 is supported. -#define BGFX_CAPS_VERTEX_ID UINT64_C(0x0000000020000000) //!< Rendering with VertexID only is supported. -#define BGFX_CAPS_VIEWPORT_LAYER_ARRAY UINT64_C(0x0000000040000000) //!< Viewport layer is available in vertex shader. +#define BGFX_CAPS_VARIABLE_RATE_SHADING UINT64_C(0x0000000008000000) //!< Variable Rate Shading +#define BGFX_CAPS_VERTEX_ATTRIB_HALF UINT64_C(0x0000000010000000) //!< Vertex attribute half-float is supported. +#define BGFX_CAPS_VERTEX_ATTRIB_UINT10 UINT64_C(0x0000000020000000) //!< Vertex attribute 10_10_10_2 is supported. +#define BGFX_CAPS_VERTEX_ID UINT64_C(0x0000000040000000) //!< Rendering with VertexID only is supported. +#define BGFX_CAPS_VIEWPORT_LAYER_ARRAY UINT64_C(0x0000000080000000) //!< Viewport layer is available in vertex shader. /// All texture compare modes are supported. #define BGFX_CAPS_TEXTURE_COMPARE_ALL (0 \ | BGFX_CAPS_TEXTURE_COMPARE_RESERVED \ diff --git a/libs/bgfx/include/bgfx/platform.h b/libs/bgfx/include/bgfx/platform.h index 5fd84c4..88ee791 100644 --- a/libs/bgfx/include/bgfx/platform.h +++ b/libs/bgfx/include/bgfx/platform.h @@ -89,6 +89,7 @@ namespace bgfx /// /// @param[in] _handle Texture handle. /// @param[in] _ptr Native API pointer to texture. + /// @param[in] _layerIndex Layer index for texture arrays (only implemented for D3D11). /// /// @returns Native API pointer to texture. If result is 0, texture is not created yet from the /// main thread. @@ -97,7 +98,7 @@ namespace bgfx /// /// @attention C99's equivalent binding is `bgfx_override_internal_texture_ptr`. /// - uintptr_t overrideInternal(TextureHandle _handle, uintptr_t _ptr); + uintptr_t overrideInternal(TextureHandle _handle, uintptr_t _ptr, uint16_t _layerIndex = 0); /// Override internal texture by creating new texture. Previously created /// internal texture will released. diff --git a/libs/bgfx/src/bgfx.cpp b/libs/bgfx/src/bgfx.cpp index c66259a..8b39c3b 100644 --- a/libs/bgfx/src/bgfx.cpp +++ b/libs/bgfx/src/bgfx.cpp @@ -19,7 +19,10 @@ # define WIN32_LEAN_AND_MEAN # endif // WIN32_LEAN_AND_MEAN # include -#endif // BX_PLATFORM_OSX +# include +#elif BX_PLATFORM_LINUX +# include // dl_iterate_phdr +#endif // BX_PLATFORM_* BX_ERROR_RESULT(BGFX_ERROR_TEXTURE_VALIDATION, BX_MAKEFOURCC('b', 'g', 0, 1) ); BX_ERROR_RESULT(BGFX_ERROR_FRAME_BUFFER_VALIDATION, BX_MAKEFOURCC('b', 'g', 0, 2) ); @@ -262,51 +265,11 @@ namespace bgfx Caps g_caps; -#if BGFX_CONFIG_MULTITHREADED && !defined(BX_THREAD_LOCAL) - class ThreadData - { - BX_CLASS(ThreadData - , NO_DEFAULT_CTOR - , NO_COPY - ); - - public: - ThreadData(uintptr_t _rhs) - { - union { uintptr_t ui; void* ptr; } cast = { _rhs }; - m_tls.set(cast.ptr); - } - - operator uintptr_t() const - { - union { uintptr_t ui; void* ptr; } cast; - cast.ptr = m_tls.get(); - return cast.ui; - } - - uintptr_t operator=(uintptr_t _rhs) - { - union { uintptr_t ui; void* ptr; } cast = { _rhs }; - m_tls.set(cast.ptr); - return _rhs; - } - - bool operator==(uintptr_t _rhs) const - { - uintptr_t lhs = *this; - return lhs == _rhs; - } - - private: - bx::TlsData m_tls; - }; - - static ThreadData s_threadIndex(0); -#elif !BGFX_CONFIG_MULTITHREADED - static uint32_t s_threadIndex(0); -#else +#if BGFX_CONFIG_MULTITHREADED static BX_THREAD_LOCAL uint32_t s_threadIndex(0); -#endif +#else + static uint32_t s_threadIndex(0); +#endif // BGFX_CONFIG_MULTITHREADED static Context* s_ctx = NULL; static bool s_renderFrameCalled = false; @@ -377,7 +340,7 @@ namespace bgfx return &g_internalData; } - uintptr_t overrideInternal(TextureHandle _handle, uintptr_t _ptr) + uintptr_t overrideInternal(TextureHandle _handle, uintptr_t _ptr, uint16_t _layerIndex) { BGFX_CHECK_RENDER_THREAD(); RendererContextI* rci = s_ctx->m_renderCtx; @@ -386,7 +349,7 @@ namespace bgfx return 0; } - rci->overrideInternal(_handle, _ptr); + rci->overrideInternal(_handle, _ptr, _layerIndex); return rci->getInternal(_handle); } @@ -404,8 +367,7 @@ namespace bgfx Memory* mem = const_cast(alloc(size) ); bx::StaticMemoryBlockWriter writer(mem->data, mem->size); - uint32_t magic = BGFX_CHUNK_MAGIC_TEX; - bx::write(&writer, magic, bx::ErrorAssert{}); + bx::write(&writer, kChunkMagicTex, bx::ErrorAssert{}); TextureCreate tc; tc.m_width = _width; @@ -932,7 +894,7 @@ namespace bgfx if (isValid(m_program[ii]) ) { destroy(m_program[ii]); - m_program[ii].idx = kInvalidHandle; + m_program[ii] = BGFX_INVALID_HANDLE; } } @@ -1468,6 +1430,8 @@ namespace bgfx } bx::radixSort(m_blitKeys, (uint32_t*)&s_ctx->m_tempKeys, m_numBlitItems); + + m_uniformCacheFrame.sort(viewRemap, s_ctx->m_tempKeys); } RenderFrame::Enum renderFrame(int32_t _msecs) @@ -1506,7 +1470,7 @@ namespace bgfx return RenderFrame::NoContext; } - const uint32_t g_uniformTypeSize[UniformType::Count+1] = + const uint32_t g_uniformTypeSize[] = { sizeof(int32_t), 0, @@ -1515,10 +1479,11 @@ namespace bgfx 4*4*sizeof(float), 1, }; + static_assert(UniformType::Count+1 == BX_COUNTOF(g_uniformTypeSize), "Must match UniformType::Enum!"); void UniformBuffer::writeUniform(UniformType::Enum _type, uint16_t _loc, const void* _value, uint16_t _num) { - const uint32_t opcode = encodeOpcode(_type, _loc, _num, true); + const uint32_t opcode = encodeOpcode(bx::narrowCast(_type), _loc, _num, true); write(opcode); write(_value, g_uniformTypeSize[_type]*_num); } @@ -1563,21 +1528,22 @@ namespace bgfx CAPS_FLAGS(BGFX_CAPS_INDEX32), CAPS_FLAGS(BGFX_CAPS_INSTANCING), CAPS_FLAGS(BGFX_CAPS_OCCLUSION_QUERY), + CAPS_FLAGS(BGFX_CAPS_PRIMITIVE_ID), CAPS_FLAGS(BGFX_CAPS_RENDERER_MULTITHREADED), CAPS_FLAGS(BGFX_CAPS_SWAP_CHAIN), CAPS_FLAGS(BGFX_CAPS_TEXTURE_2D_ARRAY), CAPS_FLAGS(BGFX_CAPS_TEXTURE_3D), CAPS_FLAGS(BGFX_CAPS_TEXTURE_BLIT), - CAPS_FLAGS(BGFX_CAPS_TRANSPARENT_BACKBUFFER), CAPS_FLAGS(BGFX_CAPS_TEXTURE_COMPARE_ALL), CAPS_FLAGS(BGFX_CAPS_TEXTURE_COMPARE_LEQUAL), CAPS_FLAGS(BGFX_CAPS_TEXTURE_CUBE_ARRAY), CAPS_FLAGS(BGFX_CAPS_TEXTURE_DIRECT_ACCESS), CAPS_FLAGS(BGFX_CAPS_TEXTURE_READ_BACK), + CAPS_FLAGS(BGFX_CAPS_TRANSPARENT_BACKBUFFER), + CAPS_FLAGS(BGFX_CAPS_VARIABLE_RATE_SHADING), CAPS_FLAGS(BGFX_CAPS_VERTEX_ATTRIB_HALF), CAPS_FLAGS(BGFX_CAPS_VERTEX_ATTRIB_UINT10), CAPS_FLAGS(BGFX_CAPS_VERTEX_ID), - CAPS_FLAGS(BGFX_CAPS_PRIMITIVE_ID), CAPS_FLAGS(BGFX_CAPS_VIEWPORT_LAYER_ARRAY), #undef CAPS_FLAGS }; @@ -1646,6 +1612,18 @@ namespace bgfx BX_TRACE("\t C Seq %016" PRIx64, kSortKeyComputeSeqMask); BX_TRACE("\t C Program %016" PRIx64, kSortKeyComputeProgramMask); + BX_TRACE(""); + BX_TRACE("Blit key masks:"); + BX_TRACE("\tView %08" PRIx32, BlitKey::kViewMask); + BX_TRACE("\tItem %08" PRIx32, BlitKey::kItemMask); + + BX_TRACE(""); + BX_TRACE("Uniform cache key masks:"); + BX_TRACE("\tView %016" PRIx64, UniformCacheKey::kViewMask); + BX_TRACE("\tHandle %016" PRIx64, UniformCacheKey::kHandleMask); + BX_TRACE("\tOffset %016" PRIx64, UniformCacheKey::kOffsetMask); + BX_TRACE("\tSize %016" PRIx64, UniformCacheKey::kSizeMask); + BX_TRACE(""); BX_TRACE("Capabilities (renderer %s, vendor 0x%04x, device 0x%04x):" , s_ctx->m_renderCtx->getRendererName() @@ -1686,8 +1664,9 @@ namespace bgfx LIMITS(maxOcclusionQueries); LIMITS(maxEncoders); LIMITS(minResourceCbSize); - LIMITS(transientVbSize); - LIMITS(transientIbSize); + LIMITS(maxTransientVbSize); + LIMITS(maxTransientIbSize); + LIMITS(minUniformBufferSize); #undef LIMITS BX_TRACE(""); @@ -1747,12 +1726,15 @@ namespace bgfx BX_UNUSED(reset, msaa); BX_TRACE("Reset back-buffer swap chain:"); - BX_TRACE("\t%dx%d, format: %s, numBackBuffers: %d, maxFrameLatency: %d" + BX_TRACE("\t%dx%d, formatColor: %s, formatDepthStencil: %s, numBackBuffers: %d, maxFrameLatency: %d" , _resolution.width , _resolution.height - , TextureFormat::Count == _resolution.format + , TextureFormat::Count == _resolution.formatColor ? "*default*" - : bimg::getName(bimg::TextureFormat::Enum(_resolution.format) ) + : bimg::getName(bimg::TextureFormat::Enum(_resolution.formatColor) ) + , TextureFormat::Count == _resolution.formatDepthStencil + ? "*default*" + : bimg::getName(bimg::TextureFormat::Enum(_resolution.formatDepthStencil) ) , _resolution.numBackBuffers , _resolution.maxFrameLatency ); @@ -1811,12 +1793,17 @@ namespace bgfx const char* getName(UniformHandle _handle) { - return s_ctx->m_uniformRef[_handle.idx].m_name.getPtr(); + return getUniformRef(_handle).m_name.getCPtr(); + } + + const UniformRef& getUniformRef(UniformHandle _handle) + { + return s_ctx->m_uniformRef[_handle.idx]; } const char* getName(ShaderHandle _handle) { - return s_ctx->m_shaderRef[_handle.idx].m_name.getPtr(); + return s_ctx->m_shaderRef[_handle.idx].m_name.getCPtr(); } static const char* s_topologyName[] = @@ -2050,14 +2037,14 @@ namespace bgfx m_textVideoMemBlitter.init(m_init.resolution.debugTextScale); m_clearQuad.init(); - m_submit->m_transientVb = createTransientVertexBuffer(_init.limits.transientVbSize); - m_submit->m_transientIb = createTransientIndexBuffer(_init.limits.transientIbSize); + m_submit->m_transientVb = createTransientVertexBuffer(_init.limits.maxTransientVbSize); + m_submit->m_transientIb = createTransientIndexBuffer(_init.limits.maxTransientIbSize); frame(); if (BX_ENABLED(BGFX_CONFIG_MULTITHREADED) ) { - m_submit->m_transientVb = createTransientVertexBuffer(_init.limits.transientVbSize); - m_submit->m_transientIb = createTransientIndexBuffer(_init.limits.transientIbSize); + m_submit->m_transientVb = createTransientVertexBuffer(_init.limits.maxTransientVbSize); + m_submit->m_transientIb = createTransientIndexBuffer(_init.limits.maxTransientIbSize); frame(); } @@ -2168,7 +2155,7 @@ namespace bgfx BX_TRACE("\t%3d: %4d %s" \ , ii \ , idx \ - , ref.m_name.getPtr() \ + , ref.m_name.getCPtr() \ ); \ } \ } \ @@ -2190,7 +2177,7 @@ namespace bgfx BX_TRACE("\t%3d: %4d %s (count %d)" \ , ii \ , idx \ - , ref.m_name.getPtr() \ + , ref.m_name.getCPtr() \ , ref.m_refCount \ ); \ } \ @@ -2273,7 +2260,9 @@ namespace bgfx for (uint16_t ii = 0, num = _frame->m_freeUniform.getNumQueued(); ii < num; ++ii) { - m_uniformHandle.free(_frame->m_freeUniform.get(ii).idx); + UniformHandle handle = _frame->m_freeUniform.get(ii); + m_uniformCache.invalidate(handle); + m_uniformHandle.free(handle.idx); } } @@ -2360,6 +2349,10 @@ namespace bgfx m_submit->m_perfStats.numViews = 0; bx::memCopy(m_submit->m_viewRemap, m_viewRemap, sizeof(m_viewRemap) ); + + m_uniformCache.frame(m_submit->m_uniformCacheFrame); + + static_assert(bx::isTriviallyCopyable(), "Must be memcopyiable..."); bx::memCopy(m_submit->m_view, m_view, sizeof(m_view) ); if (m_colorPaletteDirty > 0) @@ -2444,7 +2437,7 @@ namespace bgfx id pool; }; -#endif // BX_PLATFORM_OSX +#endif // BX_PLATFORM_OSX || BX_PLATFORM_IOS || BX_PLATFORM_VISIONOS RenderFrame::Enum Context::renderFrame(int32_t _msecs) { @@ -2452,7 +2445,7 @@ namespace bgfx #if BX_PLATFORM_OSX || BX_PLATFORM_IOS || BX_PLATFORM_VISIONOS NSAutoreleasePoolScope pool; -#endif // BX_PLATFORM_OSX +#endif // BX_PLATFORM_OSX || BX_PLATFORM_IOS || BX_PLATFORM_VISIONOS if (!m_flipAfterRender) { @@ -2661,6 +2654,82 @@ namespace bgfx }; static_assert(BX_COUNTOF(s_rendererCreator) == RendererType::Count); + void* findModule(const char* _name) + { +#if BX_PLATFORM_WINDOWS + // NOTE: there was some reason to do it this way instead of simply calling GetModuleHandleA, + // but not sure what it was. + HANDLE process = GetCurrentProcess(); + DWORD size; + BOOL result = EnumProcessModules(process + , NULL + , 0 + , &size + ); + if (0 != result) + { + HMODULE* modules = (HMODULE*)BX_STACK_ALLOC(size); + result = EnumProcessModules(process + , modules + , size + , &size + ); + + if (0 != result) + { + char moduleName[MAX_PATH]; + + for (uint32_t ii = 0, num = uint32_t(size/sizeof(HMODULE) ); ii < num; ++ii) + { + result = GetModuleBaseNameA(process + , modules[ii] + , moduleName + , BX_COUNTOF(moduleName) + ); + + if (0 != result + && 0 == bx::strCmpI(_name, moduleName) ) + { + return (void*)modules[ii]; + } + } + } + } + + return NULL; +#elif BX_PLATFORM_LINUX + struct DlIterateCallbackData + { + const char* name; + void* ptr; + } cbData = + { + .name = _name, + .ptr = NULL, + }; + + auto dlIterateCb = [](struct dl_phdr_info* _info, size_t /* _size */, void* _data) -> int + { + DlIterateCallbackData& data = *(DlIterateCallbackData*)_data; + + if (bx::hasSuffix(_info->dlpi_name, data.name) ) + { + data.ptr = dlopen(_info->dlpi_name, RTLD_NOW | RTLD_NOLOAD); + return 1; + } + + return 0; + }; + + dl_iterate_phdr(dlIterateCb, &cbData); + + return cbData.ptr; +#else + BX_UNUSED(_name); + return NULL; +#endif // BX_PLATFORM_WINDOWS + } + bool windowsVersionIs(Condition::Enum _op, uint32_t _version, uint32_t _build) { #if BX_PLATFORM_WINDOWS @@ -3154,7 +3223,7 @@ namespace bgfx uint32_t magic; bx::read(&reader, magic, &err); - if (BGFX_CHUNK_MAGIC_TEX == magic) + if (kChunkMagicTex == magic) { TextureCreate tc; bx::read(&reader, tc, &err); @@ -3455,7 +3524,8 @@ namespace bgfx } Resolution::Resolution() - : format(TextureFormat::RGBA8) + : formatColor(TextureFormat::RGBA8) + , formatDepthStencil(TextureFormat::D24S8) , width(1280) , height(720) , reset(BGFX_RESET_NONE) @@ -3468,8 +3538,9 @@ namespace bgfx Init::Limits::Limits() : maxEncoders(BGFX_CONFIG_DEFAULT_MAX_ENCODERS) , minResourceCbSize(BGFX_CONFIG_MIN_RESOURCE_COMMAND_BUFFER_SIZE) - , transientVbSize(BGFX_CONFIG_TRANSIENT_VERTEX_BUFFER_SIZE) - , transientIbSize(BGFX_CONFIG_TRANSIENT_INDEX_BUFFER_SIZE) + , maxTransientVbSize(BGFX_CONFIG_MAX_TRANSIENT_VERTEX_BUFFER_SIZE) + , maxTransientIbSize(BGFX_CONFIG_MAX_TRANSIENT_INDEX_BUFFER_SIZE) + , minUniformBufferSize(BGFX_CONFIG_MIN_UNIFORM_BUFFER_SIZE) { } @@ -3563,8 +3634,9 @@ namespace bgfx g_caps.limits.maxFBAttachments = 1; g_caps.limits.maxEncoders = init.limits.maxEncoders; g_caps.limits.minResourceCbSize = init.limits.minResourceCbSize; - g_caps.limits.transientVbSize = init.limits.transientVbSize; - g_caps.limits.transientIbSize = init.limits.transientIbSize; + g_caps.limits.maxTransientVbSize = init.limits.maxTransientVbSize; + g_caps.limits.maxTransientIbSize = init.limits.maxTransientIbSize; + g_caps.limits.minUniformBufferSize = init.limits.minUniformBufferSize; g_caps.vendorId = init.vendorId; g_caps.deviceId = init.deviceId; @@ -3720,6 +3792,7 @@ namespace bgfx { BGFX_CHECK_HANDLE("setUniform", s_ctx->m_uniformHandle, _handle); const UniformRef& uniform = s_ctx->m_uniformRef[_handle.idx]; + BX_ASSERT(uniform.m_freq == UniformFreq::Draw, "Setting uniform per draw call, but uniform is created with different bgfx::UniformFreq::Enum!"); BX_ASSERT(isValid(_handle) && 0 < uniform.m_refCount, "Setting invalid uniform (handle %3d)!", _handle.idx); BX_ASSERT(_num == UINT16_MAX || uniform.m_num >= _num, "Truncated uniform update. %d (max: %d)", _num, uniform.m_num); BGFX_ENCODER(setUniform(uniform.m_type, _handle, _value, UINT16_MAX != _num ? _num : uniform.m_num) ); @@ -4037,7 +4110,7 @@ namespace bgfx uint32_t dstHeight = bx::max(1, dst.m_height >> _dstMip); uint32_t srcDepth = src.isCubeMap() ? 6 * src.m_numLayers : src.m_numLayers > 1 ? src.m_numLayers : bx::max(1, src.m_depth >> _srcMip); - uint32_t dstDepth = dst.isCubeMap() ? 6 * src.m_numLayers : src.m_numLayers > 1 ? src.m_numLayers : bx::max(1, dst.m_depth >> _dstMip); + uint32_t dstDepth = dst.isCubeMap() ? 6 * dst.m_numLayers : dst.m_numLayers > 1 ? dst.m_numLayers : bx::max(1, dst.m_depth >> _dstMip); BX_ASSERT(_srcX < srcWidth && _srcY < srcHeight && _srcZ < srcDepth , "Blit src coordinates out of range (%d, %d, %d) >= (%d, %d, %d)" @@ -4548,13 +4621,13 @@ namespace bgfx ++depth; BGFX_ERROR_CHECK( - // if BGFX_TEXTURE_RT_MSAA_X2 or greater than BGFX_TEXTURE_RT_WRITE_ONLY is required - // if BGFX_TEXTURE_RT with no MSSA then WRITE_ONLY is not required. + // if BGFX_TEXTURE_RT_MSAA_X2 or greater than either BGFX_TEXTURE_RT_WRITE_ONLY or BGFX_TEXTURE_MSAA_SAMPLE is required + // if BGFX_TEXTURE_RT with no MSSA then this is not required. (1 == ((tr.m_flags & BGFX_TEXTURE_RT_MSAA_MASK) >> BGFX_TEXTURE_RT_MSAA_SHIFT)) - || (0 != (tr.m_flags & BGFX_TEXTURE_RT_WRITE_ONLY)) + || (0 != (tr.m_flags & (BGFX_TEXTURE_RT_WRITE_ONLY | BGFX_TEXTURE_MSAA_SAMPLE))) , _err , BGFX_ERROR_FRAME_BUFFER_VALIDATION - , "Frame buffer depth MSAA texture cannot be resolved. It must be created with `BGFX_TEXTURE_RT_WRITE_ONLY` flag." + , "Frame buffer depth MSAA texture cannot be resolved. It must be created with either `BGFX_TEXTURE_RT_WRITE_ONLY` or `BGFX_TEXTURE_MSAA_SAMPLE` flag." , "Attachment %d, texture flags 0x%016" PRIx64 "." , ii , tr.m_flags @@ -4888,8 +4961,7 @@ namespace bgfx const Memory* mem = alloc(size); bx::StaticMemoryBlockWriter writer(mem->data, mem->size); - uint32_t magic = BGFX_CHUNK_MAGIC_TEX; - bx::write(&writer, magic, bx::ErrorAssert{}); + bx::write(&writer, kChunkMagicTex, bx::ErrorAssert{}); TextureCreate tc; tc.m_width = _width; @@ -4945,8 +5017,7 @@ namespace bgfx const Memory* mem = alloc(size); bx::StaticMemoryBlockWriter writer(mem->data, mem->size); - uint32_t magic = BGFX_CHUNK_MAGIC_TEX; - bx::write(&writer, magic, bx::ErrorAssert{}); + bx::write(&writer, kChunkMagicTex, bx::ErrorAssert{}); TextureCreate tc; tc.m_width = _width; @@ -4991,8 +5062,7 @@ namespace bgfx const Memory* mem = alloc(size); bx::StaticMemoryBlockWriter writer(mem->data, mem->size); - uint32_t magic = BGFX_CHUNK_MAGIC_TEX; - bx::write(&writer, magic, bx::ErrorAssert{}); + bx::write(&writer, kChunkMagicTex, bx::ErrorAssert{}); TextureCreate tc; tc.m_width = _size; @@ -5156,7 +5226,24 @@ namespace bgfx UniformHandle createUniform(const char* _name, UniformType::Enum _type, uint16_t _num) { - return s_ctx->createUniform(_name, _type, _num); + BX_ASSERT(UniformType::End != _type && UniformType::Count > _type + , "UniformType argument is not valid (_type: %d)!" + , _type + ); + return s_ctx->createUniform(_name, UniformFreq::Draw, _type, _num); + } + + UniformHandle createUniform(const char* _name, UniformFreq::Enum _freq, UniformType::Enum _type, uint16_t _num) + { + BX_ASSERT(UniformType::End != _type && UniformType::Count > _type + , "UniformType argument is not valid (_type: %d)!" + , _type + ); + BX_ASSERT(UniformFreq::Count > _freq + , "UniformFreq argument is not valid (_freq: %d)!" + , _freq + ); + return s_ctx->createUniform(_name, _freq, _type, _num); } void getUniformInfo(UniformHandle _handle, UniformInfo& _info) @@ -5287,6 +5374,12 @@ namespace bgfx s_ctx->setViewOrder(_id, _num, _order); } + void setViewShadingRate(ViewId _id, ShadingRate::Enum _shadingRate) + { + BX_ASSERT(checkView(_id), "Invalid view id: %d", _id); + s_ctx->setViewShadingRate(_id, _shadingRate); + } + void resetView(ViewId _id) { BX_ASSERT(checkView(_id), "Invalid view id: %d", _id); @@ -5358,6 +5451,19 @@ namespace bgfx s_ctx->m_encoder0->setUniform(_handle, _value, _num); } + void setViewUniform(ViewId _id, UniformHandle _handle, const void* _value, uint16_t _num) + { + BX_ASSERT(checkView(_id), "Invalid view id: %d", _id); + BGFX_CHECK_HANDLE("setUniform", s_ctx->m_uniformHandle, _handle); + s_ctx->setViewUniform(_id, _handle, _value, _num); + } + + void setFrameUniform(UniformHandle _handle, const void* _value, uint16_t _num) + { + BGFX_CHECK_HANDLE("setUniform", s_ctx->m_uniformHandle, _handle); + s_ctx->setViewUniform(UINT16_MAX, _handle, _value, _num); + } + void setIndexBuffer(IndexBufferHandle _handle) { BGFX_CHECK_ENCODER0(); diff --git a/libs/bgfx/src/bgfx.idl.inl b/libs/bgfx/src/bgfx.idl.inl index fa0e2b3..cab986d 100644 --- a/libs/bgfx/src/bgfx.idl.inl +++ b/libs/bgfx/src/bgfx.idl.inl @@ -601,6 +601,13 @@ BGFX_C_API bgfx_uniform_handle_t bgfx_create_uniform(const char* _name, bgfx_uni return handle_ret.c; } +BGFX_C_API bgfx_uniform_handle_t bgfx_create_uniform_with_freq(const char* _name, bgfx_uniform_freq_t _freq, bgfx_uniform_type_t _type, uint16_t _num) +{ + union { bgfx_uniform_handle_t c; bgfx::UniformHandle cpp; } handle_ret; + handle_ret.cpp = bgfx::createUniform(_name, (bgfx::UniformFreq::Enum)_freq, (bgfx::UniformType::Enum)_type, _num); + return handle_ret.c; +} + BGFX_C_API void bgfx_get_uniform_info(bgfx_uniform_handle_t _handle, bgfx_uniform_info_t * _info) { union { bgfx_uniform_handle_t c; bgfx::UniformHandle cpp; } handle = { _handle }; @@ -699,6 +706,11 @@ BGFX_C_API void bgfx_set_view_order(bgfx_view_id_t _id, uint16_t _num, const bgf bgfx::setViewOrder((bgfx::ViewId)_id, _num, (const bgfx::ViewId*)_order); } +BGFX_C_API void bgfx_set_view_shading_rate(bgfx_view_id_t _id, bgfx_shading_rate_t _shadingRate) +{ + bgfx::setViewShadingRate((bgfx::ViewId)_id, (bgfx::ShadingRate::Enum)_shadingRate); +} + BGFX_C_API void bgfx_reset_view(bgfx_view_id_t _id) { bgfx::resetView((bgfx::ViewId)_id); @@ -776,6 +788,18 @@ BGFX_C_API void bgfx_encoder_set_uniform(bgfx_encoder_t* _this, bgfx_uniform_han This->setUniform(handle.cpp, _value, _num); } +BGFX_C_API void bgfx_set_view_uniform(bgfx_view_id_t _id, bgfx_uniform_handle_t _handle, const void* _value, uint16_t _num) +{ + union { bgfx_uniform_handle_t c; bgfx::UniformHandle cpp; } handle = { _handle }; + bgfx::setViewUniform((bgfx::ViewId)_id, handle.cpp, _value, _num); +} + +BGFX_C_API void bgfx_set_frame_uniform(bgfx_uniform_handle_t _handle, const void* _value, uint16_t _num) +{ + union { bgfx_uniform_handle_t c; bgfx::UniformHandle cpp; } handle = { _handle }; + bgfx::setFrameUniform(handle.cpp, _value, _num); +} + BGFX_C_API void bgfx_encoder_set_index_buffer(bgfx_encoder_t* _this, bgfx_index_buffer_handle_t _handle, uint32_t _firstIndex, uint32_t _numIndices) { bgfx::Encoder* This = (bgfx::Encoder*)_this; @@ -1010,10 +1034,10 @@ BGFX_C_API const bgfx_internal_data_t* bgfx_get_internal_data(void) return (const bgfx_internal_data_t*)bgfx::getInternalData(); } -BGFX_C_API uintptr_t bgfx_override_internal_texture_ptr(bgfx_texture_handle_t _handle, uintptr_t _ptr) +BGFX_C_API uintptr_t bgfx_override_internal_texture_ptr(bgfx_texture_handle_t _handle, uintptr_t _ptr, uint16_t _layerIndex) { union { bgfx_texture_handle_t c; bgfx::TextureHandle cpp; } handle = { _handle }; - return bgfx::overrideInternal(handle.cpp, _ptr); + return bgfx::overrideInternal(handle.cpp, _ptr, _layerIndex); } BGFX_C_API uintptr_t bgfx_override_internal_texture(bgfx_texture_handle_t _handle, uint16_t _width, uint16_t _height, uint8_t _numMips, bgfx_texture_format_t _format, uint64_t _flags) @@ -1387,6 +1411,7 @@ BGFX_C_API bgfx_interface_vtbl_t* bgfx_get_interface(uint32_t _version) bgfx_get_texture, bgfx_destroy_frame_buffer, bgfx_create_uniform, + bgfx_create_uniform_with_freq, bgfx_get_uniform_info, bgfx_destroy_uniform, bgfx_create_occlusion_query, @@ -1405,6 +1430,7 @@ BGFX_C_API bgfx_interface_vtbl_t* bgfx_get_interface(uint32_t _version) bgfx_set_view_frame_buffer, bgfx_set_view_transform, bgfx_set_view_order, + bgfx_set_view_shading_rate, bgfx_reset_view, bgfx_encoder_begin, bgfx_encoder_end, @@ -1418,6 +1444,8 @@ BGFX_C_API bgfx_interface_vtbl_t* bgfx_get_interface(uint32_t _version) bgfx_encoder_set_transform_cached, bgfx_encoder_alloc_transform, bgfx_encoder_set_uniform, + bgfx_set_view_uniform, + bgfx_set_frame_uniform, bgfx_encoder_set_index_buffer, bgfx_encoder_set_dynamic_index_buffer, bgfx_encoder_set_transient_index_buffer, diff --git a/libs/bgfx/src/bgfx_compute.sh b/libs/bgfx/src/bgfx_compute.sh index adcd560..f1bb34f 100644 --- a/libs/bgfx/src/bgfx_compute.sh +++ b/libs/bgfx/src/bgfx_compute.sh @@ -79,18 +79,27 @@ #define COMP_r32ui uint #define COMP_rg32ui uint2 #define COMP_rgba32ui uint4 +#define COMP_r16ui uint +#define COMP_rg16ui uint2 +#define COMP_rgba16ui uint4 #define COMP_r32f float #define COMP_r16f float #define COMP_rg16f float2 #define COMP_rgba16f float4 #if BGFX_SHADER_LANGUAGE_HLSL -# define COMP_rgba8 unorm float4 -# define COMP_rg8 unorm float2 -# define COMP_r8 unorm float +# define COMP_rgba8 unorm float4 +# define COMP_rg8 unorm float2 +# define COMP_r8 unorm float +# define COMP_rgba16 unorm float4 +# define COMP_rg16 unorm float2 +# define COMP_r16 unorm float #else -# define COMP_rgba8 float4 -# define COMP_rg8 float2 -# define COMP_r8 float +# define COMP_rgba8 float4 +# define COMP_rg8 float2 +# define COMP_r8 float +# define COMP_rgba16 float4 +# define COMP_rg16 float2 +# define COMP_r16 float #endif // BGFX_SHADER_LANGUAGE_HLSL #define COMP_rgba32f float4 diff --git a/libs/bgfx/src/bgfx_p.h b/libs/bgfx/src/bgfx_p.h index ec43273..e80b38b 100644 --- a/libs/bgfx/src/bgfx_p.h +++ b/libs/bgfx/src/bgfx_p.h @@ -92,13 +92,13 @@ namespace bgfx } \ BX_MACRO_BLOCK_END -#define _BGFX_ASSERT(_condition, _format, ...) \ - BX_MACRO_BLOCK_BEGIN \ - if (!BX_IGNORE_C4127(_condition) \ - && bx::assertFunction(bx::Location::current(), "ASSERT " #_condition " -> " _format, ##__VA_ARGS__) ) \ - { \ - bgfx::fatal(__FILE__, uint16_t(__LINE__), bgfx::Fatal::DebugCheck, _format, ##__VA_ARGS__); \ - } \ +#define _BGFX_ASSERT(_condition, _format, ...) \ + BX_MACRO_BLOCK_BEGIN \ + if (!BX_IGNORE_C4127(_condition) \ + && bx::assertFunction(bx::Location::current(), 0, "ASSERT " #_condition " -> " _format, ##__VA_ARGS__) ) \ + { \ + bgfx::fatal(__FILE__, uint16_t(__LINE__), bgfx::Fatal::DebugCheck, _format, ##__VA_ARGS__); \ + } \ BX_MACRO_BLOCK_END #define BGFX_FATAL(_condition, _err, _format, ...) \ @@ -148,8 +148,6 @@ namespace bgfx #include "vertexlayout.h" #include "version.h" -#define BGFX_CHUNK_MAGIC_TEX BX_MAKEFOURCC('T', 'E', 'X', 0x0) - #define BGFX_CLEAR_COLOR_USE_PALETTE UINT16_C(0x8000) #define BGFX_CLEAR_MASK (0 \ | BGFX_CLEAR_COLOR \ @@ -287,6 +285,8 @@ namespace stl = std; namespace bgfx { + constexpr uint32_t kChunkMagicTex = BX_MAKEFOURCC('T', 'E', 'X', 0x0); + extern InternalData g_internalData; extern PlatformData g_platformData; extern bool g_platformDataChangedSinceReset; @@ -427,6 +427,7 @@ namespace bgfx }; }; + void* findModule(const char* _name); bool windowsVersionIs(Condition::Enum _op, uint32_t _version, uint32_t _build = UINT32_MAX); constexpr bool isShaderType(uint32_t _magic, char _type) @@ -567,8 +568,6 @@ namespace bgfx extern bx::AllocatorI* g_allocator; extern Caps g_caps; - typedef bx::StringT<&g_allocator> String; - struct ProfilerScope { ProfilerScope(const char* _name, uint32_t _abgr, const char* _filePath, uint16_t _line) @@ -594,6 +593,8 @@ namespace bgfx const char* getName(ShaderHandle _handle); const char* getName(Topology::Enum _topology); + const struct UniformRef& getUniformRef(UniformHandle _handle); + template inline void release(Ty) { @@ -817,7 +818,7 @@ namespace bgfx { for (uint32_t ii = 0; ii < BX_COUNTOF(m_program); ++ii) { - m_program[ii].idx = kInvalidHandle; + m_program[ii] = BGFX_INVALID_HANDLE; } } @@ -1314,33 +1315,43 @@ namespace bgfx }; #undef SORT_KEY_RENDER_DRAW - constexpr uint8_t kBlitKeyViewShift = 32-kSortKeyViewNumBits; - constexpr uint32_t kBlitKeyViewMask = uint32_t(BGFX_CONFIG_MAX_VIEWS-1)<> kBlitKeyItemShift); - m_view = ViewId( (_key & kBlitKeyViewMask) >> kBlitKeyViewShift); + m_item = uint16_t( (_key & kItemMask) >> kItemShift); + m_view = ViewId( (_key & kViewMask) >> kViewShift); } - static uint32_t remapView(uint32_t _key, ViewId _viewRemap[BGFX_CONFIG_MAX_VIEWS]) + static KeyT remapView(KeyT _key, ViewId _viewRemap[BGFX_CONFIG_MAX_VIEWS]) { - const ViewId oldView = ViewId( (_key & kBlitKeyViewMask) >> kBlitKeyViewShift); - const uint32_t view = uint32_t( (_viewRemap[oldView] << kBlitKeyViewShift) & kBlitKeyViewMask); - const uint32_t key = (_key & ~kBlitKeyViewMask) | view; + const ViewId oldView = ViewId( (_key & kViewMask) >> kViewShift); + const KeyT view = uint32_t( (_viewRemap[oldView] << kViewShift) & kViewMask); + const KeyT key = (_key & ~kViewMask) | view; return key; } @@ -1479,7 +1490,7 @@ namespace bgfx class UniformBuffer { public: - static UniformBuffer* create(uint32_t _size = 1<<20) + static UniformBuffer* create(uint32_t _size) { const uint32_t structSize = sizeof(UniformBuffer)-sizeof(UniformBuffer::m_buffer); @@ -1494,13 +1505,16 @@ namespace bgfx bx::free(g_allocator, _uniformBuffer); } - static void update(UniformBuffer** _uniformBuffer, uint32_t _threshold = 64<<10, uint32_t _grow = 1<<20) + static void update(UniformBuffer** _uniformBuffer) { + constexpr uint32_t kThreshold = BGFX_CONFIG_UNIFORM_BUFFER_RESIZE_THRESHOLD_SIZE; + constexpr uint32_t kIncrement = BGFX_CONFIG_UNIFORM_BUFFER_RESIZE_INCREMENT_SIZE; + UniformBuffer* uniformBuffer = *_uniformBuffer; - if (_threshold >= uniformBuffer->m_size - uniformBuffer->m_pos) + if (kThreshold >= uniformBuffer->m_size - uniformBuffer->m_pos) { const uint32_t structSize = sizeof(UniformBuffer)-sizeof(UniformBuffer::m_buffer); - uint32_t size = bx::alignUp(uniformBuffer->m_size + _grow, 16); + uint32_t size = bx::alignUp(uniformBuffer->m_size + kIncrement, 16); void* data = bx::realloc(g_allocator, uniformBuffer, size+structSize); uniformBuffer = reinterpret_cast(data); uniformBuffer->m_size = size; @@ -1679,9 +1693,9 @@ namespace bgfx { void clear() { - m_startVertex = 0; - m_handle.idx = kInvalidHandle; - m_layoutHandle.idx = kInvalidHandle; + m_startVertex = 0; + m_handle = BGFX_INVALID_HANDLE; + m_layoutHandle = BGFX_INVALID_HANDLE; } uint32_t m_startVertex; @@ -1738,7 +1752,7 @@ namespace bgfx m_instanceDataOffset = 0; m_instanceDataStride = 0; m_numInstances = 1; - m_instanceDataBuffer.idx = kInvalidHandle; + m_instanceDataBuffer = BGFX_INVALID_HANDLE; } if (0 != (_flags & BGFX_DISCARD_VERTEX_STREAMS) ) @@ -1750,22 +1764,22 @@ namespace bgfx if (0 != (_flags & BGFX_DISCARD_INDEX_BUFFER) ) { - m_startIndex = 0; - m_numIndices = UINT32_MAX; - m_indexBuffer.idx = kInvalidHandle; - m_submitFlags = 0; + m_startIndex = 0; + m_numIndices = UINT32_MAX; + m_indexBuffer = BGFX_INVALID_HANDLE; + m_submitFlags = 0; } else { m_submitFlags = isIndex16() ? 0 : BGFX_SUBMIT_INTERNAL_INDEX32; } - m_startIndirect = 0; - m_numIndirect = UINT32_MAX; - m_numIndirectIndex = 0; - m_indirectBuffer.idx = kInvalidHandle; - m_numIndirectBuffer.idx = kInvalidHandle; - m_occlusionQuery.idx = kInvalidHandle; + m_startIndirect = 0; + m_numIndirect = UINT32_MAX; + m_numIndirectIndex = 0; + m_indirectBuffer = BGFX_INVALID_HANDLE; + m_numIndirectBuffer = BGFX_INVALID_HANDLE; + m_occlusionQuery = BGFX_INVALID_HANDLE; } bool setStreamBit(uint8_t _stream, VertexBufferHandle _handle) @@ -1828,13 +1842,13 @@ namespace bgfx m_numMatrices = 0; } - m_numX = 0; - m_numY = 0; - m_numZ = 0; - m_submitFlags = 0; - m_indirectBuffer.idx = kInvalidHandle; - m_startIndirect = 0; - m_numIndirect = UINT32_MAX; + m_numX = 0; + m_numY = 0; + m_numZ = 0; + m_submitFlags = 0; + m_indirectBuffer = BGFX_INVALID_HANDLE; + m_startIndirect = 0; + m_numIndirect = UINT32_MAX; } uint32_t m_uniformBegin; @@ -1877,14 +1891,14 @@ namespace bgfx struct IndexBuffer { - String m_name; + bx::FixedString64 m_name; uint32_t m_size; uint16_t m_flags; }; struct VertexBuffer { - String m_name; + bx::FixedString64 m_name; uint32_t m_size; uint16_t m_stride; }; @@ -1934,7 +1948,7 @@ namespace bgfx struct ShaderRef { UniformHandle* m_uniforms; - String m_name; + bx::FixedString64 m_name; uint32_t m_hashIn; uint32_t m_hashOut; uint16_t m_num; @@ -1950,7 +1964,8 @@ namespace bgfx struct UniformRef { - String m_name; + bx::FixedString64 m_name; + UniformFreq::Enum m_freq; UniformType::Enum m_type; uint16_t m_num; int16_t m_refCount; @@ -2015,7 +2030,7 @@ namespace bgfx return 0 < m_depth; } - String m_name; + bx::FixedString64 m_name; void* m_ptr; uint64_t m_flags; uint32_t m_storageSize; @@ -2035,7 +2050,7 @@ namespace bgfx struct FrameBufferRef { - String m_name; + bx::FixedString64 m_name; uint16_t m_width; uint16_t m_height; @@ -2056,6 +2071,7 @@ namespace bgfx setScissor(0, 0, 0, 0); setClear(BGFX_CLEAR_NONE, 0, 0.0f, 0); setMode(ViewMode::Default); + setShadingRate(ShadingRate::Rate1x1); setFrameBuffer(BGFX_INVALID_HANDLE); setTransform(NULL, NULL); } @@ -2091,6 +2107,16 @@ namespace bgfx m_mode = uint8_t(_mode); } + void setShadingRate(ShadingRate::Enum _shadingRate) + { + m_shadingRate = uint8_t(_shadingRate); + } + + void setUniform(UniformHandle _handle, const void* _value, uint16_t _num) + { + BX_UNUSED(_handle, _value, _num); + } + void setFrameBuffer(FrameBufferHandle _handle) { m_fbh = _handle; @@ -2124,6 +2150,150 @@ namespace bgfx Matrix4 m_proj; FrameBufferHandle m_fbh; uint8_t m_mode; + uint8_t m_shadingRate; + }; + + struct UniformCacheKey + { + using KeyT = uint64_t; + + static constexpr uint8_t kViewShift = sizeof(KeyT)*8-kSortKeyViewNumBits; + static constexpr KeyT kViewMask = KeyT(BGFX_CONFIG_MAX_VIEWS-1)<>12)<>4)<>kSizeShift ) + 1)<<4; + constexpr uint32_t kMaxOffset = ( (kOffsetMask>>kOffsetShift) + 1)<<4; + + BX_ASSERT(true + && uint32_t(m_size) < kMaxSize + && m_offset < kMaxOffset + , "UniformCacheKey couldn't fit size or offest (size %d max %d, offset %d max %d)!" + , m_size + , kMaxSize + , m_offset + , kMaxOffset + ); + + const KeyT view = (KeyT(m_view) << kViewShift) & kViewMask; + const KeyT handle = (KeyT(m_handle) << kHandleShift) & kHandleMask; + const KeyT offset = (KeyT(m_offset>>4) << kOffsetShift) & kOffsetMask; + const KeyT size = (KeyT(m_size>>4) << kSizeShift) & kSizeMask; + const KeyT key = view|handle|offset|size; + + return key; + } + + void decode(KeyT _key) + { + m_offset = (uint32_t( (_key & kOffsetMask) >> kOffsetShift) ) << 4; + m_handle = {uint16_t( (_key & kHandleMask) >> kHandleShift) }; + m_size = (uint16_t( (_key & kSizeMask) >> kSizeShift ) ) << 4; + m_view = ViewId( (_key & kViewMask) >> kViewShift); + } + + static KeyT remapView(KeyT _key, ViewId _viewRemap[BGFX_CONFIG_MAX_VIEWS]) + { + const ViewId oldView = ViewId( (_key & kViewMask) >> kViewShift); + const KeyT view = UINT16_MAX != oldView + ? (KeyT(_viewRemap[oldView]) << kViewShift) & kViewMask + : 0 // frame uniforms go into physical view 0. + ; + const KeyT key = (_key & ~kViewMask) | view; + return key; + } + + uint32_t m_offset; + uint16_t m_handle; + uint16_t m_size; + ViewId m_view; + }; + + struct UniformCacheEntry + { + uint32_t offset; + uint16_t size; + int16_t refCount; + }; + + struct UniformCacheFrame + { + static constexpr uint32_t kMinKeysCapacity = 256; + static constexpr uint32_t kMinDataCapacity = 16<<10; + + UniformCacheFrame() + : m_keys(NULL) + , m_data(NULL) + , m_numItems(0) + , m_keysCapacity(kMinKeysCapacity) + , m_dataCapacity(kMinDataCapacity) + { + m_keys = (UniformCacheKey::KeyT*)bx::alloc(g_allocator, m_keysCapacity*sizeof(uint64_t) ); + m_data = (uint8_t*)bx::alloc(g_allocator, m_dataCapacity); + } + + ~UniformCacheFrame() + { + bx::free(g_allocator, m_keys); + bx::free(g_allocator, m_data); + } + + void resize(uint32_t _keysCapacity, uint32_t _dataCapacity) + { + { + const uint32_t newKeysCapacity = bx::alignUp(bx::max(_keysCapacity, kMinKeysCapacity), kMinKeysCapacity); + + if (newKeysCapacity != m_keysCapacity) + { + m_keys = (UniformCacheKey::KeyT*)bx::realloc(g_allocator, m_keys, newKeysCapacity * sizeof(uint64_t)); + m_keysCapacity = newKeysCapacity; + } + } + + { + const uint32_t newDataCapacity = bx::alignUp(bx::max(_dataCapacity, kMinDataCapacity), kMinDataCapacity); + + if (newDataCapacity != m_dataCapacity) + { + m_data = (uint8_t*)bx::realloc(g_allocator, m_data, newDataCapacity); + m_dataCapacity = newDataCapacity; + } + } + } + + void sort(ViewId* _viewRemap, uint64_t* _tempKeys) + { + for (uint32_t ii = 0, num = m_numItems; ii < num; ++ii) + { + m_keys[ii] = UniformCacheKey::remapView(m_keys[ii], _viewRemap); + } + + bx::radixSort(m_keys, _tempKeys, m_numItems); + } + + uint64_t* m_keys; + uint8_t* m_data; + uint32_t m_numItems; + uint32_t m_keysCapacity; + uint32_t m_dataCapacity; }; struct FrameCache @@ -2173,7 +2343,7 @@ namespace bgfx m_perfStats.viewStats = m_viewStats; - bx::memSet(&m_renderItemBind[0], 0, sizeof(m_renderItemBind)); + bx::memSet(&m_renderItemBind[0], 0, sizeof(m_renderItemBind) ); } ~Frame() @@ -2192,7 +2362,7 @@ namespace bgfx for (uint32_t ii = 0; ii < num; ++ii) { - m_uniformBuffer[ii] = UniformBuffer::create(); + m_uniformBuffer[ii] = UniformBuffer::create(g_caps.limits.minUniformBufferSize); } } @@ -2248,7 +2418,7 @@ namespace bgfx { const uint32_t offset = bx::strideAlign(m_iboffset, _indexSize); uint32_t iboffset = offset + _num*_indexSize; - iboffset = bx::min(iboffset, g_caps.limits.transientIbSize); + iboffset = bx::min(iboffset, g_caps.limits.maxTransientIbSize); const uint32_t num = (iboffset-offset)/_indexSize; return num; } @@ -2267,7 +2437,7 @@ namespace bgfx { uint32_t offset = bx::strideAlign(m_vboffset, _stride); uint32_t vboffset = offset + _num * _stride; - vboffset = bx::min(vboffset, g_caps.limits.transientVbSize); + vboffset = bx::min(vboffset, g_caps.limits.maxTransientVbSize); uint32_t num = (vboffset-offset)/_stride; return num; } @@ -2349,6 +2519,8 @@ namespace bgfx uint32_t m_blitKeys[BGFX_CONFIG_MAX_BLIT_ITEMS+1]; BlitItem m_blitItem[BGFX_CONFIG_MAX_BLIT_ITEMS+1]; + UniformCacheFrame m_uniformCacheFrame; + FrameCache m_frameCache; UniformBuffer** m_uniformBuffer; @@ -2456,7 +2628,7 @@ namespace bgfx // will leaves bytes uninitialized. This will influence the hashing // as it reads those bytes too. To make this deterministic, we will // clear all bytes (inclusively the padding) before we start. - bx::memSet(&m_bind, 0, sizeof(m_bind)); + bx::memSet(&m_bind, 0, sizeof(m_bind) ); discard(BGFX_DISCARD_ALL); } @@ -2515,7 +2687,13 @@ namespace bgfx , _handle.idx , getName(_handle) ); -// m_uniformSet.insert(_handle.idx); + m_uniformSet.insert(_handle.idx); + + const UniformRef& uniform = getUniformRef(_handle); + BX_ASSERT(UniformFreq::Draw == uniform.m_freq + , "Setting uniform for draw call, but uniform frequency is different (frequency: %d)!" + , uniform.m_freq + ); } UniformBuffer::update(&m_frame->m_uniformBuffer[m_uniformIdx]); @@ -2888,7 +3066,7 @@ namespace bgfx void add(VertexBufferHandle _handle, VertexLayoutHandle _layoutHandle, uint32_t _hash) { - BX_ASSERT(m_vertexBufferRef[_handle.idx].idx == kInvalidHandle, ""); + BX_ASSERT(!isValid(m_vertexBufferRef[_handle.idx]), ""); m_vertexBufferRef[_handle.idx] = _layoutHandle; m_refCount[_layoutHandle.idx]++; m_vertexLayoutMap.insert(_hash, _layoutHandle.idx); @@ -2896,7 +3074,7 @@ namespace bgfx void add(DynamicVertexBufferHandle _handle, VertexLayoutHandle _layoutHandle, uint32_t _hash) { - BX_ASSERT(m_dynamicVertexBufferRef[_handle.idx].idx == kInvalidHandle, ""); + BX_ASSERT(!isValid(m_dynamicVertexBufferRef[_handle.idx]), ""); m_dynamicVertexBufferRef[_handle.idx] = _layoutHandle; m_refCount[_layoutHandle.idx]++; m_vertexLayoutMap.insert(_hash, _layoutHandle.idx); @@ -2922,7 +3100,7 @@ namespace bgfx { VertexLayoutHandle layoutHandle = m_vertexBufferRef[_handle.idx]; layoutHandle = release(layoutHandle); - m_vertexBufferRef[_handle.idx].idx = kInvalidHandle; + m_vertexBufferRef[_handle.idx] = BGFX_INVALID_HANDLE; return layoutHandle; } @@ -2931,7 +3109,7 @@ namespace bgfx { VertexLayoutHandle layoutHandle = m_dynamicVertexBufferRef[_handle.idx]; layoutHandle = release(layoutHandle); - m_dynamicVertexBufferRef[_handle.idx].idx = kInvalidHandle; + m_dynamicVertexBufferRef[_handle.idx] = BGFX_INVALID_HANDLE; return layoutHandle; } @@ -2951,6 +3129,7 @@ namespace bgfx static const uint64_t kInvalidBlock = UINT64_MAX; NonLocalAllocator() + : m_total(0) { } @@ -2962,6 +3141,7 @@ namespace bgfx { m_free.clear(); m_used.clear(); + m_total = 0; } void add(uint64_t _ptr, uint32_t _size) @@ -2994,6 +3174,7 @@ namespace bgfx uint64_t ptr = it->m_ptr; m_used.insert(stl::make_pair(ptr, _size) ); + m_total += _size; if (it->m_size != _size) { @@ -3018,6 +3199,8 @@ namespace bgfx UsedList::iterator it = m_used.find(_block); if (it != m_used.end() ) { + m_total -= it->second; + m_free.push_front(Free(it->first, it->second) ); m_used.erase(it); } @@ -3044,6 +3227,11 @@ namespace bgfx return 0 == m_used.size(); } + uint32_t getTotal() const + { + return m_total; + } + private: struct Free { @@ -3067,6 +3255,265 @@ namespace bgfx typedef stl::unordered_map UsedList; UsedList m_used; + + uint32_t m_total; + }; + + struct UniformCache + { + UniformCache() + { + const uint32_t size = 1<<20; + m_data = (uint8_t*)bx::alloc(g_allocator, size); + m_uniformStoreAlloc.add(0, size); + } + + ~UniformCache() + { + BX_ASSERT(true + && 0 == m_uniformKeyHashMap.size() + && 0 == m_uniformEntryMap.size() + && 0 == m_uniformStoreAlloc.getTotal() + , "UniformCache leak (keys %d, entries %d, %d bytes)!" + , m_uniformKeyHashMap.size() + , m_uniformEntryMap.size() + , m_uniformStoreAlloc.getTotal() + ); + + bx::free(g_allocator, m_data); + m_uniformKeyHashMap.clear(); + m_uniformEntryMap.clear(); + } + + void setViewUniform(ViewId _id, UniformHandle _handle, const void* _value, uint16_t _num) + { + const UniformRef& uniform = getUniformRef(_handle); + + const UniformFreq::Enum freq = UINT16_MAX == _id + ? UniformFreq::Frame + : UniformFreq::View + ; + + BX_ASSERT(0 < uniform.m_refCount + , "Uniform reference count it 0 (handle %3d)!" + , _handle.idx + ); + BX_ASSERT(uniform.m_freq == freq + , "Setting uniform per view, but uniform is created with different bgfx::UniformFreq::Enum!" + ); + BX_ASSERT(_num == UINT16_MAX || uniform.m_num >= _num + , "Truncated uniform update. %d (max: %d)" + , _num, uniform.m_num + ); + + UniformCacheKey key = + { + .m_offset = 0, + .m_handle = _handle.idx, + .m_size = 0, + .m_view = _id, + }; + + constexpr UniformCacheKey::KeyT kViewHandleMask = UniformCacheKey::kViewMask|UniformCacheKey::kHandleMask; + static_assert( ( (kViewHandleMask>>32)<<32) == kViewHandleMask, "View + handle must be in top 32 bits of 64-bit key."); + const uint32_t uniformKey = uint32_t(key.encode() >> 32); + + setUniform(uniformKey, uniform.m_type, _value, _num); + } + + void setUniform(uint32_t _uniformKey, UniformType::Enum _type, const void* _value, uint16_t _num) + { + const uint32_t typeSize = g_uniformTypeSize[_type]; + const uint32_t dataSize = _num * typeSize; + + bx::HashMurmur3 murmur; + murmur.begin(); + murmur.add(_type); + murmur.add(_num); + murmur.add(_value, dataSize); + const uint32_t hash = murmur.end(); + + UniformKeyHashMap::iterator itKey = m_uniformKeyHashMap.find(_uniformKey); + if (itKey != m_uniformKeyHashMap.end() ) + { + if (itKey->second == hash) + { + return; + } + + UniformEntryMap::iterator itOldEntry = m_uniformEntryMap.find(itKey->second); + if (itOldEntry != m_uniformEntryMap.end()) + { + if (release(itOldEntry->second) ) + { + m_uniformEntryMap.erase(itOldEntry); + } + } + + itKey->second = hash; + + UniformEntryMap::iterator itEntry = m_uniformEntryMap.find(hash); + if (itEntry != m_uniformEntryMap.end()) + { + ++itEntry->second.refCount; + + return; + } + } + else + { + m_uniformKeyHashMap.insert(stl::make_pair(_uniformKey, hash) ); + } + + UniformEntryMap::iterator itEntry = m_uniformEntryMap.find(hash); + if (itEntry != m_uniformEntryMap.end()) + { + ++itEntry->second.refCount; + } + else + { + const uint64_t offset = m_uniformStoreAlloc.alloc(dataSize); + BX_ASSERT(NonLocalAllocator::kInvalidBlock != offset, "UniformCache: Failed to allocate data!"); + + m_uniformEntryMap.insert(stl::make_pair(hash, UniformCacheEntry + { + .offset = bx::narrowCast(offset), + .size = bx::narrowCast(dataSize), + .refCount = 1 + }) ); + + bx::memCopy(&m_data[offset], _value, dataSize); + } + } + + void frame(UniformCacheFrame& _outUniformCacheFrame) + { + m_uniformStoreAlloc.compact(); + + _outUniformCacheFrame.resize( + uint32_t(m_uniformKeyHashMap.size() ) + , m_uniformStoreAlloc.getTotal() + ); + + using OffsetRemap = stl::unordered_map; + OffsetRemap offsetRemap; + + uint32_t linearOffset = 0; + uint32_t num = 0; + for (UniformKeyHashMap::const_iterator itKey = m_uniformKeyHashMap.begin(), itEnd = m_uniformKeyHashMap.end(); itKey != itEnd; ++itKey) + { + UniformEntryMap::iterator itEntry = m_uniformEntryMap.find(itKey->second); + BX_ASSERT(itEntry != m_uniformEntryMap.end() + , "Couldn't find uniform cache entry for key 0x%d, hash 0x%x!" + , itKey->first + , itKey->second + ); + + const uint32_t offset = itEntry->second.offset; + const uint16_t size = itEntry->second.size; + + UniformCacheKey key; + key.decode(uint64_t(itKey->first)<<32); + key.m_size = size; + + OffsetRemap::const_iterator itOffset = offsetRemap.find(offset); + if (itOffset != offsetRemap.end()) + { + key.m_offset = itOffset->second; + } + else + { + key.m_offset = linearOffset; + + offsetRemap.insert(stl::make_pair(offset, linearOffset) ); + bx::memCopy(&_outUniformCacheFrame.m_data[linearOffset], &m_data[offset], size); + + linearOffset += size; + } + + _outUniformCacheFrame.m_keys[num++] = key.encode(); + } + + _outUniformCacheFrame.m_numItems = num; + } + + void invalidate(ViewId _viewId) + { + for (UniformKeyHashMap::iterator itKey = m_uniformKeyHashMap.begin(), itEnd = m_uniformKeyHashMap.end(); itKey != itEnd; ++itKey) + { + UniformCacheKey key; + key.decode(uint64_t(itKey->first) << 32); + + if (key.m_view == _viewId) + { + release(itKey->second); + + UniformKeyHashMap::iterator itErase = itKey; + ++itKey; + + m_uniformKeyHashMap.erase(itErase); + } + } + } + + void invalidate(UniformHandle _handle) + { + for (UniformKeyHashMap::iterator itKey = m_uniformKeyHashMap.begin(), itEnd = m_uniformKeyHashMap.end(); itKey != itEnd;) + { + UniformCacheKey key; + key.decode(uint64_t(itKey->first) << 32); + + if (key.m_handle == _handle.idx) + { + release(itKey->second); + + UniformKeyHashMap::iterator itErase = itKey; + ++itKey; + + m_uniformKeyHashMap.erase(itErase); + } + else + { + ++itKey; + } + } + } + + bool release(UniformCacheEntry& _entry) + { + --_entry.refCount; + + if (0 == _entry.refCount) + { + const uint64_t offset = _entry.offset; + + m_uniformStoreAlloc.free(offset); + return true; + } + + return false; + } + + void release(uint32_t _hash) + { + UniformEntryMap::iterator itEntry = m_uniformEntryMap.find(_hash); + if (itEntry != m_uniformEntryMap.end()) + { + if (release(itEntry->second) ) + { + m_uniformEntryMap.erase(itEntry); + } + } + } + + using UniformKeyHashMap = stl::unordered_map; + using UniformEntryMap = stl::unordered_map; + + UniformKeyHashMap m_uniformKeyHashMap; + UniformEntryMap m_uniformEntryMap; + + NonLocalAllocator m_uniformStoreAlloc; + uint8_t* m_data; }; struct BX_NO_VTABLE RendererContextI @@ -3098,7 +3545,7 @@ namespace bgfx virtual void updateTextureEnd() = 0; virtual void readTexture(TextureHandle _handle, void* _data, uint8_t _mip) = 0; virtual void resizeTexture(TextureHandle _handle, uint16_t _width, uint16_t _height, uint8_t _numMips, uint16_t _numLayers) = 0; - virtual void overrideInternal(TextureHandle _handle, uintptr_t _ptr) = 0; + virtual void overrideInternal(TextureHandle _handle, uintptr_t _ptr, uint16_t _layerIndex) = 0; virtual uintptr_t getInternal(TextureHandle _handle) = 0; virtual void destroyTexture(TextureHandle _handle) = 0; virtual void createFrameBuffer(FrameBufferHandle _handle, uint8_t _num, const Attachment* _attachment) = 0; @@ -3180,7 +3627,7 @@ namespace bgfx return cmdbuf; } - BGFX_API_FUNC(void reset(uint32_t _width, uint32_t _height, uint32_t _flags, TextureFormat::Enum _format) ) + BGFX_API_FUNC(void reset(uint32_t _width, uint32_t _height, uint32_t _flags, TextureFormat::Enum _formatColor) ) { BGFX_MUTEX_SCOPE(m_resourceApiLock); @@ -3191,13 +3638,17 @@ namespace bgfx , "Running in headless mode, resolution of non-existing backbuffer can't be larger than 0x0!" ); - const TextureFormat::Enum format = TextureFormat::Count != _format ? _format : m_init.resolution.format; + const TextureFormat::Enum formatColor = TextureFormat::Count != _formatColor + ? _formatColor + : m_init.resolution.formatColor + ; if (!g_platformDataChangedSinceReset - && m_init.resolution.format == format - && m_init.resolution.width == _width - && m_init.resolution.height == _height - && m_init.resolution.reset == _flags) + && m_init.resolution.formatColor == formatColor + && m_init.resolution.width == _width + && m_init.resolution.height == _height + && m_init.resolution.reset == _flags + ) { // Nothing changed, ignore request. return; @@ -3229,7 +3680,7 @@ namespace bgfx , _width , _height ); - m_init.resolution.format = format; + m_init.resolution.formatColor = formatColor; m_init.resolution.width = bx::clamp(_width, 1u, g_caps.limits.maxTextureSize); m_init.resolution.height = bx::clamp(_height, 1u, g_caps.limits.maxTextureSize); m_init.resolution.reset = 0 @@ -4066,6 +4517,7 @@ namespace bgfx IndirectBufferHandle createIndirectBuffer(uint32_t _num) { + BGFX_MUTEX_SCOPE(m_resourceApiLock); BX_UNUSED(_num); IndirectBufferHandle handle = { m_vertexBufferHandle.alloc() }; @@ -4086,6 +4538,7 @@ namespace bgfx void destroyIndirectBuffer(IndirectBufferHandle _handle) { + BGFX_MUTEX_SCOPE(m_resourceApiLock); VertexBufferHandle handle = { _handle.idx }; BGFX_CHECK_HANDLE("destroyDrawIndirectBuffer", m_vertexBufferHandle, handle); @@ -4231,9 +4684,10 @@ namespace bgfx } PredefinedUniform::Enum predefined = nameToPredefinedUniformEnum(name); - if (PredefinedUniform::Count == predefined && UniformType::End != UniformType::Enum(type) ) + if (PredefinedUniform::Count == predefined + && UniformType::End != UniformType::Enum(type) ) { - uniforms[sr.m_num] = createUniform(name, UniformType::Enum(type), num); + uniforms[sr.m_num] = createUniform(name, UniformFreq::Count, UniformType::Enum(type), num); sr.m_num++; } } @@ -4888,7 +5342,7 @@ namespace bgfx } } - BGFX_API_FUNC(UniformHandle createUniform(const char* _name, UniformType::Enum _type, uint16_t _num) ) + BGFX_API_FUNC(UniformHandle createUniform(const char* _name, UniformFreq::Enum _freq, UniformType::Enum _type, uint16_t _num) ) { BGFX_MUTEX_SCOPE(m_resourceApiLock); @@ -4915,8 +5369,14 @@ namespace bgfx , uniform.m_type ); - uint32_t oldsize = g_uniformTypeSize[uniform.m_type]; - uint32_t newsize = g_uniformTypeSize[_type]; + const uint32_t oldsize = g_uniformTypeSize[uniform.m_type]; + const uint32_t newsize = g_uniformTypeSize[_type]; + + if (UniformFreq::Count != _freq) + { + // Ignore shader created uniforms, and use UniformFreq when user creates uniform. + uniform.m_freq = _freq; + } if (oldsize < newsize || uniform.m_num < _num) @@ -4952,6 +5412,10 @@ namespace bgfx UniformRef& uniform = m_uniformRef[handle.idx]; uniform.m_name.set(_name); uniform.m_refCount = 1; + uniform.m_freq = UniformFreq::Count == _freq + ? UniformFreq::Draw + : _freq + ; uniform.m_type = _type; uniform.m_num = _num; @@ -4976,7 +5440,7 @@ namespace bgfx BGFX_CHECK_HANDLE("getUniformInfo", m_uniformHandle, _handle); UniformRef& uniform = m_uniformRef[_handle.idx]; - bx::strCopy(_info.name, sizeof(_info.name), uniform.m_name.getPtr() ); + bx::strCopy(_info.name, sizeof(_info.name), uniform.m_name); _info.type = uniform.m_type; _info.num = uniform.m_num; } @@ -5154,11 +5618,6 @@ namespace bgfx m_view[_id].setTransform(_view, _proj); } - BGFX_API_FUNC(void resetView(ViewId _id) ) - { - m_view[_id].reset(); - } - BGFX_API_FUNC(void setViewOrder(ViewId _id, uint16_t _num, const ViewId* _order) ) { const uint32_t num = bx::min(_id + _num, BGFX_CONFIG_MAX_VIEWS) - _id; @@ -5176,6 +5635,22 @@ namespace bgfx } } + BGFX_API_FUNC(void setViewShadingRate(ViewId _id, ShadingRate::Enum _shadingRate) ) + { + m_view[_id].setShadingRate(_shadingRate); + } + + BGFX_API_FUNC(void setViewUniform(ViewId _id, UniformHandle _handle, const void* _value, uint16_t _num) ) + { + m_uniformCache.setViewUniform(_id, _handle, _value, _num); + } + + BGFX_API_FUNC(void resetView(ViewId _id) ) + { + m_view[_id].reset(); + m_uniformCache.invalidate(_id); + } + BGFX_API_FUNC(Encoder* begin(bool _forThread) ); BGFX_API_FUNC(void end(Encoder* _encoder) ); @@ -5367,6 +5842,8 @@ namespace bgfx uint32_t m_seq[BGFX_CONFIG_MAX_VIEWS]; View m_view[BGFX_CONFIG_MAX_VIEWS]; + UniformCache m_uniformCache; + float m_clearColor[BGFX_CONFIG_MAX_COLOR_PALETTE][4]; uint8_t m_colorPaletteDirty; diff --git a/libs/bgfx/src/config.h b/libs/bgfx/src/config.h index 596d724..5b3592a 100644 --- a/libs/bgfx/src/config.h +++ b/libs/bgfx/src/config.h @@ -170,6 +170,11 @@ # define BGFX_CONFIG_RENDERER_DIRECT3D11_USE_STAGING_BUFFER 0 #endif // BGFX_CONFIG_RENDERER_DIRECT3D11_USE_STAGING_BUFFER +/// Configure the amount of max descriptor sets per frame for Vulkan +#ifndef BGFX_CONFIG_RENDERER_VULKAN_MAX_DESCRIPTOR_SETS_PER_FRAME +# define BGFX_CONFIG_RENDERER_VULKAN_MAX_DESCRIPTOR_SETS_PER_FRAME 1024 +#endif // BGFX_CONFIG_RENDERER_VULKAN_MAX_DESCRIPTOR_SETS_PER_FRAME + /// Enable use of tinystl. #ifndef BGFX_CONFIG_USE_TINYSTL # define BGFX_CONFIG_USE_TINYSTL 1 @@ -316,37 +321,56 @@ static_assert(bx::isPowerOf2(BGFX_CONFIG_MAX_VIEWS), "BGFX_CONFIG_MAX_VIEWS must # define BGFX_CONFIG_MIN_RESOURCE_COMMAND_BUFFER_SIZE (64<<10) #endif // BGFX_CONFIG_MIN_RESOURCE_COMMAND_BUFFER_SIZE -#ifndef BGFX_CONFIG_TRANSIENT_VERTEX_BUFFER_SIZE -# define BGFX_CONFIG_TRANSIENT_VERTEX_BUFFER_SIZE (6<<20) -#endif // BGFX_CONFIG_TRANSIENT_VERTEX_BUFFER_SIZE - -#ifndef BGFX_CONFIG_TRANSIENT_INDEX_BUFFER_SIZE -# define BGFX_CONFIG_TRANSIENT_INDEX_BUFFER_SIZE (2<<20) -#endif // BGFX_CONFIG_TRANSIENT_INDEX_BUFFER_SIZE - -#ifndef BGFX_CONFIG_PER_FRAME_SCRATCH_STAGING_BUFFER_SIZE -/// Amount of scratch buffer size (per in-flight frame) that will be reserved -/// for staging data for copying to the device (such as vertex buffer data, -/// texture data, etc). This buffer will be used instead of allocating memory -/// on device separately for every data copy. -/// Note: Currently only used by the Vulkan backend. -# define BGFX_CONFIG_PER_FRAME_SCRATCH_STAGING_BUFFER_SIZE (32<<20) -#endif - -#ifndef BGFX_CONFIG_MAX_BYTES_CACHED_DEVICE_MEMORY_ALLOCATIONS +#ifndef BGFX_CONFIG_MAX_TRANSIENT_VERTEX_BUFFER_SIZE +/// Maximum transient vertex buffer size. There is no growth, and all transient +/// vertices must fit into this buffer. +# define BGFX_CONFIG_MAX_TRANSIENT_VERTEX_BUFFER_SIZE (6<<20) +#endif // BGFX_CONFIG_MAX_TRANSIENT_VERTEX_BUFFER_SIZE + +#ifndef BGFX_CONFIG_MAX_TRANSIENT_INDEX_BUFFER_SIZE +/// Maximum transient index buffer size. There is no growth, and all transient +/// indices must fit into this buffer. +# define BGFX_CONFIG_MAX_TRANSIENT_INDEX_BUFFER_SIZE (2<<20) +#endif // BGFX_CONFIG_MAX_TRANSIENT_INDEX_BUFFER_SIZE + +#ifndef BGFX_CONFIG_MIN_UNIFORM_BUFFER_SIZE +/// Mimumum uniform buffer size. This buffer will resize on demand. +# define BGFX_CONFIG_MIN_UNIFORM_BUFFER_SIZE (1<<20) +#endif // BGFX_CONFIG_MIN_UNIFORM_BUFFER_SIZE + +#ifndef BGFX_CONFIG_UNIFORM_BUFFER_RESIZE_THRESHOLD_SIZE +/// Max amount of unused uniform buffer space before uniform buffer resize. +# define BGFX_CONFIG_UNIFORM_BUFFER_RESIZE_THRESHOLD_SIZE (64<<10) +#endif // BGFX_CONFIG_UNIFORM_BUFFER_RESIZE_THRESHOLD_SIZE + +#ifndef BGFX_CONFIG_UNIFORM_BUFFER_RESIZE_INCREMENT_SIZE +/// Increment of uniform buffer resize. +# define BGFX_CONFIG_UNIFORM_BUFFER_RESIZE_INCREMENT_SIZE (1<<20) +#endif // BGFX_CONFIG_UNIFORM_BUFFER_RESIZE_INCREMENT_SIZE + +#ifndef BGFX_CONFIG_CACHED_DEVICE_MEMORY_ALLOCATIONS_SIZE /// Amount of allowed memory allocations left on device to use for recycling during /// later allocations. This can be beneficial in case the driver is slow allocating memory /// on the device. /// Note: Currently only used by the Vulkan backend. -# define BGFX_CONFIG_MAX_BYTES_CACHED_DEVICE_MEMORY_ALLOCATIONS (128 << 20) -#endif +# define BGFX_CONFIG_CACHED_DEVICE_MEMORY_ALLOCATIONS_SIZE (128 << 20) +#endif // BGFX_CONFIG_CACHED_DEVICE_MEMORY_ALLOCATIONS_SIZE -#ifndef BGFX_CONFIG_MAX_STAGING_SIZE_FOR_SCRATCH_BUFFER +#ifndef BGFX_CONFIG_MAX_STAGING_SCRATCH_BUFFER_SIZE /// The threshold of data size above which the staging scratch buffer will /// not be used, but instead a separate device memory allocation will take /// place to stage the data for copying to device. -# define BGFX_CONFIG_MAX_STAGING_SIZE_FOR_SCRATCH_BUFFER (16 << 20) -#endif +# define BGFX_CONFIG_MAX_STAGING_SCRATCH_BUFFER_SIZE (16 << 20) +#endif // BGFX_CONFIG_MAX_STAGING_SCRATCH_BUFFER_SIZE + +#ifndef BGFX_CONFIG_MAX_SCRATCH_STAGING_BUFFER_PER_FRAME_SIZE +/// Amount of scratch buffer size (per in-flight frame) that will be reserved +/// for staging data for copying to the device (such as vertex buffer data, +/// texture data, etc). This buffer will be used instead of allocating memory +/// on device separately for every data copy. +/// Note: Currently only used by the Vulkan backend. +# define BGFX_CONFIG_MAX_SCRATCH_STAGING_BUFFER_PER_FRAME_SIZE (32<<20) +#endif // BGFX_CONFIG_MAX_SCRATCH_STAGING_BUFFER_PER_FRAME_SIZE #ifndef BGFX_CONFIG_MAX_INSTANCE_DATA_COUNT # define BGFX_CONFIG_MAX_INSTANCE_DATA_COUNT 5 diff --git a/libs/bgfx/src/debug_renderdoc.cpp b/libs/bgfx/src/debug_renderdoc.cpp index fedbed9..ee03b85 100644 --- a/libs/bgfx/src/debug_renderdoc.cpp +++ b/libs/bgfx/src/debug_renderdoc.cpp @@ -6,65 +6,12 @@ #include "bgfx_p.h" #if BX_PLATFORM_WINDOWS || BX_PLATFORM_LINUX -# if BX_PLATFORM_WINDOWS -# ifndef WIN32_LEAN_AND_MEAN -# define WIN32_LEAN_AND_MEAN -# endif // WIN32_LEAN_AND_MEAN -# include -# include -# endif // BX_PLATFORM_WINDOWS # include namespace bgfx { - void* findModule(const char* _name) - { -#if BX_PLATFORM_WINDOWS - // NOTE: there was some reason to do it this way instead of simply calling GetModuleHandleA, - // but not sure what it was. - HANDLE process = GetCurrentProcess(); - DWORD size; - BOOL result = EnumProcessModules(process - , NULL - , 0 - , &size - ); - if (0 != result) - { - HMODULE* modules = (HMODULE*)BX_STACK_ALLOC(size); - result = EnumProcessModules(process - , modules - , size - , &size - ); - - if (0 != result) - { - char moduleName[MAX_PATH]; - for (uint32_t ii = 0, num = uint32_t(size/sizeof(HMODULE) ); ii < num; ++ii) - { - result = GetModuleBaseNameA(process - , modules[ii] - , moduleName - , BX_COUNTOF(moduleName) - ); - if (0 != result - && 0 == bx::strCmpI(_name, moduleName) ) - { - return (void*)modules[ii]; - } - } - } - } -#else - BX_UNUSED(_name); -#endif // BX_PLATFORM_WINDOWS - - return NULL; - } - pRENDERDOC_GetAPI RENDERDOC_GetAPI; - static RENDERDOC_API_1_1_2* s_renderDoc = NULL; + static RENDERDOC_API_1_6_0* s_renderDoc = NULL; static void* s_renderDocDll = NULL; void* loadRenderDoc() @@ -80,18 +27,25 @@ namespace bgfx return NULL; } - // If RenderDoc is already injected in the process then use the already present DLL - void* renderDocDll = findModule("renderdoc.dll"); - if (NULL == renderDocDll) - { - // TODO: try common installation paths before looking in current directory - renderDocDll = bx::dlopen( + const char* renderDocDllName = #if BX_PLATFORM_WINDOWS - "renderdoc.dll" + "renderdoc.dll" #else - "./librenderdoc.so" + "librenderdoc.so" #endif // BX_PLATFORM_WINDOWS - ); + ; + + // If RenderDoc is already injected in the process then use the already present DLL + void* renderDocDll = findModule(renderDocDllName); + + if (NULL == renderDocDll) + { + BX_TRACE("Loading RenderDoc..."); + renderDocDll = bx::dlopen(renderDocDllName); + } + else + { + BX_TRACE("RenderDoc is already loaded."); } if (NULL != renderDocDll) @@ -99,7 +53,7 @@ namespace bgfx RENDERDOC_GetAPI = (pRENDERDOC_GetAPI)bx::dlsym(renderDocDll, "RENDERDOC_GetAPI"); if (NULL != RENDERDOC_GetAPI - && 1 == RENDERDOC_GetAPI(eRENDERDOC_API_Version_1_1_2, (void**)&s_renderDoc) ) + && 1 == RENDERDOC_GetAPI(eRENDERDOC_API_Version_1_6_0, (void**)&s_renderDoc) ) { s_renderDoc->SetCaptureFilePathTemplate(BGFX_CONFIG_RENDERDOC_LOG_FILEPATH); @@ -108,8 +62,8 @@ namespace bgfx RENDERDOC_InputButton captureKeys[] = BGFX_CONFIG_RENDERDOC_CAPTURE_KEYS; s_renderDoc->SetCaptureKeys(captureKeys, BX_COUNTOF(captureKeys) ); - s_renderDoc->SetCaptureOptionU32(eRENDERDOC_Option_AllowVSync, 1); - s_renderDoc->SetCaptureOptionU32(eRENDERDOC_Option_SaveAllInitials, 1); + s_renderDoc->SetCaptureOptionU32(eRENDERDOC_Option_AllowVSync, 1); + s_renderDoc->SetCaptureOptionU32(eRENDERDOC_Option_APIValidation, 1); s_renderDoc->MaskOverlayBits(eRENDERDOC_Overlay_None, eRENDERDOC_Overlay_None); diff --git a/libs/bgfx/src/dxgi.cpp b/libs/bgfx/src/dxgi.cpp index 0ffc3d7..b45fa05 100644 --- a/libs/bgfx/src/dxgi.cpp +++ b/libs/bgfx/src/dxgi.cpp @@ -624,13 +624,16 @@ namespace bgfx return S_OK; } -#if BX_PLATFORM_WINRT HRESULT Dxgi::removeSwapChain(const SwapChainDesc& _scd) { +#if BX_PLATFORM_WINRT IInspectable* nativeWindow = reinterpret_cast(_scd.nwh); return setSwapChain(nativeWindow, NULL); - } +#else + BX_UNUSED(_scd); + return S_OK; #endif // BX_PLATFORM_WINRT + } void Dxgi::updateHdr10(SwapChainI* _swapChain, const SwapChainDesc& _scd) { diff --git a/libs/bgfx/src/dxgi.h b/libs/bgfx/src/dxgi.h index 9bf3bbe..e16ac6e 100644 --- a/libs/bgfx/src/dxgi.h +++ b/libs/bgfx/src/dxgi.h @@ -88,10 +88,8 @@ namespace bgfx /// HRESULT createSwapChain(IUnknown* _device, const SwapChainDesc& _scd, SwapChainI** _swapChain); -#if BX_PLATFORM_WINRT /// HRESULT removeSwapChain(const SwapChainDesc& _scd); -#endif /// void updateHdr10(SwapChainI* _swapChain, const SwapChainDesc& _scd); diff --git a/libs/bgfx/src/glcontext_egl.cpp b/libs/bgfx/src/glcontext_egl.cpp index 46cf504..ede3b8b 100644 --- a/libs/bgfx/src/glcontext_egl.cpp +++ b/libs/bgfx/src/glcontext_egl.cpp @@ -35,29 +35,8 @@ namespace bgfx { namespace gl #if BGFX_USE_GL_DYNAMIC_LIB - typedef void (*EGLPROC)(void); - - typedef EGLBoolean (EGLAPIENTRY* PGNEGLBINDAPIPROC)(EGLenum api); - typedef EGLBoolean (EGLAPIENTRY* PFNEGLCHOOSECONFIGPROC)(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config); - typedef EGLContext (EGLAPIENTRY* PFNEGLCREATECONTEXTPROC)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list); - typedef EGLSurface (EGLAPIENTRY* PFNEGLCREATEPBUFFERSURFACEPROC)(EGLDisplay display, EGLConfig config, EGLint const* attrib_list); - typedef EGLSurface (EGLAPIENTRY* PFNEGLCREATEWINDOWSURFACEPROC)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list); - typedef EGLBoolean (EGLAPIENTRY* PFNEGLDESTROYCONTEXTPROC)(EGLDisplay dpy, EGLContext ctx); - typedef EGLBoolean (EGLAPIENTRY* PFNEGLDESTROYSURFACEPROC)(EGLDisplay dpy, EGLSurface surface); - typedef EGLContext (EGLAPIENTRY* PFNEGLGETCURRENTCONTEXTPROC)(void); - typedef EGLSurface (EGLAPIENTRY* PFNEGLGETCURRENTSURFACEPROC)(EGLint readdraw); - typedef EGLDisplay (EGLAPIENTRY* PFNEGLGETDISPLAYPROC)(EGLNativeDisplayType display_id); - typedef EGLint (EGLAPIENTRY* PFNEGLGETERRORPROC)(void); - typedef EGLPROC (EGLAPIENTRY* PFNEGLGETPROCADDRESSPROC)(const char* procname); - typedef EGLBoolean (EGLAPIENTRY* PFNEGLINITIALIZEPROC)(EGLDisplay dpy, EGLint* major, EGLint* minor); - typedef EGLBoolean (EGLAPIENTRY* PFNEGLMAKECURRENTPROC)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx); - typedef EGLBoolean (EGLAPIENTRY* PFNEGLSWAPBUFFERSPROC)(EGLDisplay dpy, EGLSurface surface); - typedef EGLBoolean (EGLAPIENTRY* PFNEGLSWAPINTERVALPROC)(EGLDisplay dpy, EGLint interval); - typedef EGLBoolean (EGLAPIENTRY* PFNEGLTERMINATEPROC)(EGLDisplay dpy); - typedef const char* (EGLAPIENTRY* PGNEGLQUERYSTRINGPROC)(EGLDisplay dpy, EGLint name); - #define EGL_IMPORT \ - EGL_IMPORT_FUNC(PGNEGLBINDAPIPROC, eglBindAPI); \ + EGL_IMPORT_FUNC(PFNEGLBINDAPIPROC, eglBindAPI); \ EGL_IMPORT_FUNC(PFNEGLCHOOSECONFIGPROC, eglChooseConfig); \ EGL_IMPORT_FUNC(PFNEGLCREATECONTEXTPROC, eglCreateContext); \ EGL_IMPORT_FUNC(PFNEGLCREATEPBUFFERSURFACEPROC, eglCreatePbufferSurface); \ @@ -66,6 +45,7 @@ namespace bgfx { namespace gl EGL_IMPORT_FUNC(PFNEGLDESTROYSURFACEPROC, eglDestroySurface); \ EGL_IMPORT_FUNC(PFNEGLGETCURRENTCONTEXTPROC, eglGetCurrentContext); \ EGL_IMPORT_FUNC(PFNEGLGETCURRENTSURFACEPROC, eglGetCurrentSurface); \ + EGL_IMPORT_FUNC(PFNEGLGETPLATFORMDISPLAYPROC, eglGetPlatformDisplay); \ EGL_IMPORT_FUNC(PFNEGLGETDISPLAYPROC, eglGetDisplay); \ EGL_IMPORT_FUNC(PFNEGLGETERRORPROC, eglGetError); \ EGL_IMPORT_FUNC(PFNEGLGETPROCADDRESSPROC, eglGetProcAddress); \ @@ -75,7 +55,9 @@ namespace bgfx { namespace gl EGL_IMPORT_FUNC(PFNEGLSWAPBUFFERSPROC, eglSwapBuffers); \ EGL_IMPORT_FUNC(PFNEGLSWAPINTERVALPROC, eglSwapInterval); \ EGL_IMPORT_FUNC(PFNEGLTERMINATEPROC, eglTerminate); \ - EGL_IMPORT_FUNC(PGNEGLQUERYSTRINGPROC, eglQueryString); \ + EGL_IMPORT_FUNC(PFNEGLQUERYSTRINGPROC, eglQueryString); \ + EGL_IMPORT_FUNC(PFNEGLGETCONFIGSPROC, eglGetConfigs); \ + EGL_IMPORT_FUNC(PFNEGLGETCONFIGATTRIBPROC, eglGetConfigAttrib); \ #define EGL_IMPORT_FUNC(_proto, _func) _proto _func EGL_IMPORT @@ -133,7 +115,7 @@ EGL_IMPORT # define WL_EGL_FUNC(rt, fname, params) \ typedef rt(*PFNWLEGL_##fname) params; \ - PFNWLEGL_##fname BGFX_WAYLAND_##fname; + PFNWLEGL_##fname fname; WL_EGL_IMPORT @@ -144,7 +126,7 @@ WL_EGL_IMPORT void* handle = bx::dlopen("libwayland-egl.so.1"); BGFX_FATAL(handle != NULL, Fatal::UnableToInitialize, "Could not dlopen() libwayland-egl.so.1"); -# define WL_EGL_FUNC(rt, fname, params) BGFX_WAYLAND_##fname = (PFNWLEGL_##fname) bx::dlsym(handle, #fname); +# define WL_EGL_FUNC(rt, fname, params) fname = (PFNWLEGL_##fname) bx::dlsym(handle, #fname); WL_EGL_IMPORT # undef WL_EGL_FUNC @@ -155,7 +137,7 @@ WL_EGL_IMPORT { bx::dlclose(_handle); -# define WL_EGL_FUNC(rt, fname, params) BGFX_WAYLAND_##fname = NULL; +# define WL_EGL_FUNC(rt, fname, params) fname = NULL; WL_EGL_IMPORT # undef WL_EGL_FUNC } @@ -168,7 +150,7 @@ WL_EGL_IMPORT struct SwapChainGL { - SwapChainGL(EGLDisplay _display, EGLConfig _config, EGLContext _context, EGLNativeWindowType _nwh, int _width, int _height) + SwapChainGL(EGLDisplay _display, EGLConfig _config, EGLContext _context, EGLNativeWindowType _nwh, int32_t _width, int32_t _height) : m_nwh(_nwh) , m_display(_display) # if BX_PLATFORM_LINUX @@ -190,7 +172,7 @@ WL_EGL_IMPORT { // A wl_surface needs to be first wrapped in a wl_egl_window // before it can be used to create the EGLSurface. - m_eglWindow = BGFX_WAYLAND_wl_egl_window_create( (wl_surface*)_nwh, _width, _height); + m_eglWindow = wl_egl_window_create( (wl_surface*)_nwh, _width, _height); _nwh = (EGLNativeWindowType) m_eglWindow; } # endif @@ -224,7 +206,7 @@ WL_EGL_IMPORT # if BX_PLATFORM_LINUX if (m_eglWindow) { - BGFX_WAYLAND_wl_egl_window_destroy(m_eglWindow); + wl_egl_window_destroy(m_eglWindow); } # endif EGL_CHECK(eglMakeCurrent(m_display, defaultSurface, defaultSurface, defaultContext) ); @@ -250,13 +232,17 @@ WL_EGL_IMPORT }; # if BX_PLATFORM_RPI + typedef uint32_t DISPMANX_ELEMENT_HANDLE_T; + typedef struct { + DISPMANX_ELEMENT_HANDLE_T element; + int width; /* This is necessary because dispmanx elements are not queriable. */ + int height; + } EGL_DISPMANX_WINDOW_T; static EGL_DISPMANX_WINDOW_T s_dispmanWindow; # endif // BX_PLATFORM_RPI - void GlContext::create(uint32_t _width, uint32_t _height, uint32_t _flags) + void GlContext::create(const Resolution& _resolution) { - BX_UNUSED(_flags); - # if BX_PLATFORM_RPI bcm_host_init(); # endif // BX_PLATFORM_RPI @@ -269,7 +255,6 @@ WL_EGL_IMPORT g_platformData.ndt = EGL_DEFAULT_DISPLAY; # endif // BX_PLATFORM_RPI - BX_UNUSED(_width, _height); EGLNativeDisplayType ndt = (EGLNativeDisplayType)g_platformData.ndt; EGLNativeWindowType nwh = (EGLNativeWindowType )g_platformData.nwh; @@ -315,59 +300,190 @@ WL_EGL_IMPORT : BGFX_CONFIG_RENDERER_OPENGLES ; -#if BX_PLATFORM_ANDROID - const uint32_t msaa = (_flags&BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT; - const uint32_t msaaSamples = msaa == 0 ? 0 : 1<>BGFX_RESET_MSAA_SHIFT; + uint32_t msaaSamples = 0 == msaa ? 0 : 1<= 30) ? EGL_OPENGL_ES3_BIT_KHR : EGL_OPENGL_ES2_BIT - , + ; - EGL_SURFACE_TYPE, headless ? EGL_PBUFFER_BIT : EGL_WINDOW_BIT, + attrs[numAttrs++] = EGL_SURFACE_TYPE; + attrs[numAttrs++] = headless ? EGL_PBUFFER_BIT : EGL_WINDOW_BIT; - EGL_BLUE_SIZE, 8, - EGL_GREEN_SIZE, 8, - EGL_RED_SIZE, 8, - EGL_ALPHA_SIZE, 8, + attrs[numAttrs++] = EGL_BLUE_SIZE; + attrs[numAttrs++] = colorBlockInfo.bBits; -# if BX_PLATFORM_ANDROID - EGL_DEPTH_SIZE, 16, - EGL_SAMPLES, (EGLint)msaaSamples, -# else - EGL_DEPTH_SIZE, 24, -# endif // BX_PLATFORM_ - EGL_STENCIL_SIZE, 8, + attrs[numAttrs++] = EGL_GREEN_SIZE; + attrs[numAttrs++] = colorBlockInfo.gBits; - // Android Recordable surface - hasEglAndroidRecordable ? EGL_RECORDABLE_ANDROID : EGL_NONE, - hasEglAndroidRecordable ? 1 : EGL_NONE, + attrs[numAttrs++] = EGL_RED_SIZE; + attrs[numAttrs++] = colorBlockInfo.rBits; - EGL_NONE - }; + attrs[numAttrs++] = EGL_ALPHA_SIZE; + attrs[numAttrs++] = colorBlockInfo.aBits; - EGLint numConfig = 0; - success = eglChooseConfig(m_display, attrs, &m_config, 1, &numConfig); - BGFX_FATAL(success, Fatal::UnableToInitialize, "eglChooseConfig"); + attrs[numAttrs++] = EGL_DEPTH_SIZE; + attrs[numAttrs++] = depthStecilBlockInfo.depthBits; -# if BX_PLATFORM_ANDROID + attrs[numAttrs++] = EGL_STENCIL_SIZE; + attrs[numAttrs++] = depthStecilBlockInfo.stencilBits; + + attrs[numAttrs++] = EGL_SAMPLES; + attrs[numAttrs++] = (EGLint)bx::min(msaaSamples, maxSamples); + + if (hasEglAndroidRecordable) + { + attrs[numAttrs++] = EGL_RECORDABLE_ANDROID; + attrs[numAttrs++] = 1; + } + + attrs[numAttrs++] = EGL_NONE; + + BX_ASSERT(numAttrs < BX_COUNTOF(attrs), "Out-of-bounds (numAttrs %d, max %d)." + , numAttrs + , BX_COUNTOF(attrs) + ); + success = eglChooseConfig(m_display, attrs, &m_config, 1, &numConfigs); + + if (!success + || 0 == numConfigs) + { + msaaSamples = 0; + continue; + } + + break; + } + + BGFX_FATAL(0 != numConfigs, Fatal::UnableToInitialize, "eglChooseConfig"); + + m_msaaContext = 1 < msaaSamples; + +# if BX_PLATFORM_ANDROID EGLint format; eglGetConfigAttrib(m_display, m_config, EGL_NATIVE_VISUAL_ID, &format); - ANativeWindow_setBuffersGeometry( (ANativeWindow*)g_platformData.nwh, _width, _height, format); + ANativeWindow_setBuffersGeometry( + (ANativeWindow*)g_platformData.nwh + , _resolution.width + , _resolution.height + , format + ); # elif BX_PLATFORM_RPI DISPMANX_DISPLAY_HANDLE_T dispmanDisplay = vc_dispmanx_display_open(0); DISPMANX_UPDATE_HANDLE_T dispmanUpdate = vc_dispmanx_update_start(0); - VC_RECT_T dstRect = { 0, 0, int32_t(_width), int32_t(_height) }; - VC_RECT_T srcRect = { 0, 0, int32_t(_width) << 16, int32_t(_height) << 16 }; + VC_RECT_T dstRect = { 0, 0, int32_t(_resolution.width), int32_t(_resolution.height) }; + VC_RECT_T srcRect = { 0, 0, int32_t(_resolution.width) << 16, int32_t(_resolution.height) << 16 }; DISPMANX_ELEMENT_HANDLE_T dispmanElement = vc_dispmanx_element_add(dispmanUpdate , dispmanDisplay @@ -382,9 +498,9 @@ WL_EGL_IMPORT ); s_dispmanWindow.element = dispmanElement; - s_dispmanWindow.width = _width; - s_dispmanWindow.height = _height; - nwh = &s_dispmanWindow; + s_dispmanWindow.width = _resolution.width; + s_dispmanWindow.height = _resolution.height; + nwh = (EGLNativeWindowType) &s_dispmanWindow; vc_dispmanx_update_submit_sync(dispmanUpdate); # endif // BX_PLATFORM_ANDROID @@ -394,7 +510,7 @@ WL_EGL_IMPORT { m_waylandEglDll = waylandEglOpen(); } -# endif +# endif // BX_PLATFORM_LINUX if (headless) { @@ -415,10 +531,15 @@ WL_EGL_IMPORT { // A wl_surface needs to be first wrapped in a wl_egl_window // before it can be used to create the EGLSurface. - m_eglWindow = BGFX_WAYLAND_wl_egl_window_create( (wl_surface*)nwh, _width, _height); + m_eglWindow = wl_egl_window_create( + (wl_surface*)nwh + , _resolution.width + , _resolution.height + ); nwh = (EGLNativeWindowType) m_eglWindow; } -# endif +# endif // BX_PLATFORM_LINUX + m_surface = eglCreateWindowSurface(m_display, m_config, nwh, NULL); } @@ -482,7 +603,7 @@ WL_EGL_IMPORT break; } - BX_TRACE("Failed to create EGL context with EGL_CONTEXT_FLAGS_KHR (%08x).", flags); + BX_TRACE("Failed to create EGL context with EGL_CONTEXT_FLAGS_KHR (%08x). Retrying without it!", flags); } BGFX_FATAL(m_context != EGL_NO_CONTEXT, Fatal::UnableToInitialize, "Failed to create context."); @@ -511,7 +632,7 @@ WL_EGL_IMPORT # if BX_PLATFORM_LINUX if (m_eglWindow) { - BGFX_WAYLAND_wl_egl_window_destroy(m_eglWindow); + wl_egl_window_destroy(m_eglWindow); waylandEglClose(m_waylandEglDll); m_waylandEglDll = NULL; } @@ -530,7 +651,7 @@ WL_EGL_IMPORT # endif // BX_PLATFORM_RPI } - void GlContext::resize(uint32_t _width, uint32_t _height, uint32_t _flags) + void GlContext::resize(const Resolution& _resolution) { # if BX_PLATFORM_ANDROID if (NULL != m_display) @@ -538,29 +659,45 @@ WL_EGL_IMPORT EGLNativeWindowType nwh = (EGLNativeWindowType )g_platformData.nwh; eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); eglDestroySurface(m_display, m_surface); + m_surface = eglCreateWindowSurface(m_display, m_config, nwh, NULL); BGFX_FATAL(m_surface != EGL_NO_SURFACE, Fatal::UnableToInitialize, "Failed to create surface."); + EGLBoolean success = eglMakeCurrent(m_display, m_surface, m_surface, m_context); BGFX_FATAL(success, Fatal::UnableToInitialize, "Failed to set context."); EGLint format; eglGetConfigAttrib(m_display, m_config, EGL_NATIVE_VISUAL_ID, &format); - ANativeWindow_setBuffersGeometry( (ANativeWindow*)g_platformData.nwh, _width, _height, format); + ANativeWindow_setBuffersGeometry( + (ANativeWindow*)g_platformData.nwh + , _resolution.width + , _resolution.height + , format + ); } # elif BX_PLATFORM_EMSCRIPTEN - EMSCRIPTEN_CHECK(emscripten_set_canvas_element_size(HTML5_TARGET_CANVAS_SELECTOR, _width, _height) ); + EMSCRIPTEN_CHECK(emscripten_set_canvas_element_size( + HTML5_TARGET_CANVAS_SELECTOR + , _resolution.width + , _resolution.height + ) + ); # elif BX_PLATFORM_LINUX if (NULL != m_eglWindow) { - BGFX_WAYLAND_wl_egl_window_resize(m_eglWindow, _width, _height, 0, 0); + wl_egl_window_resize( + m_eglWindow + , _resolution.width + , _resolution.height + , 0 + , 0 + ); } -# else - BX_UNUSED(_width, _height); # endif // BX_PLATFORM_* if (NULL != m_display) { - bool vsync = !!(_flags&BGFX_RESET_VSYNC); + const bool vsync = !!(_resolution.reset & BGFX_RESET_VSYNC); EGL_CHECK(eglSwapInterval(m_display, vsync ? 1 : 0) ); } } @@ -577,7 +714,7 @@ WL_EGL_IMPORT ; } - SwapChainGL* GlContext::createSwapChain(void* _nwh, int _width, int _height) + SwapChainGL* GlContext::createSwapChain(void* _nwh, int32_t _width, int32_t _height) { return BX_NEW(g_allocator, SwapChainGL)(m_display, m_config, m_context, (EGLNativeWindowType)_nwh, _width, _height); } @@ -630,13 +767,17 @@ WL_EGL_IMPORT # if BX_PLATFORM_WINDOWS || BX_PLATFORM_LINUX # if BX_PLATFORM_WINDOWS -# define LIBRARY_NAME "libGL.dll" +# if BGFX_CONFIG_RENDERER_OPENGL +# define LIBRARY_NAME "libGL.dll" +# else +# define LIBRARY_NAME "libGLESv2.dll" +# endif // BGFX_CONFIG_RENDERER_OPENGL # elif BX_PLATFORM_LINUX # if BGFX_CONFIG_RENDERER_OPENGL # define LIBRARY_NAME "libGL.so.1" # else # define LIBRARY_NAME "libGLESv2.so.2" -# endif +# endif // BGFX_CONFIG_RENDERER_OPENGL # endif void* lib = bx::dlopen(LIBRARY_NAME); diff --git a/libs/bgfx/src/glcontext_egl.h b/libs/bgfx/src/glcontext_egl.h index d5556b8..e8a3819 100644 --- a/libs/bgfx/src/glcontext_egl.h +++ b/libs/bgfx/src/glcontext_egl.h @@ -8,6 +8,10 @@ #if BGFX_USE_EGL +#if BGFX_USE_GL_DYNAMIC_LIB +# define EGL_EGL_PROTOTYPES 0 +#endif // BGFX_USE_GL_DYNAMIC_LIB + #include #include @@ -46,12 +50,12 @@ namespace bgfx { namespace gl { } - void create(uint32_t _width, uint32_t _height, uint32_t _flags); + void create(const Resolution& _resolution); void destroy(); - void resize(uint32_t _width, uint32_t _height, uint32_t _flags); + void resize(const Resolution& _resolution); uint64_t getCaps() const; - SwapChainGL* createSwapChain(void* _nwh, int _w, int _h); + SwapChainGL* createSwapChain(void* _nwh, int32_t _width, int32_t _height); void destroySwapChain(SwapChainGL* _swapChain); void swap(SwapChainGL* _swapChain = NULL); void makeCurrent(SwapChainGL* _swapChain = NULL); diff --git a/libs/bgfx/src/glcontext_html5.cpp b/libs/bgfx/src/glcontext_html5.cpp index 24f1996..8139438 100644 --- a/libs/bgfx/src/glcontext_html5.cpp +++ b/libs/bgfx/src/glcontext_html5.cpp @@ -64,15 +64,26 @@ namespace bgfx { namespace gl char* m_canvas; }; - void GlContext::create(uint32_t _width, uint32_t _height, uint32_t /*_flags*/) + void GlContext::create(const Resolution& _resolution) { - // assert? - if (m_primary != NULL) + if (NULL != m_primary) + { return; + } + const bimg::ImageBlockInfo& colorBlockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(_resolution.formatColor) ); + const bimg::ImageBlockInfo& depthStecilBlockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(_resolution.formatDepthStencil) ); - const char* canvas = (const char*) g_platformData.nwh; + emscripten_webgl_init_context_attributes(&s_attrs); + s_attrs.alpha = 0 != colorBlockInfo.aBits; + s_attrs.premultipliedAlpha = false; + s_attrs.depth = 0 != depthStecilBlockInfo.depthBits; + s_attrs.stencil = 0 != depthStecilBlockInfo.stencilBits; + s_attrs.enableExtensionsByDefault = true; + s_attrs.antialias = false; + s_attrs.minorVersion = 0; - EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = bx::narrowCast((uintptr_t) g_platformData.context); + const char* canvas = (const char*)g_platformData.nwh; + EMSCRIPTEN_WEBGL_CONTEXT_HANDLE context = bx::narrowCast( (uintptr_t) g_platformData.context); if (context > 0) { if (emscripten_webgl_get_context_attributes(context, &s_attrs) >= 0) @@ -87,13 +98,17 @@ namespace bgfx { namespace gl } else { - m_primary = createSwapChain((void*)canvas, (int)_width, (int)_height); + m_primary = createSwapChain( (void*)canvas, _resolution.width, _resolution.height); } - if (0 != _width - && 0 != _height) + if (0 != _resolution.width + && 0 != _resolution.height) { - EMSCRIPTEN_CHECK(emscripten_set_canvas_element_size(canvas, (int)_width, (int)_height) ); + EMSCRIPTEN_CHECK(emscripten_set_canvas_element_size( + canvas + , _resolution.width + , _resolution.height + ) ); } makeCurrent(m_primary); @@ -113,32 +128,25 @@ namespace bgfx { namespace gl } } - void GlContext::resize(uint32_t _width, uint32_t _height, uint32_t /* _flags */) + void GlContext::resize(const Resolution& _resolution) { if (m_primary == NULL) { return; } - EMSCRIPTEN_CHECK(emscripten_set_canvas_element_size(m_primary->m_canvas, (int) _width, (int) _height) ); + EMSCRIPTEN_CHECK(emscripten_set_canvas_element_size( + m_primary->m_canvas + , _resolution.width + , _resolution.height + ) ); } - SwapChainGL* GlContext::createSwapChain(void* _nwh, int _width, int _height) + SwapChainGL* GlContext::createSwapChain(void* _nwh, int32_t _width, int32_t _height) { - emscripten_webgl_init_context_attributes(&s_attrs); BX_UNUSED(_width, _height); - // Work around bug https://bugs.chromium.org/p/chromium/issues/detail?id=1045643 in Chrome - // by having alpha always enabled. - s_attrs.alpha = true; - s_attrs.premultipliedAlpha = false; - s_attrs.depth = true; - s_attrs.stencil = true; - s_attrs.enableExtensionsByDefault = true; - s_attrs.antialias = false; - - s_attrs.minorVersion = 0; - const char* canvas = (const char*) _nwh; + const char* canvas = (const char*)_nwh; int32_t error = 0; for (int version = 2; version >= 1; --version) diff --git a/libs/bgfx/src/glcontext_html5.h b/libs/bgfx/src/glcontext_html5.h index 2529253..c85c809 100644 --- a/libs/bgfx/src/glcontext_html5.h +++ b/libs/bgfx/src/glcontext_html5.h @@ -21,12 +21,12 @@ namespace bgfx { namespace gl { } - void create(uint32_t _width, uint32_t _height, uint32_t _flags); + void create(const Resolution& _resolution); void destroy(); - void resize(uint32_t _width, uint32_t _height, uint32_t _flags); + void resize(const Resolution& _resolution); uint64_t getCaps() const; - SwapChainGL* createSwapChain(void* _nwh, int _width, int _height); + SwapChainGL* createSwapChain(void* _nwh, int32_t _width, int32_t _height); void destroySwapChain(SwapChainGL* _swapChain); void swap(SwapChainGL* _swapChain = NULL); void makeCurrent(SwapChainGL* _swapChain = NULL); diff --git a/libs/bgfx/src/glcontext_wgl.cpp b/libs/bgfx/src/glcontext_wgl.cpp index 2fad20d..2e4e24f 100644 --- a/libs/bgfx/src/glcontext_wgl.cpp +++ b/libs/bgfx/src/glcontext_wgl.cpp @@ -63,19 +63,22 @@ namespace bgfx { namespace gl HGLRC m_context; }; - static HGLRC createContext(HDC _hdc) + static HGLRC createContext(HDC _hdc, const Resolution& _resolution) { + const bimg::ImageBlockInfo& colorBlockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(_resolution.formatColor) ); + const bimg::ImageBlockInfo& depthStecilBlockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(_resolution.formatDepthStencil) ); + PIXELFORMATDESCRIPTOR pfd; bx::memSet(&pfd, 0, sizeof(pfd) ); pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR); pfd.nVersion = 1; - pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; - pfd.iPixelType = PFD_TYPE_RGBA; - pfd.cColorBits = 32; - pfd.cAlphaBits = 8; - pfd.cDepthBits = 24; - pfd.cStencilBits = 8; - pfd.iLayerType = PFD_MAIN_PLANE; + pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; + pfd.iPixelType = PFD_TYPE_RGBA; + pfd.cColorBits = colorBlockInfo.bitsPerPixel; + pfd.cAlphaBits = colorBlockInfo.aBits; + pfd.cDepthBits = depthStecilBlockInfo.depthBits; + pfd.cStencilBits = depthStecilBlockInfo.stencilBits; + pfd.iLayerType = PFD_MAIN_PLANE; int pixelFormat = ChoosePixelFormat(_hdc, &pfd); BGFX_FATAL(0 != pixelFormat, Fatal::UnableToInitialize, "ChoosePixelFormat failed!"); @@ -108,7 +111,7 @@ namespace bgfx { namespace gl return context; } - void GlContext::create(uint32_t /*_width*/, uint32_t /*_height*/, uint32_t /*_flags*/) + void GlContext::create(const Resolution& _resolution) { m_opengl32dll = bx::dlopen("opengl32.dll"); BGFX_FATAL(NULL != m_opengl32dll, Fatal::UnableToInitialize, "Failed to load opengl32.dll."); @@ -174,7 +177,7 @@ namespace bgfx { namespace gl HDC hdc = GetDC(hwnd); BGFX_FATAL(NULL != hdc, Fatal::UnableToInitialize, "GetDC failed!"); - HGLRC context = createContext(hdc); + HGLRC context = createContext(hdc, _resolution); wglGetExtensionsStringARB = wglGetProc("wglGetExtensionsStringARB"); wglChoosePixelFormatARB = wglGetProc("wglChoosePixelFormatARB"); @@ -191,6 +194,9 @@ namespace bgfx { namespace gl if (NULL != wglChoosePixelFormatARB && NULL != wglCreateContextAttribsARB) { + const bimg::ImageBlockInfo& colorBlockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(_resolution.formatColor) ); + const bimg::ImageBlockInfo& depthStecilBlockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(_resolution.formatDepthStencil) ); + int32_t attrs[] = { WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB, @@ -198,10 +204,10 @@ namespace bgfx { namespace gl WGL_DRAW_TO_WINDOW_ARB, GL_TRUE, WGL_SUPPORT_OPENGL_ARB, GL_TRUE, - WGL_ALPHA_BITS_ARB, 8, - WGL_COLOR_BITS_ARB, 32, - WGL_DEPTH_BITS_ARB, 24, - WGL_STENCIL_BITS_ARB, 8, + WGL_ALPHA_BITS_ARB, colorBlockInfo.aBits, + WGL_COLOR_BITS_ARB, colorBlockInfo.bitsPerPixel, + WGL_DEPTH_BITS_ARB, depthStecilBlockInfo.depthBits, + WGL_STENCIL_BITS_ARB, depthStecilBlockInfo.stencilBits, WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, WGL_SAMPLES_ARB, 0, @@ -282,7 +288,7 @@ namespace bgfx { namespace gl if (NULL == m_context) { - m_context = createContext(m_hdc); + m_context = createContext(m_hdc, _resolution); } int result = wglMakeCurrent(m_hdc, m_context); @@ -321,11 +327,11 @@ namespace bgfx { namespace gl m_opengl32dll = NULL; } - void GlContext::resize(uint32_t /*_width*/, uint32_t /*_height*/, uint32_t _flags) + void GlContext::resize(const Resolution& _resolution) { if (NULL != wglSwapIntervalEXT) { - bool vsync = !!(_flags&BGFX_RESET_VSYNC); + const bool vsync = !!(_resolution.reset & BGFX_RESET_VSYNC); wglSwapIntervalEXT(vsync ? 1 : 0); } } @@ -335,7 +341,7 @@ namespace bgfx { namespace gl return BGFX_CAPS_SWAP_CHAIN; } - SwapChainGL* GlContext::createSwapChain(void* _nwh, int _width, int _height) + SwapChainGL* GlContext::createSwapChain(void* _nwh, int32_t _width, int32_t _height) { BX_UNUSED(_width, _height); SwapChainGL* swapChain = BX_NEW(g_allocator, SwapChainGL)(_nwh); diff --git a/libs/bgfx/src/glcontext_wgl.h b/libs/bgfx/src/glcontext_wgl.h index 71e9535..4c6fef1 100644 --- a/libs/bgfx/src/glcontext_wgl.h +++ b/libs/bgfx/src/glcontext_wgl.h @@ -69,12 +69,12 @@ typedef void (APIENTRYP PFNGLSTENCILOPPROC) (GLenum fail, GLenum zfail, GLenum z { } - void create(uint32_t _width, uint32_t _height, uint32_t _flags); + void create(const Resolution& _resolution); void destroy(); - void resize(uint32_t _width, uint32_t _height, uint32_t _flags); + void resize(const Resolution& _resolution); uint64_t getCaps() const; - SwapChainGL* createSwapChain(void* _nwh, int _width, int _height); + SwapChainGL* createSwapChain(void* _nwh, int32_t _width, int32_t _height); void destroySwapChain(SwapChainGL* _swapChain); void swap(SwapChainGL* _swapChain = NULL); void makeCurrent(SwapChainGL* _swapChain = NULL); diff --git a/libs/bgfx/src/renderer.h b/libs/bgfx/src/renderer.h index c8971fa..743e90d 100644 --- a/libs/bgfx/src/renderer.h +++ b/libs/bgfx/src/renderer.h @@ -58,6 +58,49 @@ namespace bgfx uint16_t m_item; }; + struct UniformCacheItem + { + uint32_t m_offset; + uint16_t m_size; + uint16_t m_handle; + }; + + struct UniformCacheState + { + UniformCacheState(const Frame* _frame) + : m_frame(_frame) + , m_item(0) + { + m_key.decode(_frame->m_uniformCacheFrame.m_keys[0]); + } + + bool hasItem(uint16_t _view) const + { + return m_item < m_frame->m_uniformCacheFrame.m_numItems + && m_key.m_view <= _view + ; + } + + const UniformCacheItem advance() + { + UniformCacheItem item = + { + .m_offset = m_key.m_offset, + .m_size = m_key.m_size, + .m_handle = m_key.m_handle, + }; + + ++m_item; + m_key.decode(m_frame->m_uniformCacheFrame.m_keys[m_item]); + + return item; + } + + const Frame* m_frame; + UniformCacheKey m_key; + uint16_t m_item; + }; + struct ViewState { ViewState() diff --git a/libs/bgfx/src/renderer_d3d11.cpp b/libs/bgfx/src/renderer_d3d11.cpp index 66e5eb7..a3b34a5 100644 --- a/libs/bgfx/src/renderer_d3d11.cpp +++ b/libs/bgfx/src/renderer_d3d11.cpp @@ -214,6 +214,10 @@ namespace bgfx { namespace d3d11 { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // ETC2 { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // ETC2A { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // ETC2A1 + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // EACR11 UNORM + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // EACR11 SNORM + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // EACRG11 UNORM + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // EACRG11 SNORM { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // PTC12 { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // PTC14 { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN }, // PTC12A @@ -703,7 +707,7 @@ namespace bgfx { namespace d3d11 , m_timerQuerySupport(false) , m_directAccessSupport(false) { - m_fbh.idx = kInvalidHandle; + m_fbh = BGFX_INVALID_HANDLE; bx::memSet(&m_scd, 0, sizeof(m_scd) ); bx::memSet(&m_windows, 0xff, sizeof(m_windows) ); } @@ -732,7 +736,7 @@ namespace bgfx { namespace d3d11 m_renderDocDll = loadRenderDoc(); } - m_fbh.idx = kInvalidHandle; + m_fbh = BGFX_INVALID_HANDLE; bx::memSet(m_uniforms, 0, sizeof(m_uniforms) ); bx::memSet(&m_resolution, 0, sizeof(m_resolution) ); @@ -1009,6 +1013,11 @@ namespace bgfx { namespace d3d11 } } + if (NULL != findModule("Nvda.Graphics.Interception.dll") ) + { + setGraphicsDebuggerPresent(true); + } + if (BGFX_PCI_ID_NVIDIA != m_dxgi.m_adapterDesc.VendorId) { m_nvapi.shutdown(); @@ -1044,7 +1053,7 @@ namespace bgfx { namespace d3d11 * is incompatible with the flip presentation model, which is desirable for various reasons including * player embedding. */ - m_scd.format = s_textureFormat[_init.resolution.format].m_fmt; + m_scd.format = s_textureFormat[_init.resolution.formatColor].m_fmt; updateMsaa(m_scd.format); m_scd.sampleDesc = s_msaa[(_init.resolution.reset&BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT]; @@ -1121,7 +1130,10 @@ namespace bgfx { namespace d3d11 * ONLY the backbuffer from swapchain can be created without *_SRGB format, custom backbuffer should be created the same * format as well as render target view. */ - desc.Format = (m_resolution.reset & BGFX_RESET_SRGB_BACKBUFFER) ? s_textureFormat[m_resolution.format].m_fmtSrgb : s_textureFormat[m_resolution.format].m_fmt; + desc.Format = (m_resolution.reset & BGFX_RESET_SRGB_BACKBUFFER) + ? s_textureFormat[m_resolution.formatColor].m_fmtSrgb + : s_textureFormat[m_resolution.formatColor].m_fmt + ; desc.SampleDesc = m_scd.sampleDesc; desc.Usage = D3D11_USAGE_DEFAULT; desc.BindFlags = D3D11_BIND_RENDER_TARGET; @@ -1618,10 +1630,9 @@ namespace bgfx { namespace d3d11 DX_RELEASE(m_annotation, 1); DX_RELEASE_W(m_infoQueue, 0); DX_RELEASE(m_msaaRt, 0); -#if BX_PLATFORM_WINRT - // Remove swap chain from SwapChainPanel (nwh) if applicable + m_dxgi.removeSwapChain(m_scd); -#endif + DX_RELEASE(m_swapChain, 0); DX_RELEASE(m_deviceCtx, 0); DX_RELEASE(m_device, 0); @@ -1709,10 +1720,9 @@ namespace bgfx { namespace d3d11 DX_RELEASE(m_annotation, 1); DX_RELEASE_W(m_infoQueue, 0); DX_RELEASE(m_msaaRt, 0); -#if BX_PLATFORM_WINRT - // Remove swap chain from SwapChainPanel (nwh) if applicable + m_dxgi.removeSwapChain(m_scd); -#endif + DX_RELEASE(m_swapChain, 0); DX_RELEASE(m_deviceCtx, 0); DX_RELEASE(m_device, 0); @@ -1861,13 +1871,7 @@ namespace bgfx { namespace d3d11 uint32_t pitch = bx::uint32_min(srcPitch, dstPitch); - for (uint32_t yy = 0, height = srcHeight; yy < height; ++yy) - { - bx::memCopy(dst, src, pitch); - - src += srcPitch; - dst += dstPitch; - } + bx::memCopy(dst, dstPitch, src, srcPitch, pitch, srcHeight); m_deviceCtx->Unmap(texture.m_ptr, _mip); } @@ -1880,8 +1884,7 @@ namespace bgfx { namespace d3d11 const Memory* mem = alloc(size); bx::StaticMemoryBlockWriter writer(mem->data, mem->size); - uint32_t magic = BGFX_CHUNK_MAGIC_TEX; - bx::write(&writer, magic, bx::ErrorAssert{}); + bx::write(&writer, kChunkMagicTex, bx::ErrorAssert{}); TextureCreate tc; tc.m_width = _width; @@ -1900,12 +1903,12 @@ namespace bgfx { namespace d3d11 release(mem); } - void overrideInternal(TextureHandle _handle, uintptr_t _ptr) override + void overrideInternal(TextureHandle _handle, uintptr_t _ptr, uint16_t _layerIndex) override { // Resource ref. counts might be messed up outside of bgfx. // Disabling ref. count check once texture is overridden. setGraphicsDebuggerPresent(true); - m_textures[_handle.idx].overrideInternal(_ptr); + m_textures[_handle.idx].overrideInternal(_ptr, _layerIndex); } uintptr_t getInternal(TextureHandle _handle) override @@ -2124,6 +2127,8 @@ namespace bgfx { namespace d3d11 void submitBlit(BlitState& _bs, uint16_t _view); + void submitUniformCache(UniformCacheState& _ucs, uint16_t _view); + void submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter) override; void blitSetup(TextVideoMemBlitter& _blitter) override @@ -2248,7 +2253,10 @@ namespace bgfx { namespace d3d11 * with the srgb version. this is OK because of this: * https://docs.microsoft.com/en-us/windows/win32/direct3ddxgi/converting-data-color-space */ - desc.Format = (m_resolution.reset & BGFX_RESET_SRGB_BACKBUFFER) ? s_textureFormat[m_resolution.format].m_fmtSrgb : s_textureFormat[m_resolution.format].m_fmt; + desc.Format = (m_resolution.reset & BGFX_RESET_SRGB_BACKBUFFER) + ? s_textureFormat[m_resolution.formatColor].m_fmtSrgb + : s_textureFormat[m_resolution.formatColor].m_fmt + ; DX_CHECK(m_device->CreateRenderTargetView(NULL == m_msaaRt ? backBufferColor : m_msaaRt, &desc, &m_backBufferColor) ); DX_RELEASE(backBufferColor, 0); @@ -2258,16 +2266,17 @@ namespace bgfx { namespace d3d11 { m_gpuTimer.postReset(); } + m_occlusionQuery.postReset(); - if (NULL == m_backBufferDepthStencil) + if (bimg::isDepth(bimg::TextureFormat::Enum(m_resolution.formatDepthStencil) ) ) { D3D11_TEXTURE2D_DESC dsd; dsd.Width = bx::uint32_max(m_scd.width, 1); dsd.Height = bx::uint32_max(m_scd.height, 1); dsd.MipLevels = 1; dsd.ArraySize = 1; - dsd.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; + dsd.Format = s_textureFormat[m_resolution.formatDepthStencil].m_fmtDsv; dsd.SampleDesc = m_scd.sampleDesc; dsd.Usage = D3D11_USAGE_DEFAULT; dsd.BindFlags = D3D11_BIND_DEPTH_STENCIL; @@ -2396,7 +2405,7 @@ namespace bgfx { namespace d3d11 #if BX_PLATFORM_WINRT // SwapChainPanels can be dynamically updated if (m_scd.ndt == reinterpret_cast(2) - && (m_scd.nwh != g_platformData.nwh || m_scd.ndt != g_platformData.ndt)) + && (m_scd.nwh != g_platformData.nwh || m_scd.ndt != g_platformData.ndt) ) { // Remove swap chain from SwapChainPanel (nwh) if applicable m_dxgi.removeSwapChain(m_scd); @@ -2462,10 +2471,12 @@ namespace bgfx { namespace d3d11 | BGFX_RESET_SUSPEND ); - if (m_resolution.width != _resolution.width - || m_resolution.height != _resolution.height - || m_resolution.format != _resolution.format - || (m_resolution.reset&maskFlags) != (_resolution.reset&maskFlags) ) + if (m_resolution.width != _resolution.width + || m_resolution.height != _resolution.height + || m_resolution.formatColor != _resolution.formatColor + || m_resolution.formatDepthStencil != _resolution.formatDepthStencil + || (m_resolution.reset&maskFlags) != (_resolution.reset&maskFlags) + ) { uint32_t flags = _resolution.reset & (~BGFX_RESET_INTERNAL_FORCE); @@ -2483,8 +2494,7 @@ namespace bgfx { namespace d3d11 m_scd.width = _resolution.width; m_scd.height = _resolution.height; // see comment in init() about why we don't worry about BGFX_RESET_SRGB_BACKBUFFER here - m_scd.format = s_textureFormat[_resolution.format].m_fmt - ; + m_scd.format = s_textureFormat[_resolution.formatColor].m_fmt; preReset(); @@ -2512,10 +2522,8 @@ namespace bgfx { namespace d3d11 updateMsaa(m_scd.format); m_scd.sampleDesc = s_msaa[(m_resolution.reset&BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT]; -#if BX_PLATFORM_WINRT - // Remove swap chain from SwapChainPanel (nwh) if applicable m_dxgi.removeSwapChain(m_scd); -#endif + DX_RELEASE(m_swapChain, 0); HRESULT hr = m_dxgi.createSwapChain(m_device , m_scd @@ -2531,7 +2539,10 @@ namespace bgfx { namespace d3d11 desc.Height = m_scd.height; desc.MipLevels = 1; desc.ArraySize = 1; - desc.Format = (m_resolution.reset & BGFX_RESET_SRGB_BACKBUFFER) ? s_textureFormat[m_resolution.format].m_fmtSrgb : s_textureFormat[m_resolution.format].m_fmt; + desc.Format = (m_resolution.reset & BGFX_RESET_SRGB_BACKBUFFER) + ? s_textureFormat[m_resolution.formatColor].m_fmtSrgb + : s_textureFormat[m_resolution.formatColor].m_fmt + ; desc.SampleDesc = m_scd.sampleDesc; desc.Usage = D3D11_USAGE_DEFAULT; desc.BindFlags = D3D11_BIND_RENDER_TARGET; @@ -4740,17 +4751,35 @@ namespace bgfx { namespace d3d11 } } - void TextureD3D11::overrideInternal(uintptr_t _ptr) + void TextureD3D11::overrideInternal(uintptr_t _ptr, uint16_t _layerIndex) { D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc{}; - const bool readable = (m_srv != NULL); + const bool readable = NULL != m_srv; + if (readable) { m_srv->GetDesc(&srvDesc); } + switch (srvDesc.ViewDimension) + { + case D3D11_SRV_DIMENSION_TEXTURE2DARRAY: + srvDesc.Texture2DArray.FirstArraySlice = _layerIndex; + srvDesc.Texture2DArray.ArraySize = 1; + break; + + case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY: + srvDesc.Texture2DMSArray.FirstArraySlice = _layerIndex; + srvDesc.Texture2DMSArray.ArraySize = 1; + break; + + default: + break; + } + destroy(); + m_flags |= BGFX_SAMPLER_INTERNAL_SHARED; m_ptr = (ID3D11Resource*)_ptr; @@ -5566,6 +5595,16 @@ namespace bgfx { namespace d3d11 } } + void RendererContextD3D11::submitUniformCache(UniformCacheState& _ucs, uint16_t _view) + { + while (_ucs.hasItem(_view) ) + { + const UniformCacheItem& uci = _ucs.advance(); + + bx::memCopy(m_uniforms[uci.m_handle], &_ucs.m_frame->m_uniformCacheFrame.m_data[uci.m_offset], uci.m_size); + } + } + void RendererContextD3D11::submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter) { if (m_lost) @@ -5636,6 +5675,7 @@ namespace bgfx { namespace d3d11 uint16_t view = UINT16_MAX; FrameBufferHandle fbh = { BGFX_CONFIG_MAX_FRAME_BUFFERS }; + UniformCacheState ucs(_render); BlitState bs(_render); const uint64_t primType = _render->m_debug&BGFX_DEBUG_WIREFRAME ? BGFX_STATE_PT_LINES : 0; @@ -5736,6 +5776,7 @@ namespace bgfx { namespace d3d11 prim = s_primInfo[Topology::Count]; // Force primitive type update after clear quad. } + submitUniformCache(ucs, view); submitBlit(bs, view); } diff --git a/libs/bgfx/src/renderer_d3d11.h b/libs/bgfx/src/renderer_d3d11.h index cb51a1d..a70d73d 100644 --- a/libs/bgfx/src/renderer_d3d11.h +++ b/libs/bgfx/src/renderer_d3d11.h @@ -286,7 +286,7 @@ namespace bgfx { namespace d3d11 void* create(const Memory* _mem, uint64_t _flags, uint8_t _skip); void destroy(); - void overrideInternal(uintptr_t _ptr); + void overrideInternal(uintptr_t _ptr, uint16_t _layerIndex); void update(uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, uint16_t _pitch, const Memory* _mem); void commit(uint8_t _stage, uint32_t _flags, const float _palette[][4]); void resolve(uint8_t _resolve, uint32_t _layer, uint32_t _numLayers, uint32_t _mip) const; diff --git a/libs/bgfx/src/renderer_d3d12.cpp b/libs/bgfx/src/renderer_d3d12.cpp index 4f95612..5bb209b 100644 --- a/libs/bgfx/src/renderer_d3d12.cpp +++ b/libs/bgfx/src/renderer_d3d12.cpp @@ -129,6 +129,18 @@ namespace bgfx { namespace d3d12 D3D12_CULL_MODE_BACK, }; + static const D3D12_SHADING_RATE s_shadingRate[] = + { + D3D12_SHADING_RATE_1X1, + D3D12_SHADING_RATE_1X2, + D3D12_SHADING_RATE_2X1, + D3D12_SHADING_RATE_2X2, + D3D12_SHADING_RATE_2X4, + D3D12_SHADING_RATE_4X2, + D3D12_SHADING_RATE_4X4, + }; + static_assert(ShadingRate::Count == BX_COUNTOF(s_shadingRate) ); + static const D3D12_TEXTURE_ADDRESS_MODE s_textureAddress[] = { D3D12_TEXTURE_ADDRESS_MODE_WRAP, @@ -204,6 +216,10 @@ namespace bgfx { namespace d3d12 { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING }, // ETC2 { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING }, // ETC2A { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING }, // ETC2A1 + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING }, // EACR11 UNORM + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING }, // EACR11 SNORM + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING }, // EACRG11 UNORM + { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING }, // EACRG11 SNORM { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING }, // PTC12 { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING }, // PTC14 { DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING }, // PTC12A @@ -406,37 +422,65 @@ namespace bgfx { namespace d3d12 BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wunused-const-variable"); BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wunneeded-internal-declaration"); - static const GUID IID_ID3D12CommandAllocator = { 0x6102dee4, 0xaf59, 0x4b09, { 0xb9, 0x99, 0xb4, 0x4d, 0x73, 0xf0, 0x9b, 0x24 } }; - static const GUID IID_ID3D12CommandQueue = { 0x0ec870a6, 0x5d7e, 0x4c22, { 0x8c, 0xfc, 0x5b, 0xaa, 0xe0, 0x76, 0x16, 0xed } }; - static const GUID IID_ID3D12CommandSignature = { 0xc36a797c, 0xec80, 0x4f0a, { 0x89, 0x85, 0xa7, 0xb2, 0x47, 0x50, 0x82, 0xd1 } }; - static const GUID IID_ID3D12Debug = { 0x344488b7, 0x6846, 0x474b, { 0xb9, 0x89, 0xf0, 0x27, 0x44, 0x82, 0x45, 0xe0 } }; - static const GUID IID_ID3D12Debug1 = { 0xaffaa4ca, 0x63fe, 0x4d8e, { 0xb8, 0xad, 0x15, 0x90, 0x00, 0xaf, 0x43, 0x04 } }; - static const GUID IID_ID3D12DescriptorHeap = { 0x8efb471d, 0x616c, 0x4f49, { 0x90, 0xf7, 0x12, 0x7b, 0xb7, 0x63, 0xfa, 0x51 } }; - static const GUID IID_ID3D12Device = { 0x189819f1, 0x1db6, 0x4b57, { 0xbe, 0x54, 0x18, 0x21, 0x33, 0x9b, 0x85, 0xf7 } }; - static const GUID IID_ID3D12Device1 = { 0x77acce80, 0x638e, 0x4e65, { 0x88, 0x95, 0xc1, 0xf2, 0x33, 0x86, 0x86, 0x3e } }; - static const GUID IID_ID3D12Device2 = { 0x30baa41e, 0xb15b, 0x475c, { 0xa0, 0xbb, 0x1a, 0xf5, 0xc5, 0xb6, 0x43, 0x28 } }; - static const GUID IID_ID3D12Device3 = { 0x81dadc15, 0x2bad, 0x4392, { 0x93, 0xc5, 0x10, 0x13, 0x45, 0xc4, 0xaa, 0x98 } }; - static const GUID IID_ID3D12Device4 = { 0xe865df17, 0xa9ee, 0x46f9, { 0xa4, 0x63, 0x30, 0x98, 0x31, 0x5a, 0xa2, 0xe5 } }; - static const GUID IID_ID3D12Device5 = { 0x8b4f173b, 0x2fea, 0x4b80, { 0x8f, 0x58, 0x43, 0x07, 0x19, 0x1a, 0xb9, 0x5d } }; - static const GUID IID_ID3D12Device6 = { 0xc70b221b, 0x40e4, 0x4a17, { 0x89, 0xaf, 0x02, 0x5a, 0x07, 0x27, 0xa6, 0xdc } }; - static const GUID IID_ID3D12Device7 = { 0x5c014b53, 0x68a1, 0x4b9b, { 0x8b, 0xd1, 0xdd, 0x60, 0x46, 0xb9, 0x35, 0x8b } }; - static const GUID IID_ID3D12Device8 = { 0x9218e6bb, 0xf944, 0x4f7e, { 0xa7, 0x5c, 0xb1, 0xb2, 0xc7, 0xb7, 0x01, 0xf3 } }; - static const GUID IID_ID3D12Fence = { 0x0a753dcf, 0xc4d8, 0x4b91, { 0xad, 0xf6, 0xbe, 0x5a, 0x60, 0xd9, 0x5a, 0x76 } }; - static const GUID IID_ID3D12GraphicsCommandList = { 0x5b160d0f, 0xac1b, 0x4185, { 0x8b, 0xa8, 0xb3, 0xae, 0x42, 0xa5, 0xa4, 0x55 } }; - static const GUID IID_ID3D12GraphicsCommandList1 = { 0x553103fb, 0x1fe7, 0x4557, { 0xbb, 0x38, 0x94, 0x6d, 0x7d, 0x0e, 0x7c, 0xa7 } }; - static const GUID IID_ID3D12GraphicsCommandList2 = { 0x38c3e585, 0xff17, 0x412c, { 0x91, 0x50, 0x4f, 0xc6, 0xf9, 0xd7, 0x2a, 0x28 } }; - static const GUID IID_ID3D12GraphicsCommandList3 = { 0x6fda83a7, 0xb84c, 0x4e38, { 0x9a, 0xc8, 0xc7, 0xbd, 0x22, 0x01, 0x6b, 0x3d } }; - static const GUID IID_ID3D12GraphicsCommandList4 = { 0x8754318e, 0xd3a9, 0x4541, { 0x98, 0xcf, 0x64, 0x5b, 0x50, 0xdc, 0x48, 0x74 } }; - static const GUID IID_ID3D12InfoQueue = { 0x0742a90b, 0xc387, 0x483f, { 0xb9, 0x46, 0x30, 0xa7, 0xe4, 0xe6, 0x14, 0x58 } }; - static const GUID IID_ID3D12PipelineState = { 0x765a30f3, 0xf624, 0x4c6f, { 0xa8, 0x28, 0xac, 0xe9, 0x48, 0x62, 0x24, 0x45 } }; - static const GUID IID_ID3D12Resource = { 0x696442be, 0xa72e, 0x4059, { 0xbc, 0x79, 0x5b, 0x5c, 0x98, 0x04, 0x0f, 0xad } }; - static const GUID IID_ID3D12RootSignature = { 0xc54a6b66, 0x72df, 0x4ee8, { 0x8b, 0xe5, 0xa9, 0x46, 0xa1, 0x42, 0x92, 0x14 } }; - static const GUID IID_ID3D12QueryHeap = { 0x0d9658ae, 0xed45, 0x469e, { 0xa6, 0x1d, 0x97, 0x0e, 0xc5, 0x83, 0xca, 0xb4 } }; + static const GUID IID_ID3D12CommandAllocator = { 0x6102dee4, 0xaf59, 0x4b09, { 0xb9, 0x99, 0xb4, 0x4d, 0x73, 0xf0, 0x9b, 0x24 } }; + static const GUID IID_ID3D12CommandQueue = { 0x0ec870a6, 0x5d7e, 0x4c22, { 0x8c, 0xfc, 0x5b, 0xaa, 0xe0, 0x76, 0x16, 0xed } }; + static const GUID IID_ID3D12CommandQueue1 = { 0x3a3c3165, 0x0ee7, 0x4b8e, { 0xa0, 0xaf, 0x63, 0x56, 0xb4, 0xc3, 0xbb, 0xb9 } }; + static const GUID IID_ID3D12CommandSignature = { 0xc36a797c, 0xec80, 0x4f0a, { 0x89, 0x85, 0xa7, 0xb2, 0x47, 0x50, 0x82, 0xd1 } }; + static const GUID IID_ID3D12Debug = { 0x344488b7, 0x6846, 0x474b, { 0xb9, 0x89, 0xf0, 0x27, 0x44, 0x82, 0x45, 0xe0 } }; + static const GUID IID_ID3D12Debug1 = { 0xaffaa4ca, 0x63fe, 0x4d8e, { 0xb8, 0xad, 0x15, 0x90, 0x00, 0xaf, 0x43, 0x04 } }; + static const GUID IID_ID3D12Debug2 = { 0x93a665c4, 0xa3b2, 0x4e5d, { 0xb6, 0x92, 0xa2, 0x6a, 0xe1, 0x4e, 0x33, 0x74 } }; + static const GUID IID_ID3D12Debug3 = { 0x5cf4e58f, 0xf671, 0x4ff1, { 0xa5, 0x42, 0x36, 0x86, 0xe3, 0xd1, 0x53, 0xd1 } }; + static const GUID IID_ID3D12Debug4 = { 0x014b816e, 0x9ec5, 0x4a2f, { 0xa8, 0x45, 0xff, 0xbe, 0x44, 0x1c, 0xe1, 0x3a } }; + static const GUID IID_ID3D12Debug5 = { 0x548d6b12, 0x09fa, 0x40e0, { 0x90, 0x69, 0x5d, 0xcd, 0x58, 0x9a, 0x52, 0xc9 } }; + static const GUID IID_ID3D12Debug6 = { 0x82a816d6, 0x5d01, 0x4157, { 0x97, 0xd0, 0x49, 0x75, 0x46, 0x3f, 0xd1, 0xed } }; + static const GUID IID_ID3D12DescriptorHeap = { 0x8efb471d, 0x616c, 0x4f49, { 0x90, 0xf7, 0x12, 0x7b, 0xb7, 0x63, 0xfa, 0x51 } }; + static const GUID IID_ID3D12Device = { 0x189819f1, 0x1db6, 0x4b57, { 0xbe, 0x54, 0x18, 0x21, 0x33, 0x9b, 0x85, 0xf7 } }; + static const GUID IID_ID3D12Device1 = { 0x77acce80, 0x638e, 0x4e65, { 0x88, 0x95, 0xc1, 0xf2, 0x33, 0x86, 0x86, 0x3e } }; + static const GUID IID_ID3D12Device2 = { 0x30baa41e, 0xb15b, 0x475c, { 0xa0, 0xbb, 0x1a, 0xf5, 0xc5, 0xb6, 0x43, 0x28 } }; + static const GUID IID_ID3D12Device3 = { 0x81dadc15, 0x2bad, 0x4392, { 0x93, 0xc5, 0x10, 0x13, 0x45, 0xc4, 0xaa, 0x98 } }; + static const GUID IID_ID3D12Device4 = { 0xe865df17, 0xa9ee, 0x46f9, { 0xa4, 0x63, 0x30, 0x98, 0x31, 0x5a, 0xa2, 0xe5 } }; + static const GUID IID_ID3D12Device5 = { 0x8b4f173b, 0x2fea, 0x4b80, { 0x8f, 0x58, 0x43, 0x07, 0x19, 0x1a, 0xb9, 0x5d } }; + static const GUID IID_ID3D12Device6 = { 0xc70b221b, 0x40e4, 0x4a17, { 0x89, 0xaf, 0x02, 0x5a, 0x07, 0x27, 0xa6, 0xdc } }; + static const GUID IID_ID3D12Device7 = { 0x5c014b53, 0x68a1, 0x4b9b, { 0x8b, 0xd1, 0xdd, 0x60, 0x46, 0xb9, 0x35, 0x8b } }; + static const GUID IID_ID3D12Device8 = { 0x9218e6bb, 0xf944, 0x4f7e, { 0xa7, 0x5c, 0xb1, 0xb2, 0xc7, 0xb7, 0x01, 0xf3 } }; + static const GUID IID_ID3D12Device9 = { 0x4c80e962, 0xf032, 0x4f60, { 0xbc, 0x9e, 0xeb, 0xc2, 0xcf, 0xa1, 0xd8, 0x3c } }; + static const GUID IID_ID3D12Device10 = { 0x517f8718, 0xaa66, 0x49f9, { 0xb0, 0x2b, 0xa7, 0xab, 0x89, 0xc0, 0x60, 0x31 } }; + static const GUID IID_ID3D12Device11 = { 0x5405c344, 0xd457, 0x444e, { 0xb4, 0xdd, 0x23, 0x66, 0xe4, 0x5a, 0xee, 0x39 } }; + static const GUID IID_ID3D12Device12 = { 0x5af5c532, 0x4c91, 0x4cd0, { 0xb5, 0x41, 0x15, 0xa4, 0x05, 0x39, 0x5f, 0xc5 } }; + static const GUID IID_ID3D12Device13 = { 0x14eecffc, 0x4df8, 0x40f7, { 0xa1, 0x18, 0x5c, 0x81, 0x6f, 0x45, 0x69, 0x5e } }; + static const GUID IID_ID3D12Device14 = { 0x5f6e592d, 0xd895, 0x44c2, { 0x8e, 0x4a, 0x88, 0xad, 0x49, 0x26, 0xd3, 0x23 } }; + static const GUID IID_ID3D12Fence = { 0x0a753dcf, 0xc4d8, 0x4b91, { 0xad, 0xf6, 0xbe, 0x5a, 0x60, 0xd9, 0x5a, 0x76 } }; + static const GUID IID_ID3D12Fence1 = { 0x433685fe, 0xe22b, 0x4ca0, { 0xa8, 0xdb, 0xb5, 0xb4, 0xf4, 0xdd, 0x0e, 0x4a } }; + static const GUID IID_ID3D12GraphicsCommandList = { 0x5b160d0f, 0xac1b, 0x4185, { 0x8b, 0xa8, 0xb3, 0xae, 0x42, 0xa5, 0xa4, 0x55 } }; + static const GUID IID_ID3D12GraphicsCommandList1 = { 0x553103fb, 0x1fe7, 0x4557, { 0xbb, 0x38, 0x94, 0x6d, 0x7d, 0x0e, 0x7c, 0xa7 } }; + static const GUID IID_ID3D12GraphicsCommandList2 = { 0x38c3e585, 0xff17, 0x412c, { 0x91, 0x50, 0x4f, 0xc6, 0xf9, 0xd7, 0x2a, 0x28 } }; + static const GUID IID_ID3D12GraphicsCommandList3 = { 0x6fda83a7, 0xb84c, 0x4e38, { 0x9a, 0xc8, 0xc7, 0xbd, 0x22, 0x01, 0x6b, 0x3d } }; + static const GUID IID_ID3D12GraphicsCommandList4 = { 0x8754318e, 0xd3a9, 0x4541, { 0x98, 0xcf, 0x64, 0x5b, 0x50, 0xdc, 0x48, 0x74 } }; + static const GUID IID_ID3D12GraphicsCommandList5 = { 0x55050859, 0x4024, 0x474c, { 0x87, 0xf5, 0x64, 0x72, 0xea, 0xee, 0x44, 0xea } }; + static const GUID IID_ID3D12GraphicsCommandList6 = { 0xc3827890, 0xe548, 0x4cfa, { 0x96, 0xcf, 0x56, 0x89, 0xa9, 0x37, 0x0f, 0x80 } }; + static const GUID IID_ID3D12GraphicsCommandList7 = { 0xdd171223, 0x8b61, 0x4769, { 0x90, 0xe3, 0x16, 0x0c, 0xcd, 0xe4, 0xe2, 0xc1 } }; + static const GUID IID_ID3D12GraphicsCommandList8 = { 0xee936ef9, 0x599d, 0x4d28, { 0x93, 0x8e, 0x23, 0xc4, 0xad, 0x05, 0xce, 0x51 } }; + static const GUID IID_ID3D12GraphicsCommandList9 = { 0x34ed2808, 0xffe6, 0x4c2b, { 0xb1, 0x1a, 0xca, 0xbd, 0x2b, 0x0c, 0x59, 0xe1 } }; + static const GUID IID_ID3D12GraphicsCommandList10 = { 0x7013c015, 0xd161, 0x4b63, { 0xa0, 0x8c, 0x23, 0x85, 0x52, 0xdd, 0x8a, 0xcc } }; + static const GUID IID_ID3D12InfoQueue = { 0x0742a90b, 0xc387, 0x483f, { 0xb9, 0x46, 0x30, 0xa7, 0xe4, 0xe6, 0x14, 0x58 } }; + static const GUID IID_ID3D12PipelineState = { 0x765a30f3, 0xf624, 0x4c6f, { 0xa8, 0x28, 0xac, 0xe9, 0x48, 0x62, 0x24, 0x45 } }; + static const GUID IID_ID3D12PipelineState1 = { 0x5646804c, 0x9638, 0x48f7, { 0x91, 0x82, 0xb3, 0xee, 0x5a, 0x6b, 0x60, 0xfb } }; + static const GUID IID_ID3D12Resource = { 0x696442be, 0xa72e, 0x4059, { 0xbc, 0x79, 0x5b, 0x5c, 0x98, 0x04, 0x0f, 0xad } }; + static const GUID IID_ID3D12Resource1 = { 0x9d5e227a, 0x4430, 0x4161, { 0x88, 0xb3, 0x3e, 0xca, 0x6b, 0xb1, 0x6e, 0x19 } }; + static const GUID IID_ID3D12Resource2 = { 0xbe36ec3b, 0xea85, 0x4aeb, { 0xa4, 0x5a, 0xe9, 0xd7, 0x64, 0x04, 0xa4, 0x95 } }; + static const GUID IID_ID3D12RootSignature = { 0xc54a6b66, 0x72df, 0x4ee8, { 0x8b, 0xe5, 0xa9, 0x46, 0xa1, 0x42, 0x92, 0x14 } }; + static const GUID IID_ID3D12QueryHeap = { 0x0d9658ae, 0xed45, 0x469e, { 0xa6, 0x1d, 0x97, 0x0e, 0xc5, 0x83, 0xca, 0xb4 } }; BX_PRAGMA_DIAGNOSTIC_POP(); static const GUID s_d3dDeviceIIDs[] = { + IID_ID3D12Device14, + IID_ID3D12Device13, + IID_ID3D12Device12, + IID_ID3D12Device11, + IID_ID3D12Device10, + IID_ID3D12Device9, IID_ID3D12Device8, IID_ID3D12Device7, IID_ID3D12Device6, @@ -474,13 +518,13 @@ namespace bgfx { namespace d3d12 static inline D3D12_HEAP_PROPERTIES ID3D12DeviceGetCustomHeapProperties(ID3D12Device *device, uint32_t nodeMask, D3D12_HEAP_TYPE heapType) { -#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER)) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) return device->GetCustomHeapProperties(nodeMask, heapType); #else D3D12_HEAP_PROPERTIES ret; device->GetCustomHeapProperties(&ret, nodeMask, heapType); return ret; -#endif // BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER)) +#endif // BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) } static void initHeapProperties(ID3D12Device* _device, D3D12_HEAP_PROPERTIES& _properties) @@ -525,11 +569,11 @@ namespace bgfx { namespace d3d12 void* ptr; DX_CHECK(resource->Map(0, NULL, &ptr) ); D3D12_RESOURCE_ALLOCATION_INFO rai; -#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER)) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) rai = _device->GetResourceAllocationInfo(1, 1, _resourceDesc); #else _device->GetResourceAllocationInfo(&rai, 1, 1, _resourceDesc); -#endif // BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER)) +#endif // BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) bx::memSet(ptr, 0, size_t(rai.SizeInBytes) ); resource->Unmap(0, NULL); } @@ -626,48 +670,56 @@ namespace bgfx { namespace d3d12 inline D3D12_CPU_DESCRIPTOR_HANDLE getCPUHandleHeapStart(ID3D12DescriptorHeap* _heap) { -#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER)) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) return _heap->GetCPUDescriptorHandleForHeapStart(); #else D3D12_CPU_DESCRIPTOR_HANDLE handle; _heap->GetCPUDescriptorHandleForHeapStart(&handle); return handle; -#endif // BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER)) +#endif // BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) } inline D3D12_GPU_DESCRIPTOR_HANDLE getGPUHandleHeapStart(ID3D12DescriptorHeap* _heap) { -#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER)) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) return _heap->GetGPUDescriptorHandleForHeapStart(); #else D3D12_GPU_DESCRIPTOR_HANDLE handle; _heap->GetGPUDescriptorHandleForHeapStart(&handle); return handle; -#endif // BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER)) +#endif // BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) } inline D3D12_RESOURCE_DESC getResourceDesc(ID3D12Resource* _resource) { -#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER)) +#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) return _resource->GetDesc(); #else D3D12_RESOURCE_DESC desc; _resource->GetDesc(&desc); return desc; -#endif // BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER)) +#endif // BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) ) } #if BGFX_CONFIG_DEBUG_ANNOTATION && (BX_PLATFORM_WINDOWS || BX_PLATFORM_WINRT) - static PIXEventsThreadInfo s_pixEventsThreadInfo; - PIXEventsThreadInfo* WINAPI stubPIXGetThreadInfo() + struct StubPIXEventsThreadInfo + { + void* block; + void* biasedLimit; + void* destination; + }; + + static StubPIXEventsThreadInfo s_pixEventsThreadInfo = {}; + + static struct PIXEventsThreadInfo* WINAPI stubPIXGetThreadInfo() { - return &s_pixEventsThreadInfo; + return (struct PIXEventsThreadInfo*)& s_pixEventsThreadInfo; } - uint64_t WINAPI stubPIXEventsReplaceBlock(bool _getEarliestTime) + uint64_t WINAPI stubPIXEventsReplaceBlock(PIXEventsThreadInfo* _threadInfo, bool _getEarliestTime) { - BX_UNUSED(_getEarliestTime); + BX_UNUSED(_threadInfo, _getEarliestTime); return 0; } #endif // BGFX_CONFIG_DEBUG_ANNOTATION && (BX_PLATFORM_WINDOWS || BX_PLATFORM_WINRT) @@ -680,6 +732,7 @@ namespace bgfx { namespace d3d12 , m_winPixEvent(NULL) , m_featureLevel(D3D_FEATURE_LEVEL(0) ) , m_swapChain(NULL) + , m_backBufferDepthStencil(NULL) , m_wireframe(false) , m_lost(false) , m_maxAnisotropy(1) @@ -687,6 +740,7 @@ namespace bgfx { namespace d3d12 , m_backBufferColorIdx(0) , m_rtMsaa(false) , m_directAccessSupport(false) + , m_variableRateShadingSupport(false) { } @@ -735,9 +789,13 @@ namespace bgfx { namespace d3d12 m_renderDocDll = loadRenderDoc(); } - setGraphicsDebuggerPresent(NULL != m_renderDocDll || NULL != m_winPixEvent); + setGraphicsDebuggerPresent(false + || NULL != m_renderDocDll + || NULL != m_winPixEvent + || NULL != findModule("Nvda.Graphics.Interception.dll") + ); - m_fbh.idx = kInvalidHandle; + m_fbh = BGFX_INVALID_HANDLE; bx::memSet(m_uniforms, 0, sizeof(m_uniforms) ); bx::memSet(&m_resolution, 0, sizeof(m_resolution) ); @@ -842,7 +900,7 @@ namespace bgfx { namespace d3d12 ID3D12Debug1* debug1; hr = debug0->QueryInterface(IID_ID3D12Debug1, (void**)&debug1); - if (SUCCEEDED(hr)) + if (SUCCEEDED(hr) ) { // https://discordapp.com/channels/590611987420020747/593519198995742733/703642988345032804 // D3D12 Bug Number: 26131261 @@ -850,7 +908,7 @@ namespace bgfx { namespace d3d12 // Setting SetEnableSynchronizedCommandQueueValidation below to false avoids the bug // It was fixed in (probably) the first windows 11 sdk, 22000 // However, the fix causes any dx12 context with validation to break if this is set to false, so we can't do that anymore - if (windowsVersionIs(Condition::GreaterEqual, 0x0A00, 22000)) + if (windowsVersionIs(Condition::GreaterEqual, 0x0A00, 22000) ) { debug1->SetEnableGPUBasedValidation(true); } @@ -953,6 +1011,8 @@ namespace bgfx { namespace d3d12 } } + BX_TRACE("Device interface version IID_ID3D12Device%d.", m_deviceInterfaceVersion); + #if !BX_PLATFORM_LINUX if (BGFX_PCI_ID_NVIDIA != m_dxgi.m_adapterDesc.VendorId) { @@ -990,7 +1050,7 @@ namespace bgfx { namespace d3d12 BX_TRACE("\tCrossNodeSharingTier %d", m_options.CrossNodeSharingTier); BX_TRACE("\tResourceHeapTier %d", m_options.ResourceHeapTier); - for (D3D12_FEATURE_DATA_D3D12_OPTIONS1 options1; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS1, &options1, sizeof(options1)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS1 options1; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS1, &options1, sizeof(options1) ) );) { BX_TRACE("D3D12 options 1:"); BX_TRACE("\tWaveOps %d", options1.WaveOps); @@ -1002,7 +1062,7 @@ namespace bgfx { namespace d3d12 break; } - for (D3D12_FEATURE_DATA_D3D12_OPTIONS2 options2; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS2, &options2, sizeof(options2)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS2 options2; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS2, &options2, sizeof(options2) ) );) { BX_TRACE("D3D12 options 2:"); BX_TRACE("\tCopyQueueTimestampQueriesSupported %d", options2.DepthBoundsTestSupported); @@ -1010,7 +1070,7 @@ namespace bgfx { namespace d3d12 break; } - for (D3D12_FEATURE_DATA_D3D12_OPTIONS3 options3; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS3, &options3, sizeof(options3)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS3 options3; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS3, &options3, sizeof(options3) ) );) { BX_TRACE("D3D12 options 3:"); BX_TRACE("\tCopyQueueTimestampQueriesSupported %d", options3.CopyQueueTimestampQueriesSupported); @@ -1021,7 +1081,7 @@ namespace bgfx { namespace d3d12 break; } - for (D3D12_FEATURE_DATA_D3D12_OPTIONS4 options4; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS4, &options4, sizeof(options4)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS4 options4; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS4, &options4, sizeof(options4) ) );) { BX_TRACE("D3D12 options 4:"); BX_TRACE("\tMSAA64KBAlignedTextureSupported %d", options4.MSAA64KBAlignedTextureSupported); @@ -1039,18 +1099,21 @@ namespace bgfx { namespace d3d12 break; } - for (D3D12_FEATURE_DATA_D3D12_OPTIONS6 options6; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS6, &options6, sizeof(options6)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS6 options6; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS6, &options6, sizeof(options6) ) );) { BX_TRACE("D3D12 options 6:"); BX_TRACE("\tAdditionalShadingRatesSupported %d", options6.AdditionalShadingRatesSupported); BX_TRACE("\tPerPrimitiveShadingRateSupportedWithViewportIndexing %d", options6.PerPrimitiveShadingRateSupportedWithViewportIndexing); BX_TRACE("\tVariableShadingRateTier %d", options6.VariableShadingRateTier); + + m_variableRateShadingSupport = D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED != options6.VariableShadingRateTier; + BX_TRACE("\tShadingRateImageTileSize %d", options6.ShadingRateImageTileSize); BX_TRACE("\tBackgroundProcessingSupported %d", options6.BackgroundProcessingSupported); break; } - for (D3D12_FEATURE_DATA_D3D12_OPTIONS7 options7; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS7, &options7, sizeof(options7)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS7 options7; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS7, &options7, sizeof(options7) ) );) { BX_TRACE("D3D12 options 7:"); BX_TRACE("\tMeshShaderTier %d", options7.MeshShaderTier); @@ -1058,14 +1121,14 @@ namespace bgfx { namespace d3d12 break; } - for (D3D12_FEATURE_DATA_D3D12_OPTIONS8 options8; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS8, &options8, sizeof(options8)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS8 options8; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS8, &options8, sizeof(options8) ) );) { BX_TRACE("D3D12 options 8:"); BX_TRACE("\tUnalignedBlockTexturesSupported %d", options8.UnalignedBlockTexturesSupported); break; } - for (D3D12_FEATURE_DATA_D3D12_OPTIONS9 options9; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS9, &options9, sizeof(options9)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS9 options9; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS9, &options9, sizeof(options9) ) );) { BX_TRACE("D3D12 options 9:"); BX_TRACE("\tMeshShaderPipelineStatsSupported %d", options9.MeshShaderPipelineStatsSupported); @@ -1077,7 +1140,7 @@ namespace bgfx { namespace d3d12 break; } - for (D3D12_FEATURE_DATA_D3D12_OPTIONS10 options10; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS10, &options10, sizeof(options10)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS10 options10; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS10, &options10, sizeof(options10) ) );) { BX_TRACE("D3D12 options 10:"); BX_TRACE("\tVariableRateShadingSumCombinerSupported %d", options10.VariableRateShadingSumCombinerSupported); @@ -1085,14 +1148,14 @@ namespace bgfx { namespace d3d12 break; } - for (D3D12_FEATURE_DATA_D3D12_OPTIONS11 options11; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS11, &options11, sizeof(options11)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS11 options11; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS11, &options11, sizeof(options11) ) );) { BX_TRACE("D3D12 options 11:"); BX_TRACE("\tAtomicInt64OnDescriptorHeapResourceSupported %d", options11.AtomicInt64OnDescriptorHeapResourceSupported); break; } - for (D3D12_FEATURE_DATA_D3D12_OPTIONS12 options12; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS12, &options12, sizeof(options12)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS12 options12; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS12, &options12, sizeof(options12) ) );) { BX_TRACE("D3D12 options 12:"); BX_TRACE("\tMSPrimitivesPipelineStatisticIncludesCulledPrimitives %d", options12.MSPrimitivesPipelineStatisticIncludesCulledPrimitives); @@ -1101,7 +1164,7 @@ namespace bgfx { namespace d3d12 break; } - for (D3D12_FEATURE_DATA_D3D12_OPTIONS13 options13; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS13, &options13, sizeof(options13)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS13 options13; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS13, &options13, sizeof(options13) ) );) { BX_TRACE("D3D12 options 13:"); BX_TRACE("\tUnrestrictedBufferTextureCopyPitchSupported %d", options13.UnrestrictedBufferTextureCopyPitchSupported); @@ -1113,7 +1176,7 @@ namespace bgfx { namespace d3d12 break; } - for (D3D12_FEATURE_DATA_D3D12_OPTIONS14 options14; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS14, &options14, sizeof(options14)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS14 options14; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS14, &options14, sizeof(options14) ) );) { BX_TRACE("D3D12 options 14:"); BX_TRACE("\tAdvancedTextureOpsSupported %d", options14.AdvancedTextureOpsSupported); @@ -1122,7 +1185,7 @@ namespace bgfx { namespace d3d12 break; } - for (D3D12_FEATURE_DATA_D3D12_OPTIONS15 options15; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS15, &options15, sizeof(options15)));) + for (D3D12_FEATURE_DATA_D3D12_OPTIONS15 options15; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS15, &options15, sizeof(options15) ) );) { BX_TRACE("D3D12 options 15:"); BX_TRACE("\tTriangleFanSupported %d", options15.TriangleFanSupported); @@ -1130,6 +1193,63 @@ namespace bgfx { namespace d3d12 break; } + for (D3D12_FEATURE_DATA_D3D12_OPTIONS16 options16; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS16, &options16, sizeof(options16) ) );) + { + BX_TRACE("D3D12 options 16:"); + BX_TRACE("\tDynamicDepthBiasSupported %d", options16.DynamicDepthBiasSupported); + BX_TRACE("\tGPUUploadHeapSupported %d", options16.GPUUploadHeapSupported); + break; + } + + for (D3D12_FEATURE_DATA_D3D12_OPTIONS17 options17; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS17, &options17, sizeof(options17) ) );) + { + BX_TRACE("D3D12 options 17:"); + BX_TRACE("\tNonNormalizedCoordinateSamplersSupported %d", options17.NonNormalizedCoordinateSamplersSupported); + BX_TRACE("\tManualWriteTrackingResourceSupported %d", options17.ManualWriteTrackingResourceSupported); + break; + } + + for (D3D12_FEATURE_DATA_D3D12_OPTIONS18 options18; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS18, &options18, sizeof(options18) ) );) + { + BX_TRACE("D3D12 options 18:"); + BX_TRACE("\tRenderPassesValid %d", options18.RenderPassesValid); + break; + } + + for (D3D12_FEATURE_DATA_D3D12_OPTIONS19 options19; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS19, &options19, sizeof(options19) ) );) + { + BX_TRACE("D3D12 options 19:"); + BX_TRACE("\tMismatchingOutputDimensionsSupported %d", options19.MismatchingOutputDimensionsSupported); + BX_TRACE("\tSupportedSampleCountsWithNoOutputs %d", options19.SupportedSampleCountsWithNoOutputs); + BX_TRACE("\tPointSamplingAddressesNeverRoundUp %d", options19.PointSamplingAddressesNeverRoundUp); + BX_TRACE("\tRasterizerDesc2Supported %d", options19.RasterizerDesc2Supported); + BX_TRACE("\tNarrowQuadrilateralLinesSupported %d", options19.NarrowQuadrilateralLinesSupported); + BX_TRACE("\tAnisoFilterWithPointMipSupported %d", options19.AnisoFilterWithPointMipSupported); + BX_TRACE("\tMaxSamplerDescriptorHeapSize %d", options19.MaxSamplerDescriptorHeapSize); + BX_TRACE("\tMaxSamplerDescriptorHeapSizeWithStaticSamplers %d", options19.MaxSamplerDescriptorHeapSizeWithStaticSamplers); + BX_TRACE("\tMaxViewDescriptorHeapSize %d", options19.MaxViewDescriptorHeapSize); + BX_TRACE("\tComputeOnlyCustomHeapSupported %d", options19.ComputeOnlyCustomHeapSupported); + break; + } + + for (D3D12_FEATURE_DATA_D3D12_OPTIONS20 options20; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS20, &options20, sizeof(options20) ) );) + { + BX_TRACE("D3D12 options 20:"); + BX_TRACE("\tComputeOnlyWriteWatchSupported %d", options20.ComputeOnlyWriteWatchSupported); + BX_TRACE("\tRecreateAtTier %d", options20.RecreateAtTier); + break; + } + + for (D3D12_FEATURE_DATA_D3D12_OPTIONS21 options21; SUCCEEDED(m_device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS21, &options21, sizeof(options21) ) );) + { + BX_TRACE("D3D12 options 21:"); + BX_TRACE("\tWorkGraphsTier %d", options21.WorkGraphsTier); + BX_TRACE("\tExecuteIndirectTier %d", options21.ExecuteIndirectTier); + BX_TRACE("\tSampleCmpGradientAndBiasSupported %d", options21.SampleCmpGradientAndBiasSupported); + BX_TRACE("\tExtendedCommandInfoSupported %d", options21.ExtendedCommandInfoSupported); + break; + } + initHeapProperties(m_device); m_cmd.init(m_device); @@ -1141,7 +1261,7 @@ namespace bgfx { namespace d3d12 bx::memSet(&m_scd, 0, sizeof(m_scd) ); m_scd.width = _init.resolution.width; m_scd.height = _init.resolution.height; - m_scd.format = s_textureFormat[_init.resolution.format].m_fmt; + m_scd.format = s_textureFormat[_init.resolution.formatColor].m_fmt; m_scd.stereo = false; updateMsaa(m_scd.format); @@ -1201,8 +1321,9 @@ namespace bgfx { namespace d3d12 resourceDesc.Height = m_scd.height; resourceDesc.MipLevels = 1; resourceDesc.Format = (m_resolution.reset & BGFX_RESET_SRGB_BACKBUFFER) - ? s_textureFormat[m_resolution.format].m_fmtSrgb - : s_textureFormat[m_resolution.format].m_fmt; + ? s_textureFormat[m_resolution.formatColor].m_fmtSrgb + : s_textureFormat[m_resolution.formatColor].m_fmt + ; resourceDesc.SampleDesc = m_scd.sampleDesc; resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; resourceDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; @@ -1349,30 +1470,31 @@ namespace bgfx { namespace d3d12 ; g_caps.supported |= ( 0 - | BGFX_CAPS_TEXTURE_3D - | BGFX_CAPS_TEXTURE_COMPARE_ALL - | BGFX_CAPS_INDEX32 - | BGFX_CAPS_INSTANCING - | BGFX_CAPS_DRAW_INDIRECT - | BGFX_CAPS_VERTEX_ATTRIB_HALF - | BGFX_CAPS_VERTEX_ATTRIB_UINT10 - | BGFX_CAPS_VERTEX_ID - | BGFX_CAPS_FRAGMENT_DEPTH + | BGFX_CAPS_ALPHA_TO_COVERAGE | BGFX_CAPS_BLEND_INDEPENDENT | BGFX_CAPS_COMPUTE - | (m_options.ROVsSupported ? BGFX_CAPS_FRAGMENT_ORDERING : 0) - | (m_directAccessSupport ? BGFX_CAPS_TEXTURE_DIRECT_ACCESS : 0) - | (BX_ENABLED(BX_PLATFORM_WINDOWS) ? BGFX_CAPS_SWAP_CHAIN : 0) - | BGFX_CAPS_TEXTURE_BLIT - | BGFX_CAPS_TEXTURE_READ_BACK + | BGFX_CAPS_DRAW_INDIRECT + | BGFX_CAPS_DRAW_INDIRECT_COUNT + | BGFX_CAPS_FRAGMENT_DEPTH + | (m_options.ROVsSupported ? BGFX_CAPS_FRAGMENT_ORDERING : 0) + | BGFX_CAPS_IMAGE_RW + | BGFX_CAPS_INDEX32 + | BGFX_CAPS_INSTANCING | BGFX_CAPS_OCCLUSION_QUERY - | BGFX_CAPS_ALPHA_TO_COVERAGE + | BGFX_CAPS_PRIMITIVE_ID + | (BX_ENABLED(BX_PLATFORM_WINDOWS) ? BGFX_CAPS_SWAP_CHAIN : 0) | BGFX_CAPS_TEXTURE_2D_ARRAY + | BGFX_CAPS_TEXTURE_3D + | BGFX_CAPS_TEXTURE_BLIT + | BGFX_CAPS_TEXTURE_COMPARE_ALL | BGFX_CAPS_TEXTURE_CUBE_ARRAY - | BGFX_CAPS_IMAGE_RW + | (m_directAccessSupport ? BGFX_CAPS_TEXTURE_DIRECT_ACCESS : 0) + | BGFX_CAPS_TEXTURE_READ_BACK + | (m_variableRateShadingSupport ? BGFX_CAPS_VARIABLE_RATE_SHADING : 0) + | BGFX_CAPS_VERTEX_ATTRIB_HALF + | BGFX_CAPS_VERTEX_ATTRIB_UINT10 + | BGFX_CAPS_VERTEX_ID | BGFX_CAPS_VIEWPORT_LAYER_ARRAY - | BGFX_CAPS_DRAW_INDIRECT_COUNT - | BGFX_CAPS_PRIMITIVE_ID ); g_caps.limits.maxTextureSize = D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION; g_caps.limits.maxTextureLayers = D3D12_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION; @@ -1911,13 +2033,7 @@ namespace bgfx { namespace d3d12 uint8_t* src; readback->Map(0, NULL, (void**)&src); - for (uint32_t yy = 0, height = srcHeight; yy < height; ++yy) - { - bx::memCopy(dst, src, pitch); - - src += srcPitch; - dst += dstPitch; - } + bx::memCopy(dst, dstPitch, src, srcPitch, pitch, srcHeight); D3D12_RANGE writeRange = { 0, 0 }; readback->Unmap(0, &writeRange); @@ -1933,8 +2049,7 @@ namespace bgfx { namespace d3d12 const Memory* mem = alloc(size); bx::StaticMemoryBlockWriter writer(mem->data, mem->size); - uint32_t magic = BGFX_CHUNK_MAGIC_TEX; - bx::write(&writer, magic, bx::ErrorAssert{}); + bx::write(&writer, kChunkMagicTex, bx::ErrorAssert{}); TextureCreate tc; tc.m_width = _width; @@ -1953,7 +2068,7 @@ namespace bgfx { namespace d3d12 release(mem); } - void overrideInternal(TextureHandle _handle, uintptr_t _ptr) override + void overrideInternal(TextureHandle _handle, uintptr_t _ptr, uint16_t /*_layerIndex*/) override { // Resource ref. counts might be messed up outside of bgfx. // Disabling ref. count check once texture is overridden. @@ -2168,6 +2283,8 @@ namespace bgfx { namespace d3d12 void submitBlit(BlitState& _bs, uint16_t _view); + void submitUniformCache(UniformCacheState& _ucs, uint16_t _view); + void submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter) override; void blitSetup(TextVideoMemBlitter& _blitter) override @@ -2286,6 +2403,7 @@ namespace bgfx { namespace d3d12 DX_RELEASE(m_backBufferColor[ii], 1); #endif // BX_PLATFORM_WINDOWS || BX_PLATFORM_WINRT } + DX_RELEASE(m_backBufferDepthStencil, 0); } @@ -2318,13 +2436,16 @@ namespace bgfx { namespace d3d12 D3D12_RENDER_TARGET_VIEW_DESC rtvDesc; rtvDesc.Format = (m_resolution.reset & BGFX_RESET_SRGB_BACKBUFFER) - ? s_textureFormat[m_resolution.format].m_fmtSrgb - : s_textureFormat[m_resolution.format].m_fmt; + ? s_textureFormat[m_resolution.formatColor].m_fmtSrgb + : s_textureFormat[m_resolution.formatColor].m_fmt + ; if (1 < getResourceDesc(m_backBufferColor[ii]).DepthOrArraySize) { - rtvDesc.ViewDimension = (NULL == m_msaaRt) ? - D3D12_RTV_DIMENSION_TEXTURE2DARRAY : D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY; + rtvDesc.ViewDimension = (NULL == m_msaaRt) + ? D3D12_RTV_DIMENSION_TEXTURE2DARRAY + : D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY + ; rtvDesc.Texture2DArray.FirstArraySlice = 0; rtvDesc.Texture2DArray.ArraySize = getResourceDesc(m_backBufferColor[ii]).DepthOrArraySize; rtvDesc.Texture2DArray.MipSlice = 0; @@ -2332,8 +2453,10 @@ namespace bgfx { namespace d3d12 } else { - rtvDesc.ViewDimension = (NULL == m_msaaRt) ? - D3D12_RTV_DIMENSION_TEXTURE2D : D3D12_RTV_DIMENSION_TEXTURE2DMS; + rtvDesc.ViewDimension = (NULL == m_msaaRt) + ? D3D12_RTV_DIMENSION_TEXTURE2D + : D3D12_RTV_DIMENSION_TEXTURE2DMS + ; rtvDesc.Texture2D.MipSlice = 0; rtvDesc.Texture2D.PlaneSlice = 0; } @@ -2361,33 +2484,36 @@ namespace bgfx { namespace d3d12 } } - D3D12_RESOURCE_DESC resourceDesc; - resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; - resourceDesc.Alignment = 1 < m_scd.sampleDesc.Count ? D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT : 0; - resourceDesc.Width = bx::uint32_max(m_resolution.width, 1); - resourceDesc.Height = bx::uint32_max(m_resolution.height, 1); - resourceDesc.DepthOrArraySize = 1; - resourceDesc.MipLevels = 1; - resourceDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; - resourceDesc.SampleDesc = m_scd.sampleDesc; - resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; - resourceDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; - - D3D12_CLEAR_VALUE clearValue; - clearValue.Format = resourceDesc.Format; - clearValue.DepthStencil.Depth = 1.0f; - clearValue.DepthStencil.Stencil = 0; - m_commandList = m_cmd.alloc(); - m_backBufferDepthStencil = createCommittedResource(m_device, HeapProperty::Default, &resourceDesc, &clearValue); - m_device->CreateDepthStencilView(m_backBufferDepthStencil, NULL, getCPUHandleHeapStart(m_dsvDescriptorHeap)); + if (bimg::isDepth(bimg::TextureFormat::Enum(m_resolution.formatDepthStencil) ) ) + { + D3D12_RESOURCE_DESC resourceDesc; + resourceDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + resourceDesc.Alignment = 1 < m_scd.sampleDesc.Count ? D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT : 0; + resourceDesc.Width = bx::uint32_max(m_resolution.width, 1); + resourceDesc.Height = bx::uint32_max(m_resolution.height, 1); + resourceDesc.DepthOrArraySize = 1; + resourceDesc.MipLevels = 1; + resourceDesc.Format = s_textureFormat[m_resolution.formatDepthStencil].m_fmtDsv; + resourceDesc.SampleDesc = m_scd.sampleDesc; + resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; + resourceDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; + + D3D12_CLEAR_VALUE clearValue; + clearValue.Format = resourceDesc.Format; + clearValue.DepthStencil.Depth = 1.0f; + clearValue.DepthStencil.Stencil = 0; + + m_backBufferDepthStencil = createCommittedResource(m_device, HeapProperty::Default, &resourceDesc, &clearValue); + m_device->CreateDepthStencilView(m_backBufferDepthStencil, NULL, getCPUHandleHeapStart(m_dsvDescriptorHeap) ); - setResourceBarrier(m_commandList - , m_backBufferDepthStencil - , D3D12_RESOURCE_STATE_COMMON - , D3D12_RESOURCE_STATE_DEPTH_WRITE - ); + setResourceBarrier(m_commandList + , m_backBufferDepthStencil + , D3D12_RESOURCE_STATE_COMMON + , D3D12_RESOURCE_STATE_DEPTH_WRITE + ); + } for (uint32_t ii = 0; ii < BX_COUNTOF(m_frameBuffers); ++ii) { @@ -2475,10 +2601,11 @@ namespace bgfx { namespace d3d12 | BGFX_RESET_SUSPEND ); - if (m_resolution.width != _resolution.width - || m_resolution.height != _resolution.height - || m_resolution.format != _resolution.format - || (m_resolution.reset&maskFlags) != (_resolution.reset&maskFlags) ) + if (m_resolution.width != _resolution.width + || m_resolution.height != _resolution.height + || m_resolution.formatColor != _resolution.formatColor + || m_resolution.formatDepthStencil != _resolution.formatDepthStencil + || (m_resolution.reset&maskFlags) != (_resolution.reset&maskFlags) ) { uint32_t flags = _resolution.reset & (~BGFX_RESET_INTERNAL_FORCE); @@ -2495,7 +2622,7 @@ namespace bgfx { namespace d3d12 m_scd.width = _resolution.width; m_scd.height = _resolution.height; - m_scd.format = s_textureFormat[_resolution.format].m_fmt; + m_scd.format = s_textureFormat[_resolution.formatColor].m_fmt; preReset(); @@ -2515,7 +2642,7 @@ namespace bgfx { namespace d3d12 static_assert(BX_COUNTOF(m_backBufferColor) == BX_COUNTOF(presentQueue) ); DX_CHECK(m_dxgi.resizeBuffers(m_swapChain, m_scd, nodeMask, presentQueue) ); #elif BX_PLATFORM_WINRT - DX_CHECK(m_dxgi.resizeBuffers(m_swapChain, m_scd)); + DX_CHECK(m_dxgi.resizeBuffers(m_swapChain, m_scd) ); m_backBufferColorIdx = m_scd.bufferCount-1; #endif // BX_PLATFORM_WINDOWS } @@ -2548,8 +2675,9 @@ namespace bgfx { namespace d3d12 resourceDesc.Height = m_scd.height; resourceDesc.MipLevels = 1; resourceDesc.Format = (m_resolution.reset & BGFX_RESET_SRGB_BACKBUFFER) - ? s_textureFormat[m_resolution.format].m_fmtSrgb - : s_textureFormat[m_resolution.format].m_fmt; + ? s_textureFormat[m_resolution.formatColor].m_fmtSrgb + : s_textureFormat[m_resolution.formatColor].m_fmt + ; resourceDesc.SampleDesc = m_scd.sampleDesc; resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; resourceDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; @@ -2691,7 +2819,11 @@ namespace bgfx { namespace d3d12 m_dsvHandle = getCPUHandleHeapStart(m_dsvDescriptorHeap); m_currentColor = &m_rtvHandle; - m_currentDepthStencil = &m_dsvHandle; + m_currentDepthStencil = NULL != m_backBufferDepthStencil + ? &m_dsvHandle + : NULL + ; + m_commandList->OMSetRenderTargets(1, m_currentColor, true, m_currentDepthStencil); } } @@ -2880,14 +3012,14 @@ namespace bgfx { namespace d3d12 uint32_t setInputLayout(D3D12_INPUT_ELEMENT_DESC* _vertexElements, uint8_t _numStreams, const VertexLayout** _layouts, const ProgramD3D12& _program, uint16_t _numInstanceData) { uint16_t attrMask[Attrib::Count]; - bx::memCopy(attrMask, _program.m_vsh->m_attrMask, sizeof(attrMask)); + bx::memCopy(attrMask, _program.m_vsh->m_attrMask, sizeof(attrMask) ); D3D12_INPUT_ELEMENT_DESC* elem = _vertexElements; for (uint8_t stream = 0; stream < _numStreams; ++stream) { VertexLayout layout; - bx::memCopy(&layout, _layouts[stream], sizeof(VertexLayout)); + bx::memCopy(&layout, _layouts[stream], sizeof(VertexLayout) ); const bool last = stream == _numStreams-1; @@ -3159,7 +3291,7 @@ namespace bgfx { namespace d3d12 union { uint32_t offset; void* ptr; } cast = { 0 }; filter(dxbc.shader, dxbc.shader, patchCb0, cast.ptr); - temp = alloc(uint32_t(dxbc.header.size)); + temp = alloc(uint32_t(dxbc.header.size) ); bx::StaticMemoryBlockWriter wr(temp->data, temp->size); int32_t size = write(&wr, dxbc, &err); @@ -3196,7 +3328,7 @@ namespace bgfx { namespace d3d12 }; filter(dxbc.shader, dxbc.shader, patchCb0, cast.ptr); - temp = alloc(uint32_t(dxbc.header.size)); + temp = alloc(uint32_t(dxbc.header.size) ); bx::StaticMemoryBlockWriter wr(temp->data, temp->size); int32_t size = write(&wr, dxbc, &err); @@ -3649,6 +3781,7 @@ namespace bgfx { namespace d3d12 uint32_t m_backBufferColorIdx; bool m_rtMsaa; bool m_directAccessSupport; + bool m_variableRateShadingSupport; }; static RendererContextD3D12* s_renderD3D12; @@ -4386,7 +4519,7 @@ namespace bgfx { namespace d3d12 for (; numStreams < BX_COUNTOF(cmd.vbv); ++numStreams) { D3D12_VERTEX_BUFFER_VIEW* vbv = &cmd.vbv[numStreams]; - bx::memSet(vbv, 0, sizeof(D3D12_VERTEX_BUFFER_VIEW)); + bx::memSet(vbv, 0, sizeof(D3D12_VERTEX_BUFFER_VIEW) ); } cmd.args.InstanceCount = _draw.m_numInstances; @@ -4430,7 +4563,7 @@ namespace bgfx { namespace d3d12 for (; numStreams < BX_COUNTOF(cmd.vbv); ++numStreams) { D3D12_VERTEX_BUFFER_VIEW* vbv = &cmd.vbv[numStreams]; - bx::memSet(vbv, 0, sizeof(D3D12_VERTEX_BUFFER_VIEW)); + bx::memSet(vbv, 0, sizeof(D3D12_VERTEX_BUFFER_VIEW) ); } cmd.args.IndexCountPerInstance = numIndices; @@ -5444,7 +5577,7 @@ namespace bgfx { namespace d3d12 m_directAccessPtr = NULL; } - if (0 == (m_flags & BGFX_SAMPLER_INTERNAL_SHARED)) + if (0 == (m_flags & BGFX_SAMPLER_INTERNAL_SHARED) ) { s_renderD3D12->m_cmd.release(m_ptr); m_ptr = NULL; @@ -5472,9 +5605,9 @@ namespace bgfx { namespace d3d12 const uint32_t bpp = bimg::getBitsPerPixel(bimg::TextureFormat::Enum(m_textureFormat) ); uint32_t rectpitch = _rect.m_width*bpp/8; - if (bimg::isCompressed(bimg::TextureFormat::Enum(m_textureFormat))) + if (bimg::isCompressed(bimg::TextureFormat::Enum(m_textureFormat) ) ) { - const bimg::ImageBlockInfo& blockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(m_textureFormat)); + const bimg::ImageBlockInfo& blockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(m_textureFormat) ); rectpitch = (_rect.m_width / blockInfo.blockWidth) * blockInfo.blockSize; } @@ -5511,7 +5644,7 @@ namespace bgfx { namespace d3d12 if (convert) { temp = (uint8_t*)bx::alloc(g_allocator, slicepitch); - bimg::imageDecodeToBgra8(g_allocator, temp, srcData, _rect.m_width, _rect.m_height, srcpitch, bimg::TextureFormat::Enum(m_requestedFormat)); + bimg::imageDecodeToBgra8(g_allocator, temp, srcData, _rect.m_width, _rect.m_height, srcpitch, bimg::TextureFormat::Enum(m_requestedFormat) ); srcData = temp; box.right = bx::max(1u, m_width >> _mip); @@ -6349,6 +6482,16 @@ namespace bgfx { namespace d3d12 } } + void RendererContextD3D12::submitUniformCache(UniformCacheState& _ucs, uint16_t _view) + { + while (_ucs.hasItem(_view) ) + { + const UniformCacheItem& uci = _ucs.advance(); + + bx::memCopy(m_uniforms[uci.m_handle], &_ucs.m_frame->m_uniformCacheFrame.m_data[uci.m_offset], uci.m_size); + } + } + void RendererContextD3D12::submit(Frame* _render, ClearQuad& /*_clearQuad*/, TextVideoMemBlitter& _textVideoMemBlitter) { if (m_lost @@ -6409,6 +6552,7 @@ namespace bgfx { namespace d3d12 uint16_t view = UINT16_MAX; FrameBufferHandle fbh = { BGFX_CONFIG_MAX_FRAME_BUFFERS }; + UniformCacheState ucs(_render); BlitState bs(_render); uint32_t blendFactor = 0; @@ -6535,12 +6679,14 @@ namespace bgfx { namespace d3d12 profiler.begin(view); + const View& renderView = _render->m_view[view]; + fbh = _render->m_view[view].m_fbh; setFrameBuffer(fbh); - viewState.m_rect = _render->m_view[view].m_rect; - const Rect& rect = _render->m_view[view].m_rect; - const Rect& scissorRect = _render->m_view[view].m_scissor; + viewState.m_rect = renderView.m_rect; + const Rect& rect = renderView.m_rect; + const Rect& scissorRect = renderView.m_scissor; viewHasScissor = !scissorRect.isZero(); viewScissorRect = viewHasScissor ? scissorRect : rect; @@ -6561,7 +6707,7 @@ namespace bgfx { namespace d3d12 m_commandList->RSSetScissorRects(1, &rc); restoreScissor = false; - Clear& clr = _render->m_view[view].m_clear; + const Clear& clr = renderView.m_clear; if (BGFX_CLEAR_NONE != clr.m_flags) { Rect clearRect = rect; @@ -6571,7 +6717,13 @@ namespace bgfx { namespace d3d12 prim = s_primInfo[Topology::Count]; // Force primitive type update. + submitUniformCache(ucs, view); submitBlit(bs, view); + + if (m_variableRateShadingSupport) + { + reinterpret_cast(m_commandList)->RSSetShadingRate(s_shadingRate[renderView.m_shadingRate], NULL); + } } if (isCompute) @@ -7356,12 +7508,17 @@ namespace bgfx { namespace d3d12 ); double elapsedCpuMs = double(frameTime)*toMs; - tvm.printf(10, pos++, 0x8b, " Submitted: %5d (draw %5d, compute %4d) / CPU %7.4f [ms] " + tvm.printf(10, pos++, 0x8b, " Submitted: %5d (draw %5d, compute %4d) / CPU %7.4f [ms] %c GPU %7.4f [ms] (latency %d) " , _render->m_numRenderItems , statsKeyType[0] , statsKeyType[1] , elapsedCpuMs + , elapsedCpuMs > maxGpuElapsed ? '>' : '<' + , maxGpuElapsed + , maxGpuLatency ); + maxGpuLatency = 0; + maxGpuElapsed = 0.0; for (uint32_t ii = 0; ii < Topology::Count; ++ii) { diff --git a/libs/bgfx/src/renderer_d3d12.h b/libs/bgfx/src/renderer_d3d12.h index a0cb6a1..3c98834 100644 --- a/libs/bgfx/src/renderer_d3d12.h +++ b/libs/bgfx/src/renderer_d3d12.h @@ -20,26 +20,6 @@ # include #endif // BX_PLATFORM_XBOXONE -#if defined(__MINGW32__) // BK - temp workaround for MinGW until I nuke d3dx12 usage. -extern "C++" { -# if defined(__cpp_constexpr) && __cpp_constexpr >= 200704L \ - && defined(__cpp_inline_variables) && __cpp_inline_variables >= 201606L - __extension__ template - constexpr const GUID& __mingw_uuidof(); -# else - __extension__ template - const GUID& __mingw_uuidof(); -# endif // __cpp_* - - template<> - const GUID& __mingw_uuidof() - { - static const GUID IID_ID3D12Device0 = { 0x189819f1, 0x1db6, 0x4b57, { 0xbe, 0x54, 0x18, 0x21, 0x33, 0x9b, 0x85, 0xf7 } }; - return IID_ID3D12Device0; - } -} -#endif // defined(__MINGW32__) - #include "renderer.h" #include "renderer_d3d.h" #include "shader_dxbc.h" @@ -50,7 +30,7 @@ extern "C++" { #if BGFX_CONFIG_DEBUG_ANNOTATION && !BX_PLATFORM_LINUX # if BX_PLATFORM_WINDOWS || BX_PLATFORM_WINRT typedef struct PIXEventsThreadInfo* (WINAPI* PFN_PIX_GET_THREAD_INFO)(); -typedef uint64_t (WINAPI* PFN_PIX_EVENTS_REPLACE_BLOCK)(bool _getEarliestTime); +typedef uint64_t (WINAPI* PFN_PIX_EVENTS_REPLACE_BLOCK)(PIXEventsThreadInfo* _threadInfo, bool _getEarliestTime); extern PFN_PIX_GET_THREAD_INFO bgfx_PIXGetThreadInfo; extern PFN_PIX_EVENTS_REPLACE_BLOCK bgfx_PIXEventsReplaceBlock; @@ -59,7 +39,7 @@ extern PFN_PIX_EVENTS_REPLACE_BLOCK bgfx_PIXEventsReplaceBlock; # define PIXEventsReplaceBlock bgfx_PIXEventsReplaceBlock # else extern "C" struct PIXEventsThreadInfo* WINAPI bgfx_PIXGetThreadInfo(); -extern "C" uint64_t WINAPI bgfx_PIXEventsReplaceBlock(bool _getEarliestTime); +extern "C" uint64_t WINAPI bgfx_PIXEventsReplaceBlock(PIXEventsThreadInfo* _threadInfo, bool _getEarliestTime); # endif // BX_PLATFORM_WINDOWS # include diff --git a/libs/bgfx/src/renderer_gl.cpp b/libs/bgfx/src/renderer_gl.cpp index 5cbd811..f2554e6 100644 --- a/libs/bgfx/src/renderer_gl.cpp +++ b/libs/bgfx/src/renderer_gl.cpp @@ -224,9 +224,13 @@ namespace bgfx { namespace gl { GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, GL_ZERO, GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, GL_ZERO, false, { $_, $_, $_, $_ } }, // BC6H { GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB, GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_ZERO, false, { $_, $_, $_, $_ } }, // BC7 { GL_ETC1_RGB8_OES, GL_ZERO, GL_ETC1_RGB8_OES, GL_ETC1_RGB8_OES, GL_ZERO, false, { $_, $_, $_, $_ } }, // ETC1 - { GL_COMPRESSED_RGB8_ETC2, GL_ZERO, GL_COMPRESSED_RGB8_ETC2, GL_COMPRESSED_RGB8_ETC2, GL_ZERO, false, { $_, $_, $_, $_ } }, // ETC2 - { GL_COMPRESSED_RGBA8_ETC2_EAC, GL_COMPRESSED_SRGB8_ETC2, GL_COMPRESSED_RGBA8_ETC2_EAC, GL_COMPRESSED_RGBA8_ETC2_EAC, GL_ZERO, false, { $_, $_, $_, $_ } }, // ETC2A + { GL_COMPRESSED_RGB8_ETC2, GL_COMPRESSED_SRGB8_ETC2, GL_COMPRESSED_RGB8_ETC2, GL_COMPRESSED_RGB8_ETC2, GL_ZERO, false, { $_, $_, $_, $_ } }, // ETC2 + { GL_COMPRESSED_RGBA8_ETC2_EAC, GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, GL_COMPRESSED_RGBA8_ETC2_EAC, GL_COMPRESSED_RGBA8_ETC2_EAC, GL_ZERO, false, { $_, $_, $_, $_ } }, // ETC2A { GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GL_ZERO, false, { $_, $_, $_, $_ } }, // ETC2A1 + { GL_COMPRESSED_R11_EAC, GL_ZERO, GL_COMPRESSED_R11_EAC, GL_COMPRESSED_R11_EAC, GL_ZERO, false, { $_, $_, $_, $_ } }, // EACR11 UNORM + { GL_COMPRESSED_SIGNED_R11_EAC, GL_ZERO, GL_COMPRESSED_SIGNED_R11_EAC, GL_COMPRESSED_SIGNED_R11_EAC, GL_ZERO, false, { $_, $_, $_, $_ } }, // EACR11 SNORM + { GL_COMPRESSED_RG11_EAC, GL_ZERO, GL_COMPRESSED_RG11_EAC, GL_COMPRESSED_RG11_EAC, GL_ZERO, false, { $_, $_, $_, $_ } }, // EACRG11 UNORM + { GL_COMPRESSED_SIGNED_RG11_EAC, GL_ZERO, GL_COMPRESSED_SIGNED_RG11_EAC, GL_COMPRESSED_SIGNED_RG11_EAC, GL_ZERO, false, { $_, $_, $_, $_ } }, // EACRG11 SNORM { GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG, GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT, GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG, GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG, GL_ZERO, false, { $_, $_, $_, $_ } }, // PTC12 { GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT, GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, GL_ZERO, false, { $_, $_, $_, $_ } }, // PTC14 { GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT, GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, GL_ZERO, false, { $_, $_, $_, $_ } }, // PTC12A @@ -337,6 +341,10 @@ namespace bgfx { namespace gl GL_ZERO, // ETC2 GL_ZERO, // ETC2A GL_ZERO, // ETC2A1 + GL_ZERO, // EACR11 UNORM + GL_ZERO, // EACR11 SNORM + GL_ZERO, // EACRG11 UNORM + GL_ZERO, // EACRG11 SNORM GL_ZERO, // PTC12 GL_ZERO, // PTC14 GL_ZERO, // PTC12A @@ -438,6 +446,10 @@ namespace bgfx { namespace gl GL_ZERO, // ETC2 GL_ZERO, // ETC2A GL_ZERO, // ETC2A1 + GL_ZERO, // EACR11 UNORM + GL_ZERO, // EACR11 SNORM + GL_ZERO, // EACRG11 UNORM + GL_ZERO, // EACRG11 SNORM GL_ZERO, // PTC12 GL_ZERO, // PTC14 GL_ZERO, // PTC12A @@ -1479,7 +1491,7 @@ namespace bgfx { namespace gl , _internalFormat , _width , _height - , false + , true ); } else @@ -2280,11 +2292,11 @@ namespace bgfx { namespace gl m_renderdocdll = loadRenderDoc(); } - m_fbh.idx = kInvalidHandle; + m_fbh = BGFX_INVALID_HANDLE; bx::memSet(m_uniforms, 0, sizeof(m_uniforms) ); bx::memSet(&m_resolution, 0, sizeof(m_resolution) ); - setRenderContextSize(_init.resolution.width, _init.resolution.height, _init.resolution.reset); + setRenderContextSize(_init.resolution); m_vendor = getGLString(GL_VENDOR); m_renderer = getGLString(GL_RENDERER); @@ -2968,12 +2980,14 @@ namespace bgfx { namespace gl || s_extension[Extension::EXT_shadow_samplers].m_supported ; + GLint numFormats = 0; + GL_CHECK(glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &numFormats) ); m_programBinarySupport = !BX_ENABLED(BX_PLATFORM_EMSCRIPTEN) && (m_gles3 || s_extension[Extension::ARB_get_program_binary].m_supported || s_extension[Extension::OES_get_program_binary].m_supported || s_extension[Extension::IMG_shader_binary ].m_supported - ); + ) && numFormats > 0; m_textureSwizzleSupport = false || s_extension[Extension::ARB_texture_swizzle].m_supported @@ -3166,7 +3180,10 @@ namespace bgfx { namespace gl m_maxLabelLen = BX_ENABLED(BGFX_CONFIG_RENDERER_OPENGLES >= 32) || BX_ENABLED(BGFX_CONFIG_RENDERER_OPENGL >= 43) || s_extension[Extension::KHR_debug].m_supported ? uint16_t(glGet(GL_MAX_LABEL_LENGTH) ) : 0; - setGraphicsDebuggerPresent(s_extension[Extension::EXT_debug_tool].m_supported); + setGraphicsDebuggerPresent(false + || s_extension[Extension::EXT_debug_tool].m_supported + || NULL != findModule("Nvda.Graphics.Interception.dll") + ); if (NULL == glObjectLabel) { @@ -3475,8 +3492,7 @@ namespace bgfx { namespace gl const Memory* mem = alloc(size); bx::StaticMemoryBlockWriter writer(mem->data, mem->size); - uint32_t magic = BGFX_CHUNK_MAGIC_TEX; - bx::write(&writer, magic, bx::ErrorAssert{}); + bx::write(&writer, kChunkMagicTex, bx::ErrorAssert{}); TextureCreate tc; tc.m_width = _width; @@ -3495,7 +3511,7 @@ namespace bgfx { namespace gl release(mem); } - void overrideInternal(TextureHandle _handle, uintptr_t _ptr) override + void overrideInternal(TextureHandle _handle, uintptr_t _ptr, uint16_t /*_layerIndex*/) override { m_textures[_handle.idx].overrideInternal(_ptr); } @@ -3517,9 +3533,10 @@ namespace bgfx { namespace gl void createFrameBuffer(FrameBufferHandle _handle, void* _nwh, uint32_t _width, uint32_t _height, TextureFormat::Enum _format, TextureFormat::Enum _depthFormat) override { + BX_UNUSED(_format, _depthFormat); uint16_t denseIdx = m_numWindows++; m_windows[denseIdx] = _handle; - m_frameBuffers[_handle.idx].create(denseIdx, _nwh, _width, _height, _format, _depthFormat); + m_frameBuffers[_handle.idx].create(denseIdx, _nwh, _width, _height); } void destroyFrameBuffer(FrameBufferHandle _handle) override @@ -3669,6 +3686,8 @@ namespace bgfx { namespace gl void submitBlit(BlitState& _bs, uint16_t _view); + void submitUniformCache(UniformCacheState& _ucs, uint16_t _view); + void submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter) override; void blitSetup(TextVideoMemBlitter& _blitter) override @@ -3738,10 +3757,16 @@ namespace bgfx { namespace gl void updateResolution(const Resolution& _resolution) { - m_maxAnisotropy = !!(_resolution.reset & BGFX_RESET_MAXANISOTROPY) + float maxAnisotropy = !!(_resolution.reset & BGFX_RESET_MAXANISOTROPY) ? m_maxAnisotropyDefault : 0.0f ; + + if (m_maxAnisotropy != maxAnisotropy) + { + m_maxAnisotropy = maxAnisotropy; + invalidateCache(); + } if (s_extension[Extension::ARB_depth_clamp].m_supported) { @@ -3773,10 +3798,7 @@ namespace bgfx { namespace gl m_textVideoMem.resize(false, _resolution.width, _resolution.height); m_textVideoMem.clear(); - setRenderContextSize(m_resolution.width - , m_resolution.height - , flags - ); + setRenderContextSize(m_resolution); updateCapture(); for (uint32_t ii = 0; ii < BX_COUNTOF(m_frameBuffers); ++ii) @@ -3974,8 +3996,8 @@ namespace bgfx { namespace gl } )"; - const GLchar *const vs = msaa_blit_vs; - const GLchar *const fs = msaa_blit_fs; + const GLchar* vs = msaa_blit_vs; + const GLchar* fs = msaa_blit_fs; GLuint shader_vs = glCreateShader(GL_VERTEX_SHADER); { @@ -4151,22 +4173,22 @@ namespace bgfx { namespace gl } } - void setRenderContextSize(uint32_t _width, uint32_t _height, uint32_t _flags = 0) + void setRenderContextSize(const Resolution& _resolution) { if (!m_glctx.isValid() ) { - m_glctx.create(_width, _height, _flags); + m_glctx.create(_resolution); } else { destroyMsaaFbo(); - m_glctx.resize(_width, _height, _flags); + m_glctx.resize(_resolution); - uint32_t msaa = (_flags&BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT; + uint32_t msaa = (_resolution.reset & BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT; msaa = bx::uint32_min(m_maxMsaa, msaa == 0 ? 0 : 1<writeUniformHandle(type, 0, info->m_handle, uint16_t(num) ); + m_constantBuffer->writeUniformHandle(bx::narrowCast(type), 0, info->m_handle, uint16_t(num) ); m_constantBuffer->write(loc); BX_TRACE("store %s %d", name, info->m_handle); } @@ -7102,7 +7125,7 @@ namespace bgfx { namespace gl { const TextureGL& texture = s_renderGL->m_textures[at.handle.idx]; - if (0 != texture.m_id) + if (0 != texture.m_rbo && 0 != texture.m_id) { GLenum attachment = GL_INVALID_ENUM; @@ -7151,9 +7174,8 @@ namespace bgfx { namespace gl } } - void FrameBufferGL::create(uint16_t _denseIdx, void* _nwh, uint32_t _width, uint32_t _height, TextureFormat::Enum _format, TextureFormat::Enum _depthFormat) + void FrameBufferGL::create(uint16_t _denseIdx, void* _nwh, uint32_t _width, uint32_t _height) { - BX_UNUSED(_format, _depthFormat); m_swapChain = s_renderGL->m_glctx.createSwapChain(_nwh, _width, _height); m_width = _width; m_height = _height; @@ -7461,6 +7483,16 @@ namespace bgfx { namespace gl } } + void RendererContextGL::submitUniformCache(UniformCacheState& _ucs, uint16_t _view) + { + while (_ucs.hasItem(_view) ) + { + const UniformCacheItem& uci = _ucs.advance(); + + bx::memCopy(m_uniforms[uci.m_handle], &_ucs.m_frame->m_uniformCacheFrame.m_data[uci.m_offset], uci.m_size); + } + } + void RendererContextGL::submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter) { if (_render->m_capture) @@ -7525,6 +7557,7 @@ namespace bgfx { namespace gl uint16_t view = UINT16_MAX; FrameBufferHandle fbh = { BGFX_CONFIG_MAX_FRAME_BUFFERS }; + UniformCacheState ucs(_render); BlitState bs(_render); int32_t resolutionHeight = _render->m_resolution.height; @@ -7647,6 +7680,7 @@ namespace bgfx { namespace gl GL_CHECK(glEnable(GL_CULL_FACE) ); GL_CHECK(glDisable(GL_BLEND) ); + submitUniformCache(ucs, view); submitBlit(bs, view); } @@ -7756,7 +7790,7 @@ namespace bgfx { namespace gl { if (isValid(currentState.m_indirectBuffer) ) { - currentState.m_indirectBuffer.idx = kInvalidHandle; + currentState.m_indirectBuffer = BGFX_INVALID_HANDLE; GL_CHECK(glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, 0) ); } @@ -8469,12 +8503,12 @@ namespace bgfx { namespace gl { if (isValid(currentState.m_indirectBuffer) ) { - currentState.m_indirectBuffer.idx = kInvalidHandle; + currentState.m_indirectBuffer = BGFX_INVALID_HANDLE; GL_CHECK(glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0) ); if (isValid(currentState.m_numIndirectBuffer) ) { - currentState.m_numIndirectBuffer.idx = kInvalidHandle; + currentState.m_numIndirectBuffer = BGFX_INVALID_HANDLE; GL_CHECK(glBindBuffer(GL_PARAMETER_BUFFER_ARB, 0) ); } } diff --git a/libs/bgfx/src/renderer_gl.h b/libs/bgfx/src/renderer_gl.h index 87bb25c..6847db8 100644 --- a/libs/bgfx/src/renderer_gl.h +++ b/libs/bgfx/src/renderer_gl.h @@ -11,7 +11,8 @@ || BX_PLATFORM_LINUX \ || BX_PLATFORM_NX \ || BX_PLATFORM_RPI \ - ) ) + ) ) \ + || (BGFX_CONFIG_RENDERER_OPENGLES && BX_PLATFORM_WINDOWS) #define BGFX_USE_HTML5 (BGFX_CONFIG_RENDERER_OPENGLES && (0 \ || BX_PLATFORM_EMSCRIPTEN \ @@ -87,6 +88,7 @@ typedef double GLdouble; typedef int64_t GLint64; typedef uint64_t GLuint64; # define GL_PROGRAM_BINARY_LENGTH GL_PROGRAM_BINARY_LENGTH_OES +# define GL_NUM_PROGRAM_BINARY_FORMATS GL_NUM_PROGRAM_BINARY_FORMATS_OES # define GL_HALF_FLOAT GL_HALF_FLOAT_OES # define GL_RGBA8 GL_RGBA8_OES # define GL_UNSIGNED_INT_2_10_10_10_REV GL_UNSIGNED_INT_2_10_10_10_REV_EXT @@ -419,6 +421,22 @@ typedef uint64_t GLuint64; # define GL_ETC1_RGB8_OES 0x8D64 #endif // GL_ETC1_RGB8_OES +#ifndef GL_COMPRESSED_R11_EAC +# define GL_COMPRESSED_R11_EAC 0x9270 +#endif // GL_COMPRESSED_R11_EAC + +#ifndef GL_COMPRESSED_SIGNED_R11_EAC +# define GL_COMPRESSED_SIGNED_R11_EAC 0x9271 +#endif // GL_COMPRESSED_SIGNED_R11_EAC + +#ifndef GL_COMPRESSED_RG11_EAC +# define GL_COMPRESSED_RG11_EAC 0x9272 +#endif // GL_COMPRESSED_RG11_EAC + +#ifndef GL_COMPRESSED_SIGNED_RG11_EAC +# define GL_COMPRESSED_SIGNED_RG11_EAC 0x9273 +#endif // GL_COMPRESSED_SIGNED_RG11_EAC + #ifndef GL_COMPRESSED_RGB8_ETC2 # define GL_COMPRESSED_RGB8_ETC2 0x9274 #endif // GL_COMPRESSED_RGB8_ETC2 @@ -427,6 +445,10 @@ typedef uint64_t GLuint64; # define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278 #endif // GL_COMPRESSED_RGBA8_ETC2_EAC +#ifndef GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC +# define GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279 +#endif // GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC + #ifndef GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 # define GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276 #endif // GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 @@ -1491,7 +1513,7 @@ namespace bgfx { namespace gl } void create(uint8_t _num, const Attachment* _attachment); - void create(uint16_t _denseIdx, void* _nwh, uint32_t _width, uint32_t _height, TextureFormat::Enum _format, TextureFormat::Enum _depthFormat); + void create(uint16_t _denseIdx, void* _nwh, uint32_t _width, uint32_t _height); void postReset(); uint16_t destroy(); void resolve(); diff --git a/libs/bgfx/src/renderer_mtl.h b/libs/bgfx/src/renderer_mtl.h index c04a994..ac1b54b 100644 --- a/libs/bgfx/src/renderer_mtl.h +++ b/libs/bgfx/src/renderer_mtl.h @@ -1,5 +1,5 @@ /* - * Copyright 2011-2015 Attila Kocsis, Branimir Karadzic. All rights reserved. + * Copyright 2011-2025 Attila Kocsis. All rights reserved. * License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE */ @@ -18,10 +18,6 @@ # import #endif // BX_PLATFORM_* -#if BX_PLATFORM_VISIONOS -#import -#endif - #define BGFX_MTL_PROFILER_BEGIN(_view, _abgr) \ BX_MACRO_BLOCK_BEGIN \ BGFX_PROFILER_BEGIN(s_viewName[view], _abgr); \ @@ -37,8 +33,231 @@ BGFX_PROFILER_END(); \ BX_MACRO_BLOCK_END +#define _MTL_RELEASE(_obj, _expected, _check) \ + BX_MACRO_BLOCK_BEGIN \ + if (NULL != _obj) \ + { \ + const NSUInteger count = [_obj retainCount] - 1; \ + _check(isGraphicsDebuggerPresent() \ + || _expected == count \ + , "%p RefCount is %d (expected %d). Label: \"%s\"." \ + , _obj \ + , count \ + , _expected \ + , [_obj respondsToSelector:@selector(label)] \ + ? [[_obj performSelector:@selector(label)] UTF8String] \ + : "?!" \ + ); \ + BX_UNUSED(count); \ + [_obj release]; \ + _obj = NULL; \ + } \ + BX_MACRO_BLOCK_END + +#define _MTL_CHECK_REFCOUNT(_obj, _expected) \ + BX_MACRO_BLOCK_BEGIN \ + const NSUInteger count = [_obj retainCount]; \ + BX_ASSERT(isGraphicsDebuggerPresent() \ + || _expected == count \ + , "%p RefCount is %d (expected %d). Label: \"%s\"." \ + , _obj \ + , count \ + , _expected \ + , [_obj respondsToSelector:@selector(label)] \ + ? [[_obj performSelector:@selector(label)] UTF8String] \ + : "?!" \ + ); \ + BX_MACRO_BLOCK_END + +#if BGFX_CONFIG_DEBUG +# define MTL_CHECK_REFCOUNT(_ptr, _expected) _MTL_CHECK_REFCOUNT(_ptr, _expected) +#else +# define MTL_CHECK_REFCOUNT(_ptr, _expected) +#endif // BGFX_CONFIG_DEBUG + +#define MTL_RELEASE(_obj, _expected) _MTL_RELEASE(_obj, _expected, BX_WARN) +#define MTL_RELEASE_W(_obj, _expected) _MTL_RELEASE(_obj, _expected, BX_WARN) +#define MTL_RELEASE_I(_obj) _MTL_RELEASE(_obj, 0, BX_NOOP) + +// C++ wrapper +// Objects with creation functions starting with 'new' has a refcount 1 after creation, object +// must be destroyed with release. commandBuffer, commandEncoders are autoreleased objects. +// Needs AutoreleasePool! +#define MTL_CLASS(_className) \ + class _className \ + { \ + public: \ + _className(id _obj = NULL) \ + : m_obj(_obj) \ + { \ + } \ + \ + operator id() const \ + { \ + return m_obj; \ + } \ + \ + id m_obj; + +#define MTL_CLASS_END }; + namespace bgfx { namespace mtl { + // Metal API has obnoxious "availability" annotations on enums causing build errors when + // referencing format, and requiring use of ifdefery to reference format. To reduce ifdefery + // bgfx uses redefined formats, and on initialization it sets up format caps and provides + // availability. + constexpr MTLPixelFormat kMtlPixelFormatInvalid = MTLPixelFormat(0); + constexpr MTLPixelFormat kMtlPixelFormatA8Unorm = MTLPixelFormat(1); + constexpr MTLPixelFormat kMtlPixelFormatR8Unorm = MTLPixelFormat(10); + constexpr MTLPixelFormat kMtlPixelFormatR8Unorm_sRGB = MTLPixelFormat(11); + constexpr MTLPixelFormat kMtlPixelFormatR8Snorm = MTLPixelFormat(12); + constexpr MTLPixelFormat kMtlPixelFormatR8Uint = MTLPixelFormat(13); + constexpr MTLPixelFormat kMtlPixelFormatR8Sint = MTLPixelFormat(14); + constexpr MTLPixelFormat kMtlPixelFormatR16Unorm = MTLPixelFormat(20); + constexpr MTLPixelFormat kMtlPixelFormatR16Snorm = MTLPixelFormat(22); + constexpr MTLPixelFormat kMtlPixelFormatR16Uint = MTLPixelFormat(23); + constexpr MTLPixelFormat kMtlPixelFormatR16Sint = MTLPixelFormat(24); + constexpr MTLPixelFormat kMtlPixelFormatR16Float = MTLPixelFormat(25); + constexpr MTLPixelFormat kMtlPixelFormatRG8Unorm = MTLPixelFormat(30); + constexpr MTLPixelFormat kMtlPixelFormatRG8Unorm_sRGB = MTLPixelFormat(31); + constexpr MTLPixelFormat kMtlPixelFormatRG8Snorm = MTLPixelFormat(32); + constexpr MTLPixelFormat kMtlPixelFormatRG8Uint = MTLPixelFormat(33); + constexpr MTLPixelFormat kMtlPixelFormatRG8Sint = MTLPixelFormat(34); + constexpr MTLPixelFormat kMtlPixelFormatB5G6R5Unorm = MTLPixelFormat(40); + constexpr MTLPixelFormat kMtlPixelFormatA1BGR5Unorm = MTLPixelFormat(41); + constexpr MTLPixelFormat kMtlPixelFormatABGR4Unorm = MTLPixelFormat(42); + constexpr MTLPixelFormat kMtlPixelFormatBGR5A1Unorm = MTLPixelFormat(43); + constexpr MTLPixelFormat kMtlPixelFormatR32Uint = MTLPixelFormat(53); + constexpr MTLPixelFormat kMtlPixelFormatR32Sint = MTLPixelFormat(54); + constexpr MTLPixelFormat kMtlPixelFormatR32Float = MTLPixelFormat(55); + constexpr MTLPixelFormat kMtlPixelFormatRG16Unorm = MTLPixelFormat(60); + constexpr MTLPixelFormat kMtlPixelFormatRG16Snorm = MTLPixelFormat(62); + constexpr MTLPixelFormat kMtlPixelFormatRG16Uint = MTLPixelFormat(63); + constexpr MTLPixelFormat kMtlPixelFormatRG16Sint = MTLPixelFormat(64); + constexpr MTLPixelFormat kMtlPixelFormatRG16Float = MTLPixelFormat(65); + constexpr MTLPixelFormat kMtlPixelFormatRGBA8Unorm = MTLPixelFormat(70); + constexpr MTLPixelFormat kMtlPixelFormatRGBA8Unorm_sRGB = MTLPixelFormat(71); + constexpr MTLPixelFormat kMtlPixelFormatRGBA8Snorm = MTLPixelFormat(72); + constexpr MTLPixelFormat kMtlPixelFormatRGBA8Uint = MTLPixelFormat(73); + constexpr MTLPixelFormat kMtlPixelFormatRGBA8Sint = MTLPixelFormat(74); + constexpr MTLPixelFormat kMtlPixelFormatBGRA8Unorm = MTLPixelFormat(80); + constexpr MTLPixelFormat kMtlPixelFormatBGRA8Unorm_sRGB = MTLPixelFormat(81); + constexpr MTLPixelFormat kMtlPixelFormatRGB10A2Unorm = MTLPixelFormat(90); + constexpr MTLPixelFormat kMtlPixelFormatRGB10A2Uint = MTLPixelFormat(91); + constexpr MTLPixelFormat kMtlPixelFormatRG11B10Float = MTLPixelFormat(92); + constexpr MTLPixelFormat kMtlPixelFormatRGB9E5Float = MTLPixelFormat(93); + constexpr MTLPixelFormat kMtlPixelFormatBGR10A2Unorm = MTLPixelFormat(94); + constexpr MTLPixelFormat kMtlPixelFormatBGR10_XR = MTLPixelFormat(554); + constexpr MTLPixelFormat kMtlPixelFormatBGR10_XR_sRGB = MTLPixelFormat(555); + constexpr MTLPixelFormat kMtlPixelFormatRG32Uint = MTLPixelFormat(103); + constexpr MTLPixelFormat kMtlPixelFormatRG32Sint = MTLPixelFormat(104); + constexpr MTLPixelFormat kMtlPixelFormatRG32Float = MTLPixelFormat(105); + constexpr MTLPixelFormat kMtlPixelFormatRGBA16Unorm = MTLPixelFormat(110); + constexpr MTLPixelFormat kMtlPixelFormatRGBA16Snorm = MTLPixelFormat(112); + constexpr MTLPixelFormat kMtlPixelFormatRGBA16Uint = MTLPixelFormat(113); + constexpr MTLPixelFormat kMtlPixelFormatRGBA16Sint = MTLPixelFormat(114); + constexpr MTLPixelFormat kMtlPixelFormatRGBA16Float = MTLPixelFormat(115); + constexpr MTLPixelFormat kMtlPixelFormatBGRA10_XR = MTLPixelFormat(552); + constexpr MTLPixelFormat kMtlPixelFormatBGRA10_XR_sRGB = MTLPixelFormat(553); + constexpr MTLPixelFormat kMtlPixelFormatRGBA32Uint = MTLPixelFormat(123); + constexpr MTLPixelFormat kMtlPixelFormatRGBA32Sint = MTLPixelFormat(124); + constexpr MTLPixelFormat kMtlPixelFormatRGBA32Float = MTLPixelFormat(125); + constexpr MTLPixelFormat kMtlPixelFormatBC1_RGBA = MTLPixelFormat(130); + constexpr MTLPixelFormat kMtlPixelFormatBC1_RGBA_sRGB = MTLPixelFormat(131); + constexpr MTLPixelFormat kMtlPixelFormatBC2_RGBA = MTLPixelFormat(132); + constexpr MTLPixelFormat kMtlPixelFormatBC2_RGBA_sRGB = MTLPixelFormat(133); + constexpr MTLPixelFormat kMtlPixelFormatBC3_RGBA = MTLPixelFormat(134); + constexpr MTLPixelFormat kMtlPixelFormatBC3_RGBA_sRGB = MTLPixelFormat(135); + constexpr MTLPixelFormat kMtlPixelFormatBC4_RUnorm = MTLPixelFormat(140); + constexpr MTLPixelFormat kMtlPixelFormatBC4_RSnorm = MTLPixelFormat(141); + constexpr MTLPixelFormat kMtlPixelFormatBC5_RGUnorm = MTLPixelFormat(142); + constexpr MTLPixelFormat kMtlPixelFormatBC5_RGSnorm = MTLPixelFormat(143); + constexpr MTLPixelFormat kMtlPixelFormatBC6H_RGBFloat = MTLPixelFormat(150); + constexpr MTLPixelFormat kMtlPixelFormatBC6H_RGBUfloat = MTLPixelFormat(151); + constexpr MTLPixelFormat kMtlPixelFormatBC7_RGBAUnorm = MTLPixelFormat(152); + constexpr MTLPixelFormat kMtlPixelFormatBC7_RGBAUnorm_sRGB = MTLPixelFormat(153); + constexpr MTLPixelFormat kMtlPixelFormatPVRTC_RGB_2BPP = MTLPixelFormat(160); + constexpr MTLPixelFormat kMtlPixelFormatPVRTC_RGB_2BPP_sRGB = MTLPixelFormat(161); + constexpr MTLPixelFormat kMtlPixelFormatPVRTC_RGB_4BPP = MTLPixelFormat(162); + constexpr MTLPixelFormat kMtlPixelFormatPVRTC_RGB_4BPP_sRGB = MTLPixelFormat(163); + constexpr MTLPixelFormat kMtlPixelFormatPVRTC_RGBA_2BPP = MTLPixelFormat(164); + constexpr MTLPixelFormat kMtlPixelFormatPVRTC_RGBA_2BPP_sRGB = MTLPixelFormat(165); + constexpr MTLPixelFormat kMtlPixelFormatPVRTC_RGBA_4BPP = MTLPixelFormat(166); + constexpr MTLPixelFormat kMtlPixelFormatPVRTC_RGBA_4BPP_sRGB = MTLPixelFormat(167); + constexpr MTLPixelFormat kMtlPixelFormatEAC_R11Unorm = MTLPixelFormat(170); + constexpr MTLPixelFormat kMtlPixelFormatEAC_R11Snorm = MTLPixelFormat(172); + constexpr MTLPixelFormat kMtlPixelFormatEAC_RG11Unorm = MTLPixelFormat(174); + constexpr MTLPixelFormat kMtlPixelFormatEAC_RG11Snorm = MTLPixelFormat(176); + constexpr MTLPixelFormat kMtlPixelFormatEAC_RGBA8 = MTLPixelFormat(178); + constexpr MTLPixelFormat kMtlPixelFormatEAC_RGBA8_sRGB = MTLPixelFormat(179); + constexpr MTLPixelFormat kMtlPixelFormatETC2_RGB8 = MTLPixelFormat(180); + constexpr MTLPixelFormat kMtlPixelFormatETC2_RGB8_sRGB = MTLPixelFormat(181); + constexpr MTLPixelFormat kMtlPixelFormatETC2_RGB8A1 = MTLPixelFormat(182); + constexpr MTLPixelFormat kMtlPixelFormatETC2_RGB8A1_sRGB = MTLPixelFormat(183); + constexpr MTLPixelFormat kMtlPixelFormatASTC_4x4_sRGB = MTLPixelFormat(186); + constexpr MTLPixelFormat kMtlPixelFormatASTC_5x4_sRGB = MTLPixelFormat(187); + constexpr MTLPixelFormat kMtlPixelFormatASTC_5x5_sRGB = MTLPixelFormat(188); + constexpr MTLPixelFormat kMtlPixelFormatASTC_6x5_sRGB = MTLPixelFormat(189); + constexpr MTLPixelFormat kMtlPixelFormatASTC_6x6_sRGB = MTLPixelFormat(190); + constexpr MTLPixelFormat kMtlPixelFormatASTC_8x5_sRGB = MTLPixelFormat(192); + constexpr MTLPixelFormat kMtlPixelFormatASTC_8x6_sRGB = MTLPixelFormat(193); + constexpr MTLPixelFormat kMtlPixelFormatASTC_8x8_sRGB = MTLPixelFormat(194); + constexpr MTLPixelFormat kMtlPixelFormatASTC_10x5_sRGB = MTLPixelFormat(195); + constexpr MTLPixelFormat kMtlPixelFormatASTC_10x6_sRGB = MTLPixelFormat(196); + constexpr MTLPixelFormat kMtlPixelFormatASTC_10x8_sRGB = MTLPixelFormat(197); + constexpr MTLPixelFormat kMtlPixelFormatASTC_10x10_sRGB = MTLPixelFormat(198); + constexpr MTLPixelFormat kMtlPixelFormatASTC_12x10_sRGB = MTLPixelFormat(199); + constexpr MTLPixelFormat kMtlPixelFormatASTC_12x12_sRGB = MTLPixelFormat(200); + constexpr MTLPixelFormat kMtlPixelFormatASTC_4x4_LDR = MTLPixelFormat(204); + constexpr MTLPixelFormat kMtlPixelFormatASTC_5x4_LDR = MTLPixelFormat(205); + constexpr MTLPixelFormat kMtlPixelFormatASTC_5x5_LDR = MTLPixelFormat(206); + constexpr MTLPixelFormat kMtlPixelFormatASTC_6x5_LDR = MTLPixelFormat(207); + constexpr MTLPixelFormat kMtlPixelFormatASTC_6x6_LDR = MTLPixelFormat(208); + constexpr MTLPixelFormat kMtlPixelFormatASTC_8x5_LDR = MTLPixelFormat(210); + constexpr MTLPixelFormat kMtlPixelFormatASTC_8x6_LDR = MTLPixelFormat(211); + constexpr MTLPixelFormat kMtlPixelFormatASTC_8x8_LDR = MTLPixelFormat(212); + constexpr MTLPixelFormat kMtlPixelFormatASTC_10x5_LDR = MTLPixelFormat(213); + constexpr MTLPixelFormat kMtlPixelFormatASTC_10x6_LDR = MTLPixelFormat(214); + constexpr MTLPixelFormat kMtlPixelFormatASTC_10x8_LDR = MTLPixelFormat(215); + constexpr MTLPixelFormat kMtlPixelFormatASTC_10x10_LDR = MTLPixelFormat(216); + constexpr MTLPixelFormat kMtlPixelFormatASTC_12x10_LDR = MTLPixelFormat(217); + constexpr MTLPixelFormat kMtlPixelFormatASTC_12x12_LDR = MTLPixelFormat(218); + constexpr MTLPixelFormat kMtlPixelFormatASTC_4x4_HDR = MTLPixelFormat(222); + constexpr MTLPixelFormat kMtlPixelFormatASTC_5x4_HDR = MTLPixelFormat(223); + constexpr MTLPixelFormat kMtlPixelFormatASTC_5x5_HDR = MTLPixelFormat(224); + constexpr MTLPixelFormat kMtlPixelFormatASTC_6x5_HDR = MTLPixelFormat(225); + constexpr MTLPixelFormat kMtlPixelFormatASTC_6x6_HDR = MTLPixelFormat(226); + constexpr MTLPixelFormat kMtlPixelFormatASTC_8x5_HDR = MTLPixelFormat(228); + constexpr MTLPixelFormat kMtlPixelFormatASTC_8x6_HDR = MTLPixelFormat(229); + constexpr MTLPixelFormat kMtlPixelFormatASTC_8x8_HDR = MTLPixelFormat(230); + constexpr MTLPixelFormat kMtlPixelFormatASTC_10x5_HDR = MTLPixelFormat(231); + constexpr MTLPixelFormat kMtlPixelFormatASTC_10x6_HDR = MTLPixelFormat(232); + constexpr MTLPixelFormat kMtlPixelFormatASTC_10x8_HDR = MTLPixelFormat(233); + constexpr MTLPixelFormat kMtlPixelFormatASTC_10x10_HDR = MTLPixelFormat(234); + constexpr MTLPixelFormat kMtlPixelFormatASTC_12x10_HDR = MTLPixelFormat(235); + constexpr MTLPixelFormat kMtlPixelFormatASTC_12x12_HDR = MTLPixelFormat(236); + constexpr MTLPixelFormat kMtlPixelFormatGBGR422 = MTLPixelFormat(240); + constexpr MTLPixelFormat kMtlPixelFormatBGRG422 = MTLPixelFormat(241); + constexpr MTLPixelFormat kMtlPixelFormatDepth16Unorm = MTLPixelFormat(250); + constexpr MTLPixelFormat kMtlPixelFormatDepth32Float = MTLPixelFormat(252); + constexpr MTLPixelFormat kMtlPixelFormatStencil8 = MTLPixelFormat(253); + constexpr MTLPixelFormat kMtlPixelFormatDepth24Unorm_Stencil8 = MTLPixelFormat(255); + constexpr MTLPixelFormat kMtlPixelFormatDepth32Float_Stencil8 = MTLPixelFormat(260); + constexpr MTLPixelFormat kMtlPixelFormatX32_Stencil8 = MTLPixelFormat(261); + constexpr MTLPixelFormat kMtlPixelFormatX24_Stencil8 = MTLPixelFormat(262); + + constexpr MTLGPUFamily kMtlGPUFamilyApple1 = MTLGPUFamily(1001); + constexpr MTLGPUFamily kMtlGPUFamilyApple2 = MTLGPUFamily(1002); + constexpr MTLGPUFamily kMtlGPUFamilyApple3 = MTLGPUFamily(1003); + constexpr MTLGPUFamily kMtlGPUFamilyApple4 = MTLGPUFamily(1004); + constexpr MTLGPUFamily kMtlGPUFamilyApple5 = MTLGPUFamily(1005); + constexpr MTLGPUFamily kMtlGPUFamilyApple6 = MTLGPUFamily(1006); + constexpr MTLGPUFamily kMtlGPUFamilyApple7 = MTLGPUFamily(1007); + constexpr MTLGPUFamily kMtlGPUFamilyApple8 = MTLGPUFamily(1008); + constexpr MTLGPUFamily kMtlGPUFamilyApple9 = MTLGPUFamily(1009); + constexpr MTLGPUFamily kMtlGPUFamilyApple10 = MTLGPUFamily(1010); + //runtime os check inline bool iOSVersionEqualOrGreater(const char* _version) { @@ -47,7 +266,7 @@ namespace bgfx { namespace mtl #else BX_UNUSED(_version); return false; -#endif +#endif // BX_PLATFORM_IOS || BX_PLATFORM_VISIONOS } inline bool macOSVersionEqualOrGreater( @@ -58,28 +277,15 @@ namespace bgfx { namespace mtl { #if BX_PLATFORM_OSX NSOperatingSystemVersion v = [[NSProcessInfo processInfo] operatingSystemVersion]; - return (v.majorVersion<<16) + (v.minorVersion<<8) + v.patchVersion >= - (_majorVersion<<16) + (_minorVersion<<8) + _patchVersion; + return (v.majorVersion<<16) + (v.minorVersion<<8) + v.patchVersion >= + ( _majorVersion<<16) + ( _minorVersion<<8) + _patchVersion + ; #else BX_UNUSED(_majorVersion, _minorVersion, _patchVersion); return false; -#endif +#endif // BX_PLATFORM_OSX } - // c++ wrapper - // objects with creation functions starting with 'new' has a refcount 1 after creation, object must be destroyed with release. - // commandBuffer, commandEncoders are autoreleased objects. Needs AutoreleasePool! - -#define MTL_CLASS(name) \ - class name \ - { \ - public: \ - name(id _obj = nil) : m_obj(_obj) {} \ - operator id () const { return m_obj; } \ - id m_obj; - -#define MTL_CLASS_END }; - typedef void (*mtlCallback)(void* userData); MTL_CLASS(BlitCommandEncoder) @@ -95,8 +301,17 @@ namespace bgfx { namespace mtl , MTLOrigin _destinationOrigin ) { - [m_obj copyFromTexture:_sourceTexture sourceSlice:_sourceSlice sourceLevel:_sourceLevel sourceOrigin:_sourceOrigin sourceSize:_sourceSize - toTexture:_destinationTexture destinationSlice:_destinationSlice destinationLevel:_destinationLevel destinationOrigin:_destinationOrigin]; + [m_obj + copyFromTexture: _sourceTexture + sourceSlice: _sourceSlice + sourceLevel: _sourceLevel + sourceOrigin: _sourceOrigin + sourceSize: _sourceSize + toTexture: _destinationTexture + destinationSlice: _destinationSlice + destinationLevel: _destinationLevel + destinationOrigin: _destinationOrigin + ]; } void copyFromBuffer( @@ -107,8 +322,13 @@ namespace bgfx { namespace mtl , NSUInteger _size ) { - [m_obj copyFromBuffer:_sourceBuffer sourceOffset:_sourceOffset toBuffer:_destinationBuffer - destinationOffset:_destinationOffset size:_size]; + [m_obj + copyFromBuffer: _sourceBuffer + sourceOffset: _sourceOffset + toBuffer: _destinationBuffer + destinationOffset: _destinationOffset + size: _size + ]; } void copyFromBuffer( @@ -123,25 +343,37 @@ namespace bgfx { namespace mtl , MTLOrigin _destinationOrigin ) { - [m_obj copyFromBuffer:_sourceBuffer sourceOffset:_sourceOffset sourceBytesPerRow:_sourceBytesPerRow - sourceBytesPerImage:_sourceBytesPerImage sourceSize:_sourceSize toTexture:_destinationTexture - destinationSlice:_destinationSlice destinationLevel:_destinationLevel destinationOrigin:_destinationOrigin]; + [m_obj + copyFromBuffer: _sourceBuffer + sourceOffset: _sourceOffset + sourceBytesPerRow: _sourceBytesPerRow + sourceBytesPerImage: _sourceBytesPerImage + sourceSize: _sourceSize + toTexture: _destinationTexture + destinationSlice: _destinationSlice + destinationLevel: _destinationLevel + destinationOrigin: _destinationOrigin + ]; } void generateMipmapsForTexture(id _texture) { - [m_obj generateMipmapsForTexture:_texture]; + [m_obj generateMipmapsForTexture: _texture]; } #if BX_PLATFORM_OSX void synchronizeTexture(id _texture, NSUInteger _slice, NSUInteger _level) { - [m_obj synchronizeTexture:_texture slice:_slice level:_level]; + [m_obj + synchronizeTexture: _texture + slice: _slice + level: _level + ]; } void synchronizeResource(id _resource) { - [m_obj synchronizeResource:_resource]; + [m_obj synchronizeResource: _resource]; } #endif // BX_PLATFORM_OSX @@ -164,14 +396,18 @@ namespace bgfx { namespace mtl void setLabel(const char* _label) { - [m_obj setLabel:@(_label)]; + if (BX_ENABLED(BGFX_CONFIG_DEBUG_ANNOTATION) ) + { + [m_obj setLabel:@(_label)]; + } } MTL_CLASS_END MTL_CLASS(CommandBuffer) // Creating Command Encoders - id renderCommandEncoderWithDescriptor(MTLRenderPassDescriptor* _renderPassDescriptor){ - return [m_obj renderCommandEncoderWithDescriptor:_renderPassDescriptor]; + id renderCommandEncoderWithDescriptor(MTLRenderPassDescriptor* _renderPassDescriptor) + { + return [m_obj renderCommandEncoderWithDescriptor: _renderPassDescriptor]; } id computeCommandEncoder() @@ -197,17 +433,27 @@ namespace bgfx { namespace mtl void addScheduledHandler(mtlCallback _cb, void* _data) { - [m_obj addScheduledHandler:^(id ){ _cb(_data); }]; + [m_obj + addScheduledHandler: ^(id) + { + _cb(_data); + } + ]; } void addCompletedHandler(mtlCallback _cb, void* _data) { - [m_obj addCompletedHandler:^(id ){ _cb(_data); }]; + [m_obj + addCompletedHandler: ^(id) + { + _cb(_data); + } + ]; } void presentDrawable(id _drawable) { - [m_obj presentDrawable:_drawable]; + [m_obj presentDrawable: _drawable]; } void waitUntilCompleted() @@ -231,36 +477,40 @@ namespace bgfx { namespace mtl MTL_CLASS(ComputeCommandEncoder) void setComputePipelineState(id _state) { - [m_obj setComputePipelineState:_state]; + [m_obj setComputePipelineState: _state]; } void setBuffer(id _buffer, NSUInteger _offset, NSUInteger _index) { - [m_obj setBuffer:_buffer offset:_offset atIndex:_index]; + [m_obj setBuffer: _buffer offset: _offset atIndex: _index]; } void setTexture(id _texture, NSUInteger _index) { - [m_obj setTexture:_texture atIndex:_index]; + [m_obj setTexture: _texture atIndex: _index]; } void setSamplerState(id _sampler, NSUInteger _index) { - [m_obj setSamplerState:_sampler atIndex:_index]; + [m_obj setSamplerState: _sampler atIndex: _index]; } void dispatchThreadgroups(MTLSize _threadgroupsPerGrid, MTLSize _threadsPerThreadgroup) { - [m_obj dispatchThreadgroups:_threadgroupsPerGrid threadsPerThreadgroup:_threadsPerThreadgroup]; + [m_obj dispatchThreadgroups: _threadgroupsPerGrid threadsPerThreadgroup: _threadsPerThreadgroup]; } void dispatchThreadgroupsWithIndirectBuffer( - id _indirectBuffer + id _indirectBuffer , NSUInteger _indirectBufferOffset , MTLSize _threadsPerThreadgroup ) { - [m_obj dispatchThreadgroupsWithIndirectBuffer:_indirectBuffer indirectBufferOffset:_indirectBufferOffset threadsPerThreadgroup:_threadsPerThreadgroup]; + [m_obj + dispatchThreadgroupsWithIndirectBuffer: _indirectBuffer + indirectBufferOffset: _indirectBufferOffset + threadsPerThreadgroup: _threadsPerThreadgroup + ]; } void endEncoding() @@ -282,7 +532,17 @@ namespace bgfx { namespace mtl MTL_CLASS(Device) bool supportsFamily(MTLGPUFamily _featureSet) { - return [m_obj supportsFamily:_featureSet]; + if ([m_obj respondsToSelector: @selector(supportsFamily:)]) + { + return [m_obj supportsFamily: _featureSet]; + } + + return false; + } + + bool supportsVariableRasterizationRate() + { + return [m_obj supportsRasterizationRateMapWithLayerCount:1]; } id newLibraryWithData(const void* _data) @@ -299,7 +559,7 @@ namespace bgfx { namespace mtl id newLibraryWithSource(const char* _source) { NSError* error; - id lib = [m_obj newLibraryWithSource:@(_source) options:nil error:&error]; + id lib = [m_obj newLibraryWithSource:@(_source) options:NULL error:&error]; BX_WARN(NULL == error , "Shader compilation failed: %s" , [error.localizedDescription cStringUsingEncoding:NSASCIIStringEncoding] @@ -314,40 +574,57 @@ namespace bgfx { namespace mtl id newCommandQueueWithMaxCommandBufferCount(NSUInteger _maxCommandBufferCount) { - return [m_obj newCommandQueueWithMaxCommandBufferCount:_maxCommandBufferCount]; + return [m_obj newCommandQueueWithMaxCommandBufferCount: _maxCommandBufferCount]; } // Creating Resources id newBufferWithLength(unsigned int _length, MTLResourceOptions _options) { - return [m_obj newBufferWithLength:_length options:_options ]; + return [m_obj + newBufferWithLength: _length + options: _options + ]; } id newBufferWithBytes(const void* _pointer, NSUInteger _length, MTLResourceOptions _options) { - return [m_obj newBufferWithBytes:_pointer length:_length options:_options]; + return [m_obj + newBufferWithBytes: _pointer + length: _length + options: _options + ]; } id newTextureWithDescriptor(MTLTextureDescriptor* _descriptor) { - return [m_obj newTextureWithDescriptor:_descriptor]; + return [m_obj + newTextureWithDescriptor: _descriptor + ]; } id newSamplerStateWithDescriptor(MTLSamplerDescriptor* _descriptor) { - return [m_obj newSamplerStateWithDescriptor:_descriptor]; + return [m_obj + newSamplerStateWithDescriptor: _descriptor + ]; } // Creating Command Objects Needed to Render Graphics id newDepthStencilStateWithDescriptor(MTLDepthStencilDescriptor* _descriptor) { - return [m_obj newDepthStencilStateWithDescriptor:_descriptor]; + return [m_obj + newDepthStencilStateWithDescriptor: _descriptor + ]; } - id newRenderPipelineStateWithDescriptor(MTLRenderPipelineDescriptor* _descriptor) + id newRenderPipelineStateWithDescriptor(MTLRenderPipelineDescriptor* _descriptor) { NSError* error; - id state = [m_obj newRenderPipelineStateWithDescriptor:_descriptor error:&error]; + id state = [m_obj + newRenderPipelineStateWithDescriptor: _descriptor + error: &error + ]; + BX_WARN(NULL == error , "newRenderPipelineStateWithDescriptor failed: %s" , [error.localizedDescription cStringUsingEncoding:NSASCIIStringEncoding] @@ -355,14 +632,19 @@ namespace bgfx { namespace mtl return state; } - id newRenderPipelineStateWithDescriptor( + id newRenderPipelineStateWithDescriptor( MTLRenderPipelineDescriptor* _descriptor , MTLPipelineOption _options , MTLRenderPipelineReflection** _reflection ) { NSError* error; - id state = [m_obj newRenderPipelineStateWithDescriptor:_descriptor options:_options reflection:_reflection error:&error]; + id state = [m_obj + newRenderPipelineStateWithDescriptor: _descriptor + options: _options + reflection: _reflection + error: &error + ]; BX_WARN(NULL == error , "newRenderPipelineStateWithDescriptor failed: %s" @@ -372,14 +654,19 @@ namespace bgfx { namespace mtl } // Creating Command Objects Needed to Perform Computational Tasks - id newComputePipelineStateWithFunction( - id _computeFunction + id newComputePipelineStateWithFunction( + id _computeFunction , MTLPipelineOption _options , MTLComputePipelineReflection** _reflection ) { NSError* error; - id state = [m_obj newComputePipelineStateWithFunction:_computeFunction options:_options reflection:_reflection error:&error]; + id state = [m_obj + newComputePipelineStateWithFunction: _computeFunction + options: _options + reflection: _reflection + error: &error + ]; BX_WARN(NULL == error , "newComputePipelineStateWithFunction failed: %s" @@ -388,16 +675,24 @@ namespace bgfx { namespace mtl return state; } - bool supportsTextureSampleCount(int sampleCount) + id newRasterizationRateMapWithDescriptor(MTLRasterizationRateMapDescriptor* _descriptor) { - if (BX_ENABLED(BX_PLATFORM_IOS) && !iOSVersionEqualOrGreater("9.0.0")) - { - return sampleCount == 1 || sampleCount == 2 || sampleCount == 4; - } - else + return [m_obj + newRasterizationRateMapWithDescriptor: _descriptor + ]; + } + + bool supportsTextureSampleCount(int32_t sampleCount) + { + if (BX_ENABLED(BX_PLATFORM_IOS) && !iOSVersionEqualOrGreater("9.0.0") ) { - return [m_obj supportsTextureSampleCount:sampleCount]; + return sampleCount == 1 + || sampleCount == 2 + || sampleCount == 4 + ; } + + return [m_obj supportsTextureSampleCount:sampleCount]; } bool depth24Stencil8PixelFormatSupported() @@ -411,6 +706,7 @@ namespace bgfx { namespace mtl MTL_CLASS_END MTL_CLASS(Function) + NSArray* vertexAttributes() { return m_obj.vertexAttributes; @@ -418,7 +714,8 @@ namespace bgfx { namespace mtl void setLabel(const char* _label) { - if ([m_obj respondsToSelector:@selector(setLabel:)]) + if (BX_ENABLED(BGFX_CONFIG_DEBUG_ANNOTATION) + && [m_obj respondsToSelector:@selector(setLabel:)]) { [m_obj setLabel:@(_label)]; } @@ -426,7 +723,7 @@ namespace bgfx { namespace mtl MTL_CLASS_END MTL_CLASS(Library) - id newFunctionWithName(const char* _functionName) + id newFunctionWithName(const char* _functionName) { return [m_obj newFunctionWithName:@(_functionName)]; } @@ -436,99 +733,113 @@ namespace bgfx { namespace mtl // Setting Graphics Rendering State void setBlendColor(float _red, float _green, float _blue, float _alpha) { - [m_obj setBlendColorRed:_red green:_green blue:_blue alpha:_alpha]; + [m_obj + setBlendColorRed: _red + green: _green + blue: _blue + alpha: _alpha + ]; } - void setVertexAmplificationCount(NSUInteger count, MTLVertexAmplificationViewMapping* viewMappings) + void setVertexAmplificationCount(NSUInteger _count, MTLVertexAmplificationViewMapping* _viewMappings) { - [m_obj setVertexAmplificationCount:count viewMappings:viewMappings]; + [m_obj + setVertexAmplificationCount: _count + viewMappings: _viewMappings + ]; } void setCullMode(MTLCullMode _cullMode) { - [m_obj setCullMode:_cullMode]; + [m_obj setCullMode: _cullMode]; } void setDepthBias(float _depthBias, float _slopeScale, float _clamp) { - [m_obj setDepthBias:_depthBias slopeScale:_slopeScale clamp:_clamp]; + [m_obj setDepthBias: _depthBias slopeScale: _slopeScale clamp: _clamp]; } void setDepthStencilState(id _depthStencilState) { - [m_obj setDepthStencilState:_depthStencilState]; + [m_obj setDepthStencilState: _depthStencilState]; } void setFrontFacingWinding(MTLWinding _frontFacingWinding) { - [m_obj setFrontFacingWinding:_frontFacingWinding]; + [m_obj setFrontFacingWinding: _frontFacingWinding]; } void setRenderPipelineState(id _pipelineState) { - [m_obj setRenderPipelineState:_pipelineState]; + [m_obj setRenderPipelineState: _pipelineState]; } void setScissorRect(MTLScissorRect _rect) { - [m_obj setScissorRect:_rect]; + [m_obj setScissorRect: _rect]; } void setStencilReferenceValue(uint32_t _ref) { - [m_obj setStencilReferenceValue:_ref]; + [m_obj setStencilReferenceValue: _ref]; } void setTriangleFillMode(MTLTriangleFillMode _fillMode) { - [m_obj setTriangleFillMode:_fillMode]; + [m_obj setTriangleFillMode: _fillMode]; } void setViewport(MTLViewport _viewport) { - [m_obj setViewport:_viewport]; + [m_obj setViewport: _viewport]; } - void setViewports(MTLViewport _viewport[], NSInteger count) + void setViewports(MTLViewport _viewport[], NSInteger _count) { - [m_obj setViewports:_viewport count:count]; + [m_obj + setViewports: _viewport + count: _count + ]; } void setVisibilityResultMode(MTLVisibilityResultMode _mode, NSUInteger _offset) { - [m_obj setVisibilityResultMode:_mode offset:_offset]; + [m_obj + setVisibilityResultMode: _mode + offset: _offset + ]; } // Specifying Resources for a Vertex Function void setVertexBuffer(id _buffer, NSUInteger _offset, NSUInteger _index) { - [m_obj setVertexBuffer:_buffer offset:_offset atIndex:_index]; + [m_obj setVertexBuffer: _buffer offset: _offset atIndex: _index]; } void setVertexSamplerState(id _sampler, NSUInteger _index) { - [m_obj setVertexSamplerState:_sampler atIndex:_index]; + [m_obj setVertexSamplerState: _sampler atIndex: _index]; } void setVertexTexture(id _texture, NSUInteger _index) { - [m_obj setVertexTexture:_texture atIndex:_index]; + [m_obj setVertexTexture: _texture atIndex: _index]; } // Specifying Resources for a Fragment Function void setFragmentBuffer(id _buffer, NSUInteger _offset, NSUInteger _index) { - [m_obj setFragmentBuffer:_buffer offset:_offset atIndex:_index]; + [m_obj setFragmentBuffer: _buffer offset: _offset atIndex: _index]; } void setFragmentSamplerState(id _sampler, NSUInteger _index) { - [m_obj setFragmentSamplerState:_sampler atIndex:_index]; + [m_obj setFragmentSamplerState: _sampler atIndex: _index]; } void setFragmentTexture(id _texture, NSUInteger _index) { - [m_obj setFragmentTexture:_texture atIndex:_index]; + [m_obj setFragmentTexture: _texture atIndex: _index]; } //Drawing Geometric Primitives @@ -542,7 +853,14 @@ namespace bgfx { namespace mtl , NSUInteger _instanceCount ) { - [m_obj drawIndexedPrimitives:_primitiveType indexCount:_indexCount indexType:_indexType indexBuffer:_indexBuffer indexBufferOffset:_indexBufferOffset instanceCount:_instanceCount]; + [m_obj + drawIndexedPrimitives: _primitiveType + indexCount: _indexCount + indexType: _indexType + indexBuffer: _indexBuffer + indexBufferOffset: _indexBufferOffset + instanceCount: _instanceCount + ]; } void drawPrimitives( @@ -552,26 +870,42 @@ namespace bgfx { namespace mtl , NSUInteger _instanceCount ) { - [m_obj drawPrimitives:_primitiveType vertexStart:_vertexStart vertexCount:_vertexCount instanceCount:_instanceCount]; + [m_obj + drawPrimitives: _primitiveType + vertexStart: _vertexStart + vertexCount: _vertexCount + instanceCount: _instanceCount + ]; } void drawPrimitives( MTLPrimitiveType _primitiveType - , id _indirectBuffer + , id _indirectBuffer , NSUInteger _indirectBufferOffset) { - [m_obj drawPrimitives:_primitiveType indirectBuffer:_indirectBuffer indirectBufferOffset:_indirectBufferOffset]; + [m_obj + drawPrimitives: _primitiveType + indirectBuffer: _indirectBuffer + indirectBufferOffset: _indirectBufferOffset + ]; } void drawIndexedPrimitives( MTLPrimitiveType _primitiveType , MTLIndexType _indexType - , id _indexBuffer + , id _indexBuffer , NSUInteger _indexBufferOffset - , id _indirectBuffer + , id _indirectBuffer , NSUInteger _indirectBufferOffset) { - [m_obj drawIndexedPrimitives:_primitiveType indexType:_indexType indexBuffer:_indexBuffer indexBufferOffset:_indexBufferOffset indirectBuffer:_indirectBuffer indirectBufferOffset:_indirectBufferOffset]; + [m_obj + drawIndexedPrimitives: _primitiveType + indexType: _indexType + indexBuffer: _indexBuffer + indexBufferOffset: _indexBufferOffset + indirectBuffer: _indirectBuffer + indirectBufferOffset: _indirectBufferOffset + ]; } void insertDebugSignpost(const char* _string) @@ -597,29 +931,66 @@ namespace bgfx { namespace mtl MTL_CLASS(Texture) // Copying Data into a Texture Image - void replaceRegion(MTLRegion _region, NSUInteger _level, NSUInteger _slice, const void* _pixelBytes, NSUInteger _bytesPerRow, NSUInteger _bytesPerImage) + void replaceRegion( + MTLRegion _region + , NSUInteger _level + , NSUInteger _slice + , const void* _pixelBytes + , NSUInteger _bytesPerRow + , NSUInteger _bytesPerImage + ) { - [m_obj replaceRegion:_region mipmapLevel:_level slice:_slice withBytes:_pixelBytes bytesPerRow:_bytesPerRow bytesPerImage:_bytesPerImage]; + [m_obj + replaceRegion: _region + mipmapLevel: _level + slice: _slice + withBytes: _pixelBytes + bytesPerRow: _bytesPerRow + bytesPerImage: _bytesPerImage + ]; } // Copying Data from a Texture Image - void getBytes(void* _pixelBytes, NSUInteger _bytesPerRow, NSUInteger _bytesPerImage, MTLRegion _region, NSUInteger _mipmapLevel, NSUInteger _slice) const - { - [m_obj getBytes:_pixelBytes bytesPerRow:_bytesPerRow bytesPerImage:_bytesPerImage fromRegion:_region mipmapLevel:_mipmapLevel slice:_slice]; + void getBytes( + void* _pixelBytes + , NSUInteger _bytesPerRow + , NSUInteger _bytesPerImage + , MTLRegion _region + , NSUInteger _mipmapLevel + , NSUInteger _slice + ) const + { + [m_obj + getBytes: _pixelBytes + bytesPerRow: _bytesPerRow + bytesPerImage: _bytesPerImage + fromRegion: _region + mipmapLevel: _mipmapLevel + slice: _slice + ]; } // Creating Textures by Reusing Image Data id newTextureViewWithPixelFormat(MTLPixelFormat _pixelFormat) { - return [m_obj newTextureViewWithPixelFormat:_pixelFormat]; + return [m_obj newTextureViewWithPixelFormat: _pixelFormat]; } - id newTextureViewWithPixelFormat(MTLPixelFormat _pixelFormat, MTLTextureType _textureType, NSRange _levelRange, NSRange _sliceRange) + id newTextureViewWithPixelFormat( + MTLPixelFormat _pixelFormat + , MTLTextureType _textureType + , NSRange _levelRange + , NSRange _sliceRange + ) { - return [m_obj newTextureViewWithPixelFormat:_pixelFormat textureType:_textureType levels:_levelRange slices:_sliceRange]; + return [m_obj + newTextureViewWithPixelFormat: _pixelFormat + textureType: _textureType + levels: _levelRange + slices: _sliceRange + ]; } - //properties uint32_t width() const { return (uint32_t)m_obj.width; @@ -652,18 +1023,21 @@ namespace bgfx { namespace mtl void setLabel(const char* _label) { - [m_obj setLabel:@(_label)]; + if (BX_ENABLED(BGFX_CONFIG_DEBUG_ANNOTATION) ) + { + [m_obj setLabel:@(_label)]; + } } MTL_CLASS_END typedef id ComputePipelineState; - typedef id DepthStencilState; - typedef id RenderPipelineState; - typedef id SamplerState; + typedef id DepthStencilState; + typedef id RenderPipelineState; + typedef id SamplerState; //descriptors //NOTE: [class new] is same as [[class alloc] init] - typedef MTLRenderPipelineDescriptor* RenderPipelineDescriptor; + typedef MTLRenderPipelineDescriptor* RenderPipelineDescriptor; typedef MTLComputePipelineReflection* ComputePipelineReflection; inline RenderPipelineDescriptor newRenderPipelineDescriptor() @@ -692,8 +1066,8 @@ namespace bgfx { namespace mtl return [MTLStencilDescriptor new]; } - typedef MTLRenderPassColorAttachmentDescriptor* RenderPassColorAttachmentDescriptor; - typedef MTLRenderPassDepthAttachmentDescriptor* RenderPassDepthAttachmentDescriptor; + typedef MTLRenderPassColorAttachmentDescriptor* RenderPassColorAttachmentDescriptor; + typedef MTLRenderPassDepthAttachmentDescriptor* RenderPassDepthAttachmentDescriptor; typedef MTLRenderPassStencilAttachmentDescriptor* RenderPassStencilAttachmentDescriptor; typedef MTLRenderPassDescriptor* RenderPassDescriptor; @@ -731,6 +1105,41 @@ namespace bgfx { namespace mtl typedef MTLRenderPipelineReflection* RenderPipelineReflection; + typedef MTLCaptureManager* CaptureManager; + + MTLCaptureManager* getSharedCaptureManager() + { + return [MTLCaptureManager sharedCaptureManager]; + } + + typedef MTLCaptureDescriptor* CaptureDescriptor; + + inline MTLCaptureDescriptor* newCaptureDescriptor() + { + return [MTLCaptureDescriptor new]; + } + + typedef MTLRasterizationRateMapDescriptor* RasterizationRateMapDescriptor; + + typedef MTLRasterizationRateLayerDescriptor* RasterizationRateLayerDescriptor; + + inline MTLRasterizationRateLayerDescriptor* newRasterizationRateLayerDescriptor(float _rate) + { + const float rate[1] = { _rate }; + return [[MTLRasterizationRateLayerDescriptor alloc] + initWithSampleCount: MTLSizeMake(1, 1, 0) + horizontal: rate + vertical: rate + ]; + } + + typedef MTLRasterizationRateMapDescriptor* RasterizationRateMapDescriptor; + + inline MTLRasterizationRateMapDescriptor* newRasterizationRateMapDescriptor() + { + return [MTLRasterizationRateMapDescriptor new]; + } + //helper functions inline void release(NSObject* _obj) { @@ -747,12 +1156,6 @@ namespace bgfx { namespace mtl return [_str UTF8String]; } -#define MTL_RELEASE(_obj) \ - BX_MACRO_BLOCK_BEGIN \ - [_obj release]; \ - _obj = NULL; \ - BX_MACRO_BLOCK_END - // end of c++ wrapper template @@ -819,7 +1222,7 @@ namespace bgfx { namespace mtl void destroy() { - MTL_RELEASE(m_ptr); + MTL_RELEASE_W(m_ptr, 0); if (NULL != m_dynamic) { @@ -850,7 +1253,6 @@ namespace bgfx { namespace mtl VertexLayoutHandle m_layoutHandle; }; - struct ShaderMtl { ShaderMtl() @@ -859,10 +1261,10 @@ namespace bgfx { namespace mtl } void create(const Memory* _mem); + void destroy() { - MTL_RELEASE(m_function); - + MTL_RELEASE_W(m_function, 0); } Function m_function; @@ -906,13 +1308,16 @@ namespace bgfx { namespace mtl , m_numPredefined(0) , m_rps(NULL) , m_cps(NULL) + { + m_numThreads[0] = 1; + m_numThreads[1] = 1; + m_numThreads[2] = 1; + + for (uint32_t ii = 0; ii < BGFX_CONFIG_MAX_TEXTURE_SAMPLERS; ++ii) { - m_numThreads[0] = 1; - m_numThreads[1] = 1; - m_numThreads[2] = 1; - for(uint32_t i=0; i currentDrawableTexture(); + void releaseBackBuffer(); + + uint32_t resize(uint32_t _width, uint32_t _height, TextureFormat::Enum _format, TextureFormat::Enum _depthFormat); + + id currentDrawableTexture(); CAMetalLayer* m_metalLayer; -#if BX_PLATFORM_VISIONOS - cp_layer_renderer_t m_layerRenderer; - cp_drawable_t m_layerRendererDrawable; - cp_layer_renderer_configuration_t m_layerRendererConfiguration; - cp_frame_t m_frame; - bool m_useLayerRenderer; -#endif - id m_drawable; - - id m_drawableTexture; + id m_drawable; + + id m_drawableTexture; + Texture m_backBufferColorMsaa; Texture m_backBufferDepth; Texture m_backBufferStencil; + uint32_t m_maxAnisotropy; void* m_nwh; }; @@ -1096,11 +1495,11 @@ namespace bgfx { namespace mtl FrameBufferMtl() : m_swapChain(NULL) , m_nwh(NULL) - , m_denseIdx(UINT16_MAX) , m_pixelFormatHash(0) + , m_denseIdx(UINT16_MAX) , m_num(0) { - m_depthHandle.idx = kInvalidHandle; + m_depthHandle = BGFX_INVALID_HANDLE; } void create(uint8_t _num, const Attachment* _attachment); @@ -1116,15 +1515,20 @@ namespace bgfx { namespace mtl uint16_t destroy(); void resolve(); + void resizeSwapChain( + uint32_t _width + , uint32_t _height + , TextureFormat::Enum _format = TextureFormat::Count + , TextureFormat::Enum _depthFormat = TextureFormat::Count + ); SwapChainMtl* m_swapChain; void* m_nwh; + uint32_t m_pixelFormatHash; uint32_t m_width; uint32_t m_height; uint16_t m_denseIdx; - uint32_t m_pixelFormatHash; - TextureHandle m_colorHandle[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS-1]; TextureHandle m_depthHandle; Attachment m_colorAttachment[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS-1]; @@ -1143,8 +1547,8 @@ namespace bgfx { namespace mtl void init(Device _device); void shutdown(); CommandBuffer alloc(); - void kick(bool _endFrame, bool _waitForFinish = false); - void finish(bool _finishAll = false); + void kick(bool _endFrame, bool _waitForFinish); + void finish(bool _finishAll); void release(NSObject* _ptr); void consume(); diff --git a/libs/bgfx/src/renderer_mtl.mm b/libs/bgfx/src/renderer_mtl.mm index fc98573..4f9c442 100644 --- a/libs/bgfx/src/renderer_mtl.mm +++ b/libs/bgfx/src/renderer_mtl.mm @@ -1,5 +1,5 @@ /* - * Copyright 2011-2016 Attila Kocsis. All rights reserved. + * Copyright 2011-2025 Attila Kocsis. All rights reserved. * License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE */ @@ -13,7 +13,7 @@ #if BX_PLATFORM_OSX # include -#endif +#endif // BX_PLATFORM_OSX #import @@ -217,8 +217,9 @@ inline void setViewType(ViewId _view, const bx::StringView _str) bool m_autoGetMipmap; }; - BX_PRAGMA_DIAGNOSTIC_PUSH(); - BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wunguarded-availability-new"); +BX_PRAGMA_DIAGNOSTIC_PUSH(); +BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wunguarded-availability-new"); + static TextureFormatInfo s_textureFormat[] = { #define $0 MTLTextureSwizzleZero @@ -227,119 +228,106 @@ inline void setViewType(ViewId _view, const bx::StringView _str) #define $G MTLTextureSwizzleGreen #define $B MTLTextureSwizzleBlue #define $A MTLTextureSwizzleAlpha - { MTLPixelFormat(130/*BC1_RGBA*/), MTLPixelFormat(131/*BC1_RGBA_sRGB*/), MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC1 - { MTLPixelFormat(132/*BC2_RGBA*/), MTLPixelFormat(133/*BC2_RGBA_sRGB*/), MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC2 - { MTLPixelFormat(134/*BC3_RGBA*/), MTLPixelFormat(135/*BC3_RGBA_sRGB*/), MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC3 - { MTLPixelFormat(140/*BC4_RUnorm*/), MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC4 - { MTLPixelFormat(142/*BC5_RGUnorm*/), MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC5 - { MTLPixelFormat(150/*BC6H_RGBFloat*/), MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC6H - { MTLPixelFormat(152/*BC7_RGBAUnorm*/), MTLPixelFormat(153/*BC7_RGBAUnorm_sRGB*/), MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC7 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ETC1 - { MTLPixelFormat(180/*ETC2_RGB8*/), MTLPixelFormat(181/*ETC2_RGB8_sRGB*/), MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ETC2 - { MTLPixelFormat(178/*EAC_RGBA8*/), MTLPixelFormat(179/*EAC_RGBA8_sRGB*/), MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ETC2A - { MTLPixelFormat(182/*ETC2_RGB8A1*/), MTLPixelFormat(183/*ETC2_RGB8A1_sRGB*/), MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ETC2A1 - { MTLPixelFormat(160/*PVRTC_RGB_2BPP*/), MTLPixelFormat(161/*PVRTC_RGB_2BPP_sRGB*/), MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // PTC12 - { MTLPixelFormat(162/*PVRTC_RGB_4BPP*/), MTLPixelFormat(163/*PVRTC_RGB_4BPP_sRGB*/), MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // PTC14 - { MTLPixelFormat(164/*PVRTC_RGBA_2BPP*/), MTLPixelFormat(165/*PVRTC_RGBA_2BPP_sRGB*/), MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // PTC12A - { MTLPixelFormat(166/*PVRTC_RGBA_4BPP*/), MTLPixelFormat(167/*PVRTC_RGBA_4BPP_sRGB*/), MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // PTC14A - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // PTC22 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // PTC24 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ATC - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ATCE - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ATCI -#if (BX_PLATFORM_IOS || BX_PLATFORM_VISIONOS) && !TARGET_OS_MACCATALYST - { MTLPixelFormatASTC_4x4_LDR, MTLPixelFormatASTC_4x4_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC4x4 - { MTLPixelFormatASTC_5x4_LDR, MTLPixelFormatASTC_5x4_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC5x4 - { MTLPixelFormatASTC_5x5_LDR, MTLPixelFormatASTC_5x5_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC5x5 - { MTLPixelFormatASTC_6x5_LDR, MTLPixelFormatASTC_6x5_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC6x5 - { MTLPixelFormatASTC_6x6_LDR, MTLPixelFormatASTC_6x6_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC6x6 - { MTLPixelFormatASTC_8x5_LDR, MTLPixelFormatASTC_8x5_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC8x5 - { MTLPixelFormatASTC_8x6_LDR, MTLPixelFormatASTC_8x6_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC8x6 - { MTLPixelFormatASTC_8x8_LDR, MTLPixelFormatASTC_8x8_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC8x8 - { MTLPixelFormatASTC_10x5_LDR, MTLPixelFormatASTC_10x5_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC10x5 - { MTLPixelFormatASTC_10x6_LDR, MTLPixelFormatASTC_10x6_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC10x6 - { MTLPixelFormatASTC_10x8_LDR, MTLPixelFormatASTC_10x8_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC10x8 - { MTLPixelFormatASTC_10x10_LDR, MTLPixelFormatASTC_10x10_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC10x10 - { MTLPixelFormatASTC_12x10_LDR, MTLPixelFormatASTC_12x10_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC12x10 - { MTLPixelFormatASTC_12x12_LDR, MTLPixelFormatASTC_12x12_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC12x12 -#else - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC4x4 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC5x4 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC5x5 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC6x5 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC6x6 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC8x5 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC8x6 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC8x8 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC10x5 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC10x6 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC10x8 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC10x10 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC12x10 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC12x12 -#endif // (BX_PLATFORM_IOS || BX_PLATFORM_VISIONOS) && !TARGET_OS_MACCATALYST - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // Unknown - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // R1 - { MTLPixelFormatA8Unorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // A8 - { MTLPixelFormatR8Unorm, MTLPixelFormat(11/*R8Unorm_sRGB*/), MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // R8 - { MTLPixelFormatR8Sint, MTLPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // R8I - { MTLPixelFormatR8Uint, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // R8U - { MTLPixelFormatR8Snorm, MTLPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // R8S - { MTLPixelFormatR16Unorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // R16 - { MTLPixelFormatR16Sint, MTLPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // R16I - { MTLPixelFormatR16Uint, MTLPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // R16U - { MTLPixelFormatR16Float, MTLPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // R16F - { MTLPixelFormatR16Snorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // R16S - { MTLPixelFormatR32Sint, MTLPixelFormatInvalid, MTLReadWriteTextureTier1, { $R, $G, $B, $A }, false }, // R32I - { MTLPixelFormatR32Uint, MTLPixelFormatInvalid, MTLReadWriteTextureTier1, { $R, $G, $B, $A }, false }, // R32U - { MTLPixelFormatR32Float, MTLPixelFormatInvalid, MTLReadWriteTextureTier1, { $R, $G, $B, $A }, false }, // R32F - { MTLPixelFormatRG8Unorm, MTLPixelFormat(31/*RG8Unorm_sRGB*/), MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RG8 - { MTLPixelFormatRG8Sint, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG8I - { MTLPixelFormatRG8Uint, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG8U - { MTLPixelFormatRG8Snorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RG8S - { MTLPixelFormatRG16Unorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RG16 - { MTLPixelFormatRG16Sint, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG16I - { MTLPixelFormatRG16Uint, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG16U - { MTLPixelFormatRG16Float, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RG16F - { MTLPixelFormatRG16Snorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RG16S - { MTLPixelFormatRG32Sint, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG32I - { MTLPixelFormatRG32Uint, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG32U - { MTLPixelFormatRG32Float, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG32F - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RGB8 - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RGB8I - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RGB8U - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RGB8S - { MTLPixelFormatRGB9E5Float, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RGB9E5F - { MTLPixelFormatBGRA8Unorm, MTLPixelFormatBGRA8Unorm_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BGRA8 - { MTLPixelFormatRGBA8Unorm, MTLPixelFormatRGBA8Unorm_sRGB, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // RGBA8 - { MTLPixelFormatRGBA8Sint, MTLPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // RGBA8I - { MTLPixelFormatRGBA8Uint, MTLPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // RGBA8U - { MTLPixelFormatRGBA8Snorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RGBA8S - { MTLPixelFormatRGBA16Unorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RGBA16 - { MTLPixelFormatRGBA16Sint, MTLPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // RGBA16I - { MTLPixelFormatRGBA16Uint, MTLPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // RGBA16U - { MTLPixelFormatRGBA16Float, MTLPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // RGBA16F - { MTLPixelFormatRGBA16Snorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RGBA16S - { MTLPixelFormatRGBA32Sint, MTLPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // RGBA32I - { MTLPixelFormatRGBA32Uint, MTLPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // RGBA32U - { MTLPixelFormatRGBA32Float, MTLPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // RGBA32F - { MTLPixelFormatB5G6R5Unorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // B5G6R5 - { MTLPixelFormatB5G6R5Unorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $B, $G, $R, $A }, true }, // R5G6B5 - { MTLPixelFormatABGR4Unorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $G, $B, $A, $R }, true }, // BGRA4 - { MTLPixelFormatABGR4Unorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $A, $B, $G, $R }, true }, // RGBA4 - { MTLPixelFormatBGR5A1Unorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // BGR5A1 - { MTLPixelFormatBGR5A1Unorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $B, $G, $R, $A }, true }, // RGB5A1 - { MTLPixelFormatRGB10A2Unorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RGB10A2 - { MTLPixelFormatRG11B10Float, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RG11B10F - { MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // UnknownDepth - { MTLPixelFormatDepth16Unorm, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D16 - { MTLPixelFormatDepth32Float, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D24 - { MTLPixelFormat(255/*Depth24Unorm_Stencil8*/), MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D24S8 - { MTLPixelFormatDepth32Float, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D32 - { MTLPixelFormatDepth32Float, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D16F - { MTLPixelFormatDepth32Float, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D24F - { MTLPixelFormatDepth32Float, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D32F - { MTLPixelFormatStencil8, MTLPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D0S8 + { kMtlPixelFormatBC1_RGBA, kMtlPixelFormatBC1_RGBA_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC1 + { kMtlPixelFormatBC2_RGBA, kMtlPixelFormatBC2_RGBA_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC2 + { kMtlPixelFormatBC3_RGBA, kMtlPixelFormatBC3_RGBA_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC3 + { kMtlPixelFormatBC4_RUnorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC4 + { kMtlPixelFormatBC5_RGUnorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC5 + { kMtlPixelFormatBC6H_RGBFloat, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC6H + { kMtlPixelFormatBC7_RGBAUnorm, kMtlPixelFormatBC7_RGBAUnorm_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BC7 + { kMtlPixelFormatInvalid, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ETC1 + { kMtlPixelFormatETC2_RGB8, kMtlPixelFormatETC2_RGB8_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ETC2 + { kMtlPixelFormatEAC_RGBA8, kMtlPixelFormatEAC_RGBA8_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ETC2A + { kMtlPixelFormatETC2_RGB8A1, kMtlPixelFormatETC2_RGB8A1_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ETC2A1 + { kMtlPixelFormatEAC_R11Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // EACR11 UNORM + { kMtlPixelFormatEAC_R11Snorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // EACR11 SNORM + { kMtlPixelFormatEAC_RG11Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // EACRG11 UNORM + { kMtlPixelFormatEAC_RG11Snorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // EACRG11 SNORM + { kMtlPixelFormatPVRTC_RGB_2BPP, kMtlPixelFormatPVRTC_RGB_2BPP_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // PTC12 + { kMtlPixelFormatPVRTC_RGB_4BPP, kMtlPixelFormatPVRTC_RGB_4BPP_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // PTC14 + { kMtlPixelFormatPVRTC_RGBA_2BPP, kMtlPixelFormatPVRTC_RGBA_2BPP_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // PTC12A + { kMtlPixelFormatPVRTC_RGBA_4BPP, kMtlPixelFormatPVRTC_RGBA_4BPP_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // PTC14A + { kMtlPixelFormatInvalid, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // PTC22 + { kMtlPixelFormatInvalid, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // PTC24 + { kMtlPixelFormatInvalid, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ATC + { kMtlPixelFormatInvalid, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ATCE + { kMtlPixelFormatInvalid, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ATCI + { kMtlPixelFormatASTC_4x4_LDR, kMtlPixelFormatASTC_4x4_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC4x4 + { kMtlPixelFormatASTC_5x4_LDR, kMtlPixelFormatASTC_5x4_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC5x4 + { kMtlPixelFormatASTC_5x5_LDR, kMtlPixelFormatASTC_5x5_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC5x5 + { kMtlPixelFormatASTC_6x5_LDR, kMtlPixelFormatASTC_6x5_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC6x5 + { kMtlPixelFormatASTC_6x6_LDR, kMtlPixelFormatASTC_6x6_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC6x6 + { kMtlPixelFormatASTC_8x5_LDR, kMtlPixelFormatASTC_8x5_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC8x5 + { kMtlPixelFormatASTC_8x6_LDR, kMtlPixelFormatASTC_8x6_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC8x6 + { kMtlPixelFormatASTC_8x8_LDR, kMtlPixelFormatASTC_8x8_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC8x8 + { kMtlPixelFormatASTC_10x5_LDR, kMtlPixelFormatASTC_10x5_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC10x5 + { kMtlPixelFormatASTC_10x6_LDR, kMtlPixelFormatASTC_10x6_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC10x6 + { kMtlPixelFormatASTC_10x8_LDR, kMtlPixelFormatASTC_10x8_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC10x8 + { kMtlPixelFormatASTC_10x10_LDR, kMtlPixelFormatASTC_10x10_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC10x10 + { kMtlPixelFormatASTC_12x10_LDR, kMtlPixelFormatASTC_12x10_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC12x10 + { kMtlPixelFormatASTC_12x12_LDR, kMtlPixelFormatASTC_12x12_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // ASTC12x12 + { kMtlPixelFormatInvalid, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // Unknown + { kMtlPixelFormatInvalid, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // R1 + { kMtlPixelFormatA8Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // A8 + { kMtlPixelFormatR8Unorm, kMtlPixelFormatR8Unorm_sRGB, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // R8 + { kMtlPixelFormatR8Sint, kMtlPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // R8I + { kMtlPixelFormatR8Uint, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // R8U + { kMtlPixelFormatR8Snorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // R8S + { kMtlPixelFormatR16Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // R16 + { kMtlPixelFormatR16Sint, kMtlPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // R16I + { kMtlPixelFormatR16Uint, kMtlPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // R16U + { kMtlPixelFormatR16Float, kMtlPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // R16F + { kMtlPixelFormatR16Snorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // R16S + { kMtlPixelFormatR32Sint, kMtlPixelFormatInvalid, MTLReadWriteTextureTier1, { $R, $G, $B, $A }, false }, // R32I + { kMtlPixelFormatR32Uint, kMtlPixelFormatInvalid, MTLReadWriteTextureTier1, { $R, $G, $B, $A }, false }, // R32U + { kMtlPixelFormatR32Float, kMtlPixelFormatInvalid, MTLReadWriteTextureTier1, { $R, $G, $B, $A }, false }, // R32F + { kMtlPixelFormatRG8Unorm, kMtlPixelFormatRG8Unorm_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RG8 + { kMtlPixelFormatRG8Sint, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG8I + { kMtlPixelFormatRG8Uint, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG8U + { kMtlPixelFormatRG8Snorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RG8S + { kMtlPixelFormatRG16Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RG16 + { kMtlPixelFormatRG16Sint, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG16I + { kMtlPixelFormatRG16Uint, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG16U + { kMtlPixelFormatRG16Float, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RG16F + { kMtlPixelFormatRG16Snorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RG16S + { kMtlPixelFormatRG32Sint, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG32I + { kMtlPixelFormatRG32Uint, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG32U + { kMtlPixelFormatRG32Float, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RG32F + { kMtlPixelFormatInvalid, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RGB8 + { kMtlPixelFormatInvalid, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RGB8I + { kMtlPixelFormatInvalid, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RGB8U + { kMtlPixelFormatInvalid, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RGB8S + { kMtlPixelFormatRGB9E5Float, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // RGB9E5F + { kMtlPixelFormatBGRA8Unorm, kMtlPixelFormatBGRA8Unorm_sRGB, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // BGRA8 + { kMtlPixelFormatRGBA8Unorm, kMtlPixelFormatRGBA8Unorm_sRGB, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // RGBA8 + { kMtlPixelFormatRGBA8Sint, kMtlPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // RGBA8I + { kMtlPixelFormatRGBA8Uint, kMtlPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // RGBA8U + { kMtlPixelFormatRGBA8Snorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RGBA8S + { kMtlPixelFormatRGBA16Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RGBA16 + { kMtlPixelFormatRGBA16Sint, kMtlPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // RGBA16I + { kMtlPixelFormatRGBA16Uint, kMtlPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, false }, // RGBA16U + { kMtlPixelFormatRGBA16Float, kMtlPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // RGBA16F + { kMtlPixelFormatRGBA16Snorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RGBA16S + { kMtlPixelFormatRGBA32Sint, kMtlPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // RGBA32I + { kMtlPixelFormatRGBA32Uint, kMtlPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // RGBA32U + { kMtlPixelFormatRGBA32Float, kMtlPixelFormatInvalid, MTLReadWriteTextureTier2, { $R, $G, $B, $A }, true }, // RGBA32F + { kMtlPixelFormatB5G6R5Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // B5G6R5 + { kMtlPixelFormatB5G6R5Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $B, $G, $R, $A }, true }, // R5G6B5 + { kMtlPixelFormatABGR4Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $G, $B, $A, $R }, true }, // BGRA4 + { kMtlPixelFormatABGR4Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $A, $B, $G, $R }, true }, // RGBA4 + { kMtlPixelFormatBGR5A1Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // BGR5A1 + { kMtlPixelFormatBGR5A1Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $B, $G, $R, $A }, true }, // RGB5A1 + { kMtlPixelFormatRGB10A2Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RGB10A2 + { kMtlPixelFormatRG11B10Float, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, true }, // RG11B10F + { kMtlPixelFormatInvalid, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // UnknownDepth + { kMtlPixelFormatDepth16Unorm, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D16 + { kMtlPixelFormatDepth32Float, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D24 + { kMtlPixelFormatDepth24Unorm_Stencil8, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D24S8 + { kMtlPixelFormatDepth32Float, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D32 + { kMtlPixelFormatDepth32Float, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D16F + { kMtlPixelFormatDepth32Float, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D24F + { kMtlPixelFormatDepth32Float, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D32F + { kMtlPixelFormatStencil8, kMtlPixelFormatInvalid, MTLReadWriteTextureTierNone, { $R, $G, $B, $A }, false }, // D0S8 #undef $0 #undef $1 #undef $R @@ -347,9 +335,10 @@ inline void setViewType(ViewId _view, const bx::StringView _str) #undef $B #undef $A }; - BX_PRAGMA_DIAGNOSTIC_POP(); static_assert(TextureFormat::Count == BX_COUNTOF(s_textureFormat) ); +BX_PRAGMA_DIAGNOSTIC_POP(); + int32_t s_msaa[] = { 1, @@ -359,6 +348,18 @@ inline void setViewType(ViewId _view, const bx::StringView _str) 16, }; + static float s_shadingRate[] = + { + 1.0f, + 0.75f, + 0.75f, + 0.5f, + 0.5f, + 0.5f, + 0.25f, + }; + static_assert(ShadingRate::Count == BX_COUNTOF(s_shadingRate) ); + static UniformType::Enum convertMtlType(MTLDataType _type) { switch (_type) @@ -429,13 +430,15 @@ static uint32_t getEntryProperty(io_registry_entry_t _entry, CFStringRef _proper #ifndef __IPHONE_OS_VERSION_MAX_ALLOWED # define __IPHONE_OS_VERSION_MAX_ALLOWED 0 -#endif +#endif // __IPHONE_OS_VERSION_MAX_ALLOWED + #ifndef __MAC_OS_X_VERSION_MAX_ALLOWED # define __MAC_OS_X_VERSION_MAX_ALLOWED 0 -#endif +#endif // __IPHONE_OS_VERSION_MAX_ALLOWED + #ifndef __VISION_OS_VERSION_MAX_ALLOWED # define __VISION_OS_VERSION_MAX_ALLOWED 0 -#endif +#endif // __VISION_OS_VERSION_MAX_ALLOWED #ifndef BX_XCODE_15 # define BX_XCODE_15 (0 \ @@ -469,7 +472,7 @@ static uint32_t getEntryProperty(io_registry_entry_t _entry, CFStringRef _proper # define VISION_OS_MINIMUM visionOS 1.0, #else # define VISION_OS_MINIMUM -#endif +#endif // __VISION_OS_VERSION_MAX_ALLOWED >= 10000 #define SHADER_FUNCTION_NAME "xlatMtlMain" #define SHADER_UNIFORM_NAME "_mtl_u" @@ -485,6 +488,7 @@ static uint32_t getEntryProperty(io_registry_entry_t _entry, CFStringRef _proper , m_rtMsaa(false) , m_capture(NULL) , m_captureSize(0) + , m_variableRateShadingSupported(false) { bx::memSet(&m_windows, 0xff, sizeof(m_windows) ); } @@ -498,10 +502,10 @@ bool init(const Init& _init) BX_UNUSED(_init); BX_TRACE("Init."); -#define CHECK_FEATURE_AVAILABLE(feature, ...) \ - BX_MACRO_BLOCK_BEGIN \ - if (@available(__VA_ARGS__)) { feature = true; } else { feature = false; } \ - BX_TRACE("[MTL] OS feature %s: %d", (#feature) + 2, feature); \ +#define CHECK_FEATURE_AVAILABLE(feature, ...) \ + BX_MACRO_BLOCK_BEGIN \ + if (@available(__VA_ARGS__) ) { feature = true; } else { feature = false; } \ + BX_TRACE("[MTL] OS feature %s: %d", (#feature) + 2, feature); \ BX_MACRO_BLOCK_END CHECK_FEATURE_AVAILABLE(m_usesMTLBindings, macOS 13.0, iOS 16.0, tvOS 16.0, macCatalyst 16.0, VISION_OS_MINIMUM *); @@ -510,9 +514,9 @@ bool init(const Init& _init) CHECK_FEATURE_AVAILABLE(m_hasVSync, macOS 10.13, macCatalyst 13.1, *); CHECK_FEATURE_AVAILABLE(m_hasMaximumDrawableCount, iOS 11.2, macOS 10.13.2, macCatalyst 13.1, tvOS 11.2, VISION_OS_MINIMUM *); - m_fbh.idx = kInvalidHandle; + m_fbh = BGFX_INVALID_HANDLE; bx::memSet(m_uniforms, 0, sizeof(m_uniforms) ); - bx::memSet(&m_resolution, 0, sizeof(m_resolution) ); + m_resolution = _init.resolution; m_device = (id)g_platformData.context; @@ -529,166 +533,67 @@ bool init(const Init& _init) retain(m_device); - m_mainFrameBuffer.create( - 0 - , g_platformData.nwh - , _init.resolution.width - , _init.resolution.height - , TextureFormat::Unknown - , TextureFormat::UnknownDepth - ); - -#if BX_PLATFORM_VISIONOS - if (m_mainFrameBuffer.m_swapChain->m_useLayerRenderer) - { - m_deviceAnchor = ar_device_anchor_create(); - m_worldTracking = ar_world_tracking_provider_create(ar_world_tracking_configuration_create()); - m_arSession = ar_session_create(); - ar_session_run(m_arSession, ar_data_providers_create_with_data_providers(m_worldTracking, nil)); - } -#endif - m_numWindows = 1; - -#if BX_PLATFORM_VISIONOS - bool useLayerRenderer = m_mainFrameBuffer.m_swapChain->m_useLayerRenderer; - if ((useLayerRenderer && NULL == m_mainFrameBuffer.m_swapChain->m_layerRenderer) - || (!useLayerRenderer && NULL == m_mainFrameBuffer.m_swapChain->m_metalLayer)) -#else - if (NULL == m_mainFrameBuffer.m_swapChain->m_metalLayer) -#endif // BX_PLATFORM_VISIONOS - { - release(m_device); - return false; - } - - m_cmd.init(m_device); - BGFX_FATAL(NULL != m_cmd.m_commandQueue, Fatal::UnableToInitialize, "Unable to create Metal device."); - - m_renderPipelineDescriptor = newRenderPipelineDescriptor(); - m_depthStencilDescriptor = newDepthStencilDescriptor(); - m_frontFaceStencilDescriptor = newStencilDescriptor(); - m_backFaceStencilDescriptor = newStencilDescriptor(); - m_vertexDescriptor = newVertexDescriptor(); - m_textureDescriptor = newTextureDescriptor(); - m_samplerDescriptor = newSamplerDescriptor(); - - for (uint8_t ii = 0; ii < BGFX_CONFIG_MAX_FRAME_LATENCY; ++ii) - { - m_uniformBuffers[ii] = m_device.newBufferWithLength(UNIFORM_BUFFER_SIZE, 0); - } - - m_uniformBufferVertexOffset = 0; - m_uniformBufferFragmentOffset = 0; - - const char* vshSource = - "using namespace metal;\n" - "struct xlatMtlShaderOutput { float4 gl_Position [[position]]; float2 v_texcoord0; }; \n" - "vertex xlatMtlShaderOutput xlatMtlMain (uint v_id [[ vertex_id ]]) \n" - "{\n" - " xlatMtlShaderOutput _mtl_o;\n" - " if (v_id==0) { _mtl_o.gl_Position = float4(-1.0,-1.0,0.0,1.0); _mtl_o.v_texcoord0 = float2(0.0,1.0); } \n" - " else if (v_id==1) { _mtl_o.gl_Position = float4(3.0,-1.0,0.0,1.0); _mtl_o.v_texcoord0 = float2(2.0,1.0); } \n" - " else { _mtl_o.gl_Position = float4(-1.0,3.0,0.0,1.0); _mtl_o.v_texcoord0 = float2(0.0,-1.0); }\n" - " return _mtl_o;\n" - "}\n" - ; - - const char* fshSource = - "using namespace metal;\n" - "struct xlatMtlShaderInput { float2 v_texcoord0; };\n" - "fragment half4 xlatMtlMain (xlatMtlShaderInput _mtl_i[[stage_in]], texture2d s_texColor [[texture(0)]], sampler _mtlsmp_s_texColor [[sampler(0)]] )\n" - "{\n" - " return half4(s_texColor.sample(_mtlsmp_s_texColor, _mtl_i.v_texcoord0) );\n" - "}\n" - ; - - Library lib = m_device.newLibraryWithSource(vshSource); - if (NULL != lib) + if (m_device.supportsFamily(kMtlGPUFamilyApple4) ) { - m_screenshotBlitProgramVsh.m_function = lib.newFunctionWithName(SHADER_FUNCTION_NAME); - release(lib); - } + g_caps.vendorId = BGFX_PCI_ID_APPLE; + g_caps.deviceId = 1004; - lib = m_device.newLibraryWithSource(fshSource); - if (NULL != lib) - { - m_screenshotBlitProgramFsh.m_function = lib.newFunctionWithName(SHADER_FUNCTION_NAME); - release(lib); + if (m_device.supportsFamily(kMtlGPUFamilyApple10) ) + { + g_caps.deviceId = 1010; + } + else if (m_device.supportsFamily(kMtlGPUFamilyApple9) ) + { + g_caps.deviceId = 1009; + } + else if (m_device.supportsFamily(kMtlGPUFamilyApple8) ) + { + g_caps.deviceId = 1008; + } + else if (m_device.supportsFamily(kMtlGPUFamilyApple7) ) + { + g_caps.deviceId = 1007; + } + else if (m_device.supportsFamily(kMtlGPUFamilyApple6) ) + { + g_caps.deviceId = 1006; + } + else if (m_device.supportsFamily(kMtlGPUFamilyApple5) ) + { + g_caps.deviceId = 1005; + } } - m_screenshotBlitProgram.create(&m_screenshotBlitProgramVsh, &m_screenshotBlitProgramFsh); - - reset(m_renderPipelineDescriptor); - m_renderPipelineDescriptor.colorAttachments[0].pixelFormat = getSwapChainPixelFormat(m_mainFrameBuffer.m_swapChain); -#if BX_PLATFORM_VISIONOS - if (m_mainFrameBuffer.m_swapChain->m_useLayerRenderer) - { - m_renderPipelineDescriptor.depthAttachmentPixelFormat = cp_layer_renderer_configuration_get_depth_format(m_mainFrameBuffer.m_swapChain->m_layerRendererConfiguration); - } -#endif // BX_PLATFORM_VISIONOS - m_renderPipelineDescriptor.vertexFunction = m_screenshotBlitProgram.m_vsh->m_function; - m_renderPipelineDescriptor.fragmentFunction = m_screenshotBlitProgram.m_fsh->m_function; - m_screenshotBlitRenderPipelineState = m_device.newRenderPipelineStateWithDescriptor(m_renderPipelineDescriptor); - +#if BX_PLATFORM_OSX + if (0 == g_caps.vendorId) { - if ([m_device respondsToSelector: @selector(supportsFamily:)]) - { - if ([m_device supportsFamily: MTLGPUFamilyApple4]) - { - g_caps.vendorId = BGFX_PCI_ID_APPLE; + io_registry_entry_t entry; - if ([m_device supportsFamily: MTLGPUFamilyApple8]) - { - g_caps.deviceId = 1008; - } - else if ([m_device supportsFamily: MTLGPUFamilyApple7]) - { - g_caps.deviceId = 1007; - } - else if ([m_device supportsFamily: MTLGPUFamilyApple6]) - { - g_caps.deviceId = 1006; - } - else if ([m_device supportsFamily: MTLGPUFamilyApple5]) - { - g_caps.deviceId = 1005; - } - else - { - g_caps.deviceId = 1004; - } - } - } + uint64_t registryId = getRegistryId(m_device); -#if BX_PLATFORM_OSX - if (0 == g_caps.vendorId) + if (0 != registryId) { - io_registry_entry_t entry; + entry = IOServiceGetMatchingService(mach_port_t(NULL), IORegistryEntryIDMatching(registryId) ); - uint64_t registryId = getRegistryId(m_device); - - if (0 != registryId) + if (0 != entry) { - entry = IOServiceGetMatchingService(mach_port_t(NULL), IORegistryEntryIDMatching(registryId) ); + io_registry_entry_t parent; - if (0 != entry) + if (kIOReturnSuccess == IORegistryEntryGetParentEntry(entry, kIOServicePlane, &parent) ) { - io_registry_entry_t parent; - - if (kIOReturnSuccess == IORegistryEntryGetParentEntry(entry, kIOServicePlane, &parent) ) - { - g_caps.vendorId = getEntryProperty(parent, CFSTR("vendor-id") ); - g_caps.deviceId = getEntryProperty(parent, CFSTR("device-id") ); + g_caps.vendorId = getEntryProperty(parent, CFSTR("vendor-id") ); + g_caps.deviceId = getEntryProperty(parent, CFSTR("device-id") ); - IOObjectRelease(parent); - } - - IOObjectRelease(entry); + IOObjectRelease(parent); } + + IOObjectRelease(entry); } } -#endif // BX_PLATFORM_OSX } +#endif // BX_PLATFORM_OSX + + m_variableRateShadingSupported = false; //m_device.supportsVariableRasterizationRate(); g_caps.numGPUs = 1; g_caps.gpu[0].vendorId = g_caps.vendorId; @@ -712,7 +617,7 @@ bool init(const Init& _init) | BGFX_CAPS_VERTEX_ID ); - g_caps.supported |= m_device.supportsFamily(MTLGPUFamilyApple7) + g_caps.supported |= m_device.supportsFamily(kMtlGPUFamilyApple7) ? BGFX_CAPS_PRIMITIVE_ID : 0 ; @@ -720,7 +625,7 @@ bool init(const Init& _init) // Reference(s): // - Metal feature set tables // https://web.archive.org/web/20230330111145/https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf - g_caps.limits.maxTextureSize = m_device.supportsFamily(MTLGPUFamilyApple3) ? 16384 : 8192; + g_caps.limits.maxTextureSize = m_device.supportsFamily(kMtlGPUFamilyApple3) ? 16384 : 8192; g_caps.limits.maxFBAttachments = 8; g_caps.supported |= m_device.supportsFamily(MTLGPUFamilyCommon2) ? BGFX_CAPS_DRAW_INDIRECT @@ -735,27 +640,55 @@ bool init(const Init& _init) // It is decremented by 1 because 1 entry is used for uniforms. g_caps.limits.maxComputeBindings = bx::uint32_min(30, BGFX_MAX_COMPUTE_BINDINGS); - CHECK_FEATURE_AVAILABLE(m_hasPixelFormatDepth32Float_Stencil8, iOS 9.0, macOS 10.11, macCatalyst 13.1, tvOS 9.0, VISION_OS_MINIMUM *); - CHECK_FEATURE_AVAILABLE(m_hasStoreActionStoreAndMultisampleResolve, iOS 10.0, macOS 10.12, macCatalyst 13.1, tvOS 10.0, VISION_OS_MINIMUM *); + g_caps.supported |= m_variableRateShadingSupported + ? BGFX_CAPS_VARIABLE_RATE_SHADING + : 0 + ; + + CHECK_FEATURE_AVAILABLE( + m_hasPixelFormatDepth32Float_Stencil8 + , iOS 9.0 + , macOS 10.11 + , macCatalyst 13.1 + , tvOS 9.0 + , VISION_OS_MINIMUM * + ); + CHECK_FEATURE_AVAILABLE( + m_hasStoreActionStoreAndMultisampleResolve + , iOS 10.0 + , macOS 10.12 + , macCatalyst 13.1 + , tvOS 10.0 + , VISION_OS_MINIMUM * + ); - if (BX_ENABLED(BX_PLATFORM_OSX)) + if (BX_ENABLED(BX_PLATFORM_OSX) ) { - s_textureFormat[TextureFormat::R8].m_fmtSrgb = MTLPixelFormatInvalid; - s_textureFormat[TextureFormat::RG8].m_fmtSrgb = MTLPixelFormatInvalid; + s_textureFormat[TextureFormat::R8 ].m_fmtSrgb = kMtlPixelFormatInvalid; + s_textureFormat[TextureFormat::RG8].m_fmtSrgb = kMtlPixelFormatInvalid; } bool hasPacked16Formats; - CHECK_FEATURE_AVAILABLE(hasPacked16Formats, iOS 8.0, macOS 11.0, macCatalyst 14.0, tvOS 9.0, VISION_OS_MINIMUM *); + CHECK_FEATURE_AVAILABLE( + hasPacked16Formats + , iOS 8.0 + , macOS 11.0 + , macCatalyst 14.0 + , tvOS 9.0 + , VISION_OS_MINIMUM * + ); + if (g_caps.vendorId == BGFX_PCI_ID_AMD) { hasPacked16Formats = false; } + if (!hasPacked16Formats) { - s_textureFormat[bgfx::TextureFormat::R5G6B5].m_fmt = MTLPixelFormatInvalid; - s_textureFormat[bgfx::TextureFormat::B5G6R5].m_fmt = MTLPixelFormatInvalid; - s_textureFormat[bgfx::TextureFormat::BGRA4].m_fmt = MTLPixelFormatInvalid; - s_textureFormat[bgfx::TextureFormat::RGBA4].m_fmt = MTLPixelFormatInvalid; + s_textureFormat[bgfx::TextureFormat::R5G6B5].m_fmt = kMtlPixelFormatInvalid; + s_textureFormat[bgfx::TextureFormat::B5G6R5].m_fmt = kMtlPixelFormatInvalid; + s_textureFormat[bgfx::TextureFormat::BGRA4 ].m_fmt = kMtlPixelFormatInvalid; + s_textureFormat[bgfx::TextureFormat::RGBA4 ].m_fmt = kMtlPixelFormatInvalid; } const MTLReadWriteTextureTier rwTier = [m_device readWriteTextureSupport]; @@ -765,17 +698,25 @@ bool init(const Init& _init) ; bool hasD16Format; - CHECK_FEATURE_AVAILABLE(hasD16Format, iOS 13.0, macOS 10.12, macCatalyst 13.1, tvOS 13.0, VISION_OS_MINIMUM *); + CHECK_FEATURE_AVAILABLE( + hasD16Format + , iOS 13.0 + , macOS 10.12 + , macCatalyst 13.1 + , tvOS 13.0 + , VISION_OS_MINIMUM * + ); + if (!hasD16Format) { - s_textureFormat[TextureFormat::D16].m_fmt = MTLPixelFormatDepth32Float; + s_textureFormat[TextureFormat::D16].m_fmt = kMtlPixelFormatDepth32Float; } for (uint32_t ii = 0; ii < TextureFormat::Count; ++ii) { uint16_t support = 0; - support |= MTLPixelFormatInvalid != s_textureFormat[ii].m_fmt + support |= kMtlPixelFormatInvalid != s_textureFormat[ii].m_fmt ? BGFX_CAPS_FORMAT_TEXTURE_2D | BGFX_CAPS_FORMAT_TEXTURE_3D | BGFX_CAPS_FORMAT_TEXTURE_CUBE @@ -783,7 +724,7 @@ bool init(const Init& _init) : BGFX_CAPS_FORMAT_TEXTURE_NONE ; - support |= MTLPixelFormatInvalid != s_textureFormat[ii].m_fmtSrgb + support |= kMtlPixelFormatInvalid != s_textureFormat[ii].m_fmtSrgb ? BGFX_CAPS_FORMAT_TEXTURE_2D_SRGB | BGFX_CAPS_FORMAT_TEXTURE_3D_SRGB | BGFX_CAPS_FORMAT_TEXTURE_CUBE_SRGB @@ -821,9 +762,9 @@ bool init(const Init& _init) g_caps.formats[TextureFormat::RGBA32I] &= ~(BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER_MSAA); g_caps.formats[TextureFormat::RGBA32U] &= ~(BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER_MSAA); - if (BX_ENABLED(BX_PLATFORM_IOS) || BX_ENABLED(BX_PLATFORM_VISIONOS)) + if (BX_ENABLED(BX_PLATFORM_IOS) || BX_ENABLED(BX_PLATFORM_VISIONOS) ) { - s_textureFormat[TextureFormat::D24S8].m_fmt = MTLPixelFormatDepth32Float_Stencil8; + s_textureFormat[TextureFormat::D24S8].m_fmt = kMtlPixelFormatDepth32Float_Stencil8; g_caps.formats[TextureFormat::BC1 ] = g_caps.formats[TextureFormat::BC2 ] = @@ -837,13 +778,13 @@ bool init(const Init& _init) g_caps.formats[TextureFormat::RGBA32F] &= ~(BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER_MSAA); } + s_textureFormat[TextureFormat::D24S8].m_fmt = m_device.depth24Stencil8PixelFormatSupported() + ? kMtlPixelFormatDepth24Unorm_Stencil8 + : kMtlPixelFormatDepth32Float_Stencil8 + ; + if (BX_ENABLED(BX_PLATFORM_OSX) ) { - s_textureFormat[TextureFormat::D24S8].m_fmt = (MTLPixelFormat)(m_device.depth24Stencil8PixelFormatSupported() - ? 255 /* Depth24Unorm_Stencil8 */ - : MTLPixelFormatDepth32Float_Stencil8) - ; - g_caps.formats[TextureFormat::ETC2 ] = g_caps.formats[TextureFormat::ETC2A ] = g_caps.formats[TextureFormat::ETC2A1] = @@ -859,8 +800,8 @@ bool init(const Init& _init) { if (BGFX_CAPS_FORMAT_TEXTURE_NONE == g_caps.formats[ii]) { - s_textureFormat[ii].m_fmt = MTLPixelFormatInvalid; - s_textureFormat[ii].m_fmtSrgb = MTLPixelFormatInvalid; + s_textureFormat[ii].m_fmt = kMtlPixelFormatInvalid; + s_textureFormat[ii].m_fmtSrgb = kMtlPixelFormatInvalid; } } @@ -884,6 +825,95 @@ bool init(const Init& _init) bx::snprintf(s_viewName[ii], BGFX_CONFIG_MAX_VIEW_NAME_RESERVED+1, "%3d ", ii); } + m_renderPipelineDescriptor = newRenderPipelineDescriptor(); + m_depthStencilDescriptor = newDepthStencilDescriptor(); + m_frontFaceStencilDescriptor = newStencilDescriptor(); + m_backFaceStencilDescriptor = newStencilDescriptor(); + m_vertexDescriptor = newVertexDescriptor(); + m_samplerDescriptor = newSamplerDescriptor(); + + if (NULL == g_platformData.nwh) + { + BX_TRACE("Headless."); + } + else + { + m_mainFrameBuffer.create( + 0 + , g_platformData.nwh + , m_resolution.width + , m_resolution.height + , m_resolution.formatColor + , m_resolution.formatDepthStencil + ); + m_textVideoMem.resize(false, m_resolution.width, m_resolution.height); + m_textVideoMem.clear(); + + m_numWindows = 1; + + if (NULL == m_mainFrameBuffer.m_swapChain->m_metalLayer) + { + MTL_RELEASE(m_device, 0); + return false; + } + } + + m_cmd.init(m_device); + BGFX_FATAL(NULL != m_cmd.m_commandQueue, Fatal::UnableToInitialize, "Unable to create Metal device."); + + for (uint8_t ii = 0; ii < BGFX_CONFIG_MAX_FRAME_LATENCY; ++ii) + { + m_uniformBuffers[ii] = m_device.newBufferWithLength(UNIFORM_BUFFER_SIZE, 0); + } + + m_uniformBufferVertexOffset = 0; + m_uniformBufferFragmentOffset = 0; + + const char* vshSource = + "using namespace metal;\n" + "struct xlatMtlShaderOutput { float4 gl_Position [[position]]; float2 v_texcoord0; }; \n" + "vertex xlatMtlShaderOutput xlatMtlMain (uint v_id [[ vertex_id ]]) \n" + "{\n" + " xlatMtlShaderOutput _mtl_o;\n" + " if (v_id==0) { _mtl_o.gl_Position = float4(-1.0,-1.0,0.0,1.0); _mtl_o.v_texcoord0 = float2(0.0,1.0); } \n" + " else if (v_id==1) { _mtl_o.gl_Position = float4(3.0,-1.0,0.0,1.0); _mtl_o.v_texcoord0 = float2(2.0,1.0); } \n" + " else { _mtl_o.gl_Position = float4(-1.0,3.0,0.0,1.0); _mtl_o.v_texcoord0 = float2(0.0,-1.0); }\n" + " return _mtl_o;\n" + "}\n" + ; + + const char* fshSource = + "using namespace metal;\n" + "struct xlatMtlShaderInput { float2 v_texcoord0; };\n" + "fragment half4 xlatMtlMain (xlatMtlShaderInput _mtl_i[[stage_in]], texture2d s_texColor [[texture(0)]], sampler _mtlsmp_s_texColor [[sampler(0)]] )\n" + "{\n" + " return half4(s_texColor.sample(_mtlsmp_s_texColor, _mtl_i.v_texcoord0) );\n" + "}\n" + ; + + Library lib = m_device.newLibraryWithSource(vshSource); + if (NULL != lib) + { + m_screenshotBlitProgramVsh.m_function = lib.newFunctionWithName(SHADER_FUNCTION_NAME); + MTL_RELEASE_W(lib, 0); + } + + lib = m_device.newLibraryWithSource(fshSource); + if (NULL != lib) + { + m_screenshotBlitProgramFsh.m_function = lib.newFunctionWithName(SHADER_FUNCTION_NAME); + MTL_RELEASE_W(lib, 0); + } + + m_screenshotBlitProgram.create(&m_screenshotBlitProgramVsh, &m_screenshotBlitProgramFsh); + + reset(m_renderPipelineDescriptor); + m_renderPipelineDescriptor.colorAttachments[0].pixelFormat = getSwapChainPixelFormat(m_mainFrameBuffer.m_swapChain); + + m_renderPipelineDescriptor.vertexFunction = m_screenshotBlitProgram.m_vsh->m_function; + m_renderPipelineDescriptor.fragmentFunction = m_screenshotBlitProgram.m_fsh->m_function; + m_screenshotBlitRenderPipelineState = m_device.newRenderPipelineStateWithDescriptor(m_renderPipelineDescriptor); + m_occlusionQuery.preReset(); m_gpuTimer.init(); @@ -903,6 +933,8 @@ void shutdown() m_depthStencilStateCache.invalidate(); m_samplerStateCache.invalidate(); + m_cmd.kick(false, true); + for (uint32_t ii = 0; ii < BX_COUNTOF(m_shaders); ++ii) { m_shaders[ii].destroy(); @@ -916,36 +948,27 @@ void shutdown() m_screenshotBlitProgramVsh.destroy(); m_screenshotBlitProgramFsh.destroy(); m_screenshotBlitProgram.destroy(); - MTL_RELEASE(m_screenshotBlitRenderPipelineState); + MTL_RELEASE(m_screenshotBlitRenderPipelineState, 0); captureFinish(); - MTL_RELEASE(m_depthStencilDescriptor); - MTL_RELEASE(m_frontFaceStencilDescriptor); - MTL_RELEASE(m_backFaceStencilDescriptor); - MTL_RELEASE(m_renderPipelineDescriptor); - MTL_RELEASE(m_vertexDescriptor); - MTL_RELEASE(m_textureDescriptor); - MTL_RELEASE(m_samplerDescriptor); - -#if BX_PLATFORM_VISIONOS - if (m_mainFrameBuffer.m_swapChain->m_useLayerRenderer) - { - ar_session_stop(m_arSession); - MTL_RELEASE(m_arSession); - MTL_RELEASE(m_worldTracking); - MTL_RELEASE(m_deviceAnchor); - } -#endif // BX_PLATFORM_VISIONOS + MTL_RELEASE(m_depthStencilDescriptor, 0); + MTL_RELEASE(m_frontFaceStencilDescriptor, 0); + MTL_RELEASE(m_backFaceStencilDescriptor, 0); + MTL_RELEASE(m_renderPipelineDescriptor, 0); + MTL_RELEASE(m_vertexDescriptor, 0); + MTL_RELEASE(m_samplerDescriptor, 0); m_mainFrameBuffer.destroy(); - for (uint8_t i=0; i < BGFX_CONFIG_MAX_FRAME_LATENCY; ++i) + m_cmd.shutdown(); + + for (uint8_t ii = 0; ii < BGFX_CONFIG_MAX_FRAME_LATENCY; ++ii) { - MTL_RELEASE(m_uniformBuffers[i]); + MTL_RELEASE_W(m_uniformBuffers[ii], 0); } - m_cmd.shutdown(); - MTL_RELEASE(m_device); + + MTL_RELEASE_W(m_device, 0); } RendererType::Enum getRendererType() const override @@ -1072,17 +1095,12 @@ void updateTextureEnd() override { } - MTLPixelFormat getSwapChainPixelFormat(SwapChainMtl *swapChain) + static MTLPixelFormat getSwapChainPixelFormat(SwapChainMtl* _swapChain) { -#if BX_PLATFORM_VISIONOS - if (swapChain->m_useLayerRenderer) - { - cp_layer_renderer_configuration_t layerConfiguration = cp_layer_renderer_get_configuration(swapChain->m_layerRenderer); - return cp_layer_renderer_configuration_get_color_format(layerConfiguration); - } -#endif // BX_PLATFORM_VISIONOS - - return swapChain->m_metalLayer.pixelFormat; + return NULL != _swapChain + ? _swapChain->m_metalLayer.pixelFormat + : kMtlPixelFormatInvalid + ; } void readTexture(TextureHandle _handle, void* _data, uint8_t _mip) override @@ -1100,9 +1118,9 @@ void readTexture(TextureHandle _handle, void* _data, uint8_t _mip) override BX_ASSERT(_mip> _mip); - uint32_t srcHeight = bx::uint32_max(1, texture.m_ptr.height() >> _mip); - const uint8_t bpp = bimg::getBitsPerPixel(bimg::TextureFormat::Enum(texture.m_textureFormat) ); + const uint32_t srcWidth = bx::uint32_max(1, texture.m_ptr.width() >> _mip); + const uint32_t srcHeight = bx::uint32_max(1, texture.m_ptr.height() >> _mip); + const uint8_t bpp = bimg::getBitsPerPixel(bimg::TextureFormat::Enum(texture.m_textureFormat) ); MTLRegion region = { @@ -1121,8 +1139,7 @@ void resizeTexture(TextureHandle _handle, uint16_t _width, uint16_t _height, uin const Memory* mem = alloc(size); bx::StaticMemoryBlockWriter writer(mem->data, mem->size); - uint32_t magic = BGFX_CHUNK_MAGIC_TEX; - bx::write(&writer, magic, bx::ErrorAssert{}); + bx::write(&writer, kChunkMagicTex, bx::ErrorAssert{}); TextureCreate tc; tc.m_width = _width; @@ -1141,7 +1158,7 @@ void resizeTexture(TextureHandle _handle, uint16_t _width, uint16_t _height, uin release(mem); } - void overrideInternal(TextureHandle _handle, uintptr_t _ptr) override + void overrideInternal(TextureHandle _handle, uintptr_t _ptr, uint16_t /*_layerIndex*/) override { m_textures[_handle.idx].overrideInternal(_ptr); } @@ -1178,7 +1195,6 @@ void createFrameBuffer(FrameBufferHandle _handle, void* _nwh, uint32_t _width, u FrameBufferMtl& fb = m_frameBuffers[_handle.idx]; fb.create(denseIdx, _nwh, _width, _height, _format, _depthFormat); - fb.m_swapChain->resize(m_frameBuffers[_handle.idx], _width, _height, m_resolution.reset, m_resolution.maxFrameLatency); } void destroyFrameBuffer(FrameBufferHandle _handle) override @@ -1326,6 +1342,8 @@ virtual void setName(Handle _handle, const char* _name, uint16_t _len) override void submitBlit(BlitState& _bs, uint16_t _view); + void submitUniformCache(UniformCacheState& _ucs, uint16_t _view); + void submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter) override; void blitSetup(TextVideoMemBlitter& _blitter) override @@ -1333,41 +1351,12 @@ void blitSetup(TextVideoMemBlitter& _blitter) override BX_UNUSED(_blitter); } -#if BX_PLATFORM_VISIONOS - void calculateViewPorts(MTLViewport (&viewports)[2]) - { - const int viewCount = 2; - for (int i = 0; i < viewCount; i++) - { - cp_view_t view = cp_drawable_get_view(m_mainFrameBuffer.m_swapChain->m_layerRendererDrawable, i); - cp_view_texture_map_t texture_map = cp_view_get_view_texture_map(view); - viewports[i] = cp_view_texture_map_get_viewport(texture_map); - } - } - - void setVertexAmplification(RenderCommandEncoder& _rce) - { - MTLVertexAmplificationViewMapping mapping0; - MTLVertexAmplificationViewMapping mapping1; - - mapping0.renderTargetArrayIndexOffset = 0; - mapping1.renderTargetArrayIndexOffset = 1; - - mapping0.viewportArrayIndexOffset = 1; - mapping1.viewportArrayIndexOffset = 2; - - MTLVertexAmplificationViewMapping mappings[] = { mapping0, mapping1 }; - - _rce.setVertexAmplificationCount(2, mappings); - } -#endif // BX_PLATFORM_VISIONOS - void blitRender(TextVideoMemBlitter& _blitter, uint32_t _numIndices) override { const uint32_t numVertices = _numIndices*4/6; if (0 < numVertices) { - m_indexBuffers [_blitter.m_ib->handle.idx].update( + m_indexBuffers[_blitter.m_ib->handle.idx].update( 0 , bx::strideAlign(_numIndices*2, 4) , _blitter.m_ib->data @@ -1382,8 +1371,8 @@ void blitRender(TextVideoMemBlitter& _blitter, uint32_t _numIndices) override endEncoding(); - uint32_t width = m_resolution.width; - uint32_t height = m_resolution.height; + const uint32_t width = m_resolution.width; + const uint32_t height = m_resolution.height; FrameBufferHandle fbh = BGFX_INVALID_HANDLE; @@ -1401,21 +1390,8 @@ void blitRender(TextVideoMemBlitter& _blitter, uint32_t _numIndices) override RenderCommandEncoder rce = m_commandBuffer.renderCommandEncoderWithDescriptor(renderPassDescriptor); m_renderCommandEncoder = rce; m_renderCommandEncoderFrameBufferHandle = fbh; - MTL_RELEASE(renderPassDescriptor); + MTL_RELEASE(renderPassDescriptor, 0); -#if BX_PLATFORM_VISIONOS - if (m_mainFrameBuffer.m_swapChain->m_useLayerRenderer) - { - if (cp_layer_renderer_configuration_get_layout(m_mainFrameBuffer.m_swapChain->m_layerRendererConfiguration) == cp_layer_renderer_layout_layered) - { - MTLViewport viewports[2]; - calculateViewPorts(viewports); - rce.setViewports(viewports, 2); - setVertexAmplification(rce); - } - } - else -#endif // BX_PLATFORM_VISIONOS { MTLViewport viewport = { 0.0f, 0.0f, (float)width, (float)height, 0.0f, 1.0f }; rce.setViewport(viewport); @@ -1495,19 +1471,6 @@ bool isDeviceRemoved() override return false; } -#if BX_PLATFORM_VISIONOS - void createPoseForTiming(cp_frame_timing_t timing, ar_world_tracking_provider_t world_tracking) - { - cp_time_t presentationTime = cp_frame_timing_get_presentation_time(timing); - CFTimeInterval queryTime = cp_time_to_cf_time_interval(presentationTime); - ar_device_anchor_query_status_t status = ar_world_tracking_provider_query_device_anchor_at_timestamp(world_tracking, queryTime, m_deviceAnchor); - if (status != ar_device_anchor_query_status_success) - { - BX_WARN(false, "Device anchor query failed.") - } - } -#endif // BX_PLATFORM_VISIONOS - void flip() override { if (NULL == m_commandBuffer) @@ -1521,43 +1484,33 @@ void flip() override if (NULL != frameBuffer.m_swapChain && frameBuffer.m_swapChain->m_drawableTexture) { - MTL_RELEASE(frameBuffer.m_swapChain->m_drawableTexture); + MTL_RELEASE_I(frameBuffer.m_swapChain->m_drawableTexture); -#if BX_PLATFORM_VISIONOS - if (frameBuffer.m_swapChain->m_useLayerRenderer) { - if (NULL != frameBuffer.m_swapChain->m_layerRendererDrawable) + if (NULL != frameBuffer.m_swapChain->m_drawable) { - if (m_worldTracking != NULL) - { - auto timingInfo = cp_drawable_get_frame_timing(frameBuffer.m_swapChain->m_layerRendererDrawable); - createPoseForTiming(timingInfo, m_worldTracking); - cp_drawable_set_device_anchor(frameBuffer.m_swapChain->m_layerRendererDrawable, m_deviceAnchor); - } - cp_drawable_encode_present(frameBuffer.m_swapChain->m_layerRendererDrawable, m_commandBuffer); - cp_frame_end_submission(frameBuffer.m_swapChain->m_frame); + m_commandBuffer.presentDrawable(frameBuffer.m_swapChain->m_drawable); + MTL_RELEASE_I(frameBuffer.m_swapChain->m_drawable); } } - else -#endif // BX_PLATFORM_VISIONOS - if (NULL != frameBuffer.m_swapChain->m_drawable) - { - m_commandBuffer.presentDrawable(frameBuffer.m_swapChain->m_drawable); - MTL_RELEASE(frameBuffer.m_swapChain->m_drawable); - } } } - m_cmd.kick(true); + m_cmd.kick(true, false); m_commandBuffer = 0; } void updateResolution(const Resolution& _resolution) { - m_mainFrameBuffer.m_swapChain->m_maxAnisotropy = !!(_resolution.reset & BGFX_RESET_MAXANISOTROPY) - ? 16 - : 1 - ; + SwapChainMtl* swapChain = m_mainFrameBuffer.m_swapChain; + + if (NULL != swapChain) + { + swapChain->m_maxAnisotropy = !!(_resolution.reset & BGFX_RESET_MAXANISOTROPY) + ? 16 + : 1 + ; + } const uint32_t maskFlags = ~(0 | BGFX_RESET_MAXANISOTROPY @@ -1569,17 +1522,22 @@ void updateResolution(const Resolution& _resolution) || m_resolution.height != _resolution.height || (m_resolution.reset&maskFlags) != (_resolution.reset&maskFlags) ) { - MTLPixelFormat prevMetalLayerPixelFormat = getSwapChainPixelFormat(m_mainFrameBuffer.m_swapChain); m_resolution = _resolution; - if (m_resolution.reset & BGFX_RESET_INTERNAL_FORCE - && m_mainFrameBuffer.m_swapChain->m_nwh != g_platformData.nwh) + const MTLPixelFormat prevPixelFormat = getSwapChainPixelFormat(swapChain); + + if (NULL != swapChain) { - m_mainFrameBuffer.m_swapChain->init(g_platformData.nwh); + if (m_resolution.reset & BGFX_RESET_INTERNAL_FORCE + && swapChain->m_nwh != g_platformData.nwh) + { + swapChain->init(g_platformData.nwh); + } + + m_mainFrameBuffer.resizeSwapChain(_resolution.width, _resolution.height); } - m_resolution.reset &= ~BGFX_RESET_INTERNAL_FORCE; - m_mainFrameBuffer.m_swapChain->resize(m_mainFrameBuffer, _resolution.width, _resolution.height, _resolution.reset, m_resolution.maxFrameLatency); + m_resolution.reset &= ~BGFX_RESET_INTERNAL_FORCE; for (uint32_t ii = 0; ii < BX_COUNTOF(m_frameBuffers); ++ii) { @@ -1591,13 +1549,14 @@ void updateResolution(const Resolution& _resolution) m_textVideoMem.resize(false, _resolution.width, _resolution.height); m_textVideoMem.clear(); + const MTLPixelFormat pixelFormat = getSwapChainPixelFormat(swapChain); - if (prevMetalLayerPixelFormat != getSwapChainPixelFormat(m_mainFrameBuffer.m_swapChain)) + if (prevPixelFormat != pixelFormat) { - MTL_RELEASE(m_screenshotBlitRenderPipelineState) + MTL_RELEASE_I(m_screenshotBlitRenderPipelineState); reset(m_renderPipelineDescriptor); - m_renderPipelineDescriptor.colorAttachments[0].pixelFormat = getSwapChainPixelFormat(m_mainFrameBuffer.m_swapChain); + m_renderPipelineDescriptor.colorAttachments[0].pixelFormat = pixelFormat; m_renderPipelineDescriptor.vertexFunction = m_screenshotBlitProgram.m_vsh->m_function; m_renderPipelineDescriptor.fragmentFunction = m_screenshotBlitProgram.m_fsh->m_function; m_screenshotBlitRenderPipelineState = m_device.newRenderPipelineStateWithDescriptor(m_renderPipelineDescriptor); @@ -1648,7 +1607,7 @@ void capture() m_commandBuffer = m_cmd.alloc(); - if (m_screenshotTarget.pixelFormat() == MTLPixelFormatRGBA8Uint) + if (m_screenshotTarget.pixelFormat() == kMtlPixelFormatRGBA8Uint) { bimg::imageSwizzleBgra8( m_capture @@ -1702,7 +1661,7 @@ void capture() } m_renderCommandEncoder = m_commandBuffer.renderCommandEncoderWithDescriptor(renderPassDescriptor); - MTL_RELEASE(renderPassDescriptor); + MTL_RELEASE(renderPassDescriptor, 0); } } @@ -1720,7 +1679,7 @@ void captureFinish() void setShaderUniform(uint8_t _flags, uint32_t _loc, const void* _val, uint32_t _numRegs) { - uint32_t offset = 0 != (_flags&kUniformFragmentBit) + const uint32_t offset = 0 != (_flags&kUniformFragmentBit) ? m_uniformBufferFragmentOffset : m_uniformBufferVertexOffset ; @@ -1985,26 +1944,7 @@ void setFrameBuffer(RenderPassDescriptor _renderPassDescriptor, FrameBufferHandl : swapChain->currentDrawableTexture() ; } -#if BX_PLATFORM_VISIONOS - if (m_mainFrameBuffer.m_swapChain->m_useLayerRenderer) - { - Texture texture = cp_drawable_get_depth_texture(swapChain->m_layerRendererDrawable, 0); - _renderPassDescriptor.depthAttachment.texture = texture; - _renderPassDescriptor.stencilAttachment.texture = swapChain->m_backBufferStencil; - cp_layer_renderer_configuration_t layerConfiguration = cp_layer_renderer_get_configuration(swapChain->m_layerRenderer); - cp_layer_renderer_layout layout = cp_layer_renderer_configuration_get_layout(layerConfiguration); - if (layout == cp_layer_renderer_layout_layered) - { - _renderPassDescriptor.renderTargetArrayLength = cp_drawable_get_view_count(swapChain->m_layerRendererDrawable); - } - else - { - _renderPassDescriptor.renderTargetArrayLength = 1; - } - } - else -#endif // BX_PLATFORM_VISIONOS { _renderPassDescriptor.depthAttachment.texture = swapChain->m_backBufferDepth; _renderPassDescriptor.stencilAttachment.texture = swapChain->m_backBufferStencil; @@ -2043,8 +1983,10 @@ void setFrameBuffer(RenderPassDescriptor _renderPassDescriptor, FrameBufferHandl if (texture.m_textureFormat == TextureFormat::D24S8) { - if (texture.m_ptr.pixelFormat() == 255 /* Depth24Unorm_Stencil8 */ - || texture.m_ptr.pixelFormat() == 260 /* Depth32Float_Stencil8 */) + const MTLPixelFormat depthFormat = texture.m_ptr.pixelFormat(); + + if (kMtlPixelFormatDepth24Unorm_Stencil8 == depthFormat + || kMtlPixelFormatDepth32Float_Stencil8 == depthFormat) { _renderPassDescriptor.stencilAttachment.texture = _renderPassDescriptor.depthAttachment.texture; } @@ -2131,15 +2073,17 @@ void setDepthStencilState(uint64_t _state, uint64_t _stencil = 0) m_renderCommandEncoder.setStencilReferenceValue(ref); } - BX_PRAGMA_DIAGNOSTIC_PUSH(); - BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wunguarded-availability-new"); - BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wincompatible-pointer-types"); void processArguments( PipelineStateMtl* ps , NSArray>* _vertexArgs , NSArray>* _fragmentArgs ) { +BX_PRAGMA_DIAGNOSTIC_PUSH(); +BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wunguarded-availability-new"); +BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wincompatible-pointer-types"); +BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wdeprecated-declarations"); + ps->m_numPredefined = 0; for (uint32_t shaderType = 0; shaderType < 2; ++shaderType) @@ -2154,7 +2098,7 @@ void processArguments( { BX_TRACE("arg: %s type:%d", utf8String(arg.name), arg.type); - if ((!m_usesMTLBindings && [(MTLArgument*)arg isActive]) || (m_usesMTLBindings && arg.used)) + if ( (!m_usesMTLBindings && [(MTLArgument*)arg isActive]) || (m_usesMTLBindings && arg.used) ) { if (arg.type == MTLBindingTypeBuffer) { @@ -2301,8 +2245,8 @@ void processArguments( constantBuffer->finish(); } } +BX_PRAGMA_DIAGNOSTIC_POP(); } - BX_PRAGMA_DIAGNOSTIC_POP(); PipelineStateMtl* getPipelineState( uint64_t _state @@ -2381,17 +2325,17 @@ void processArguments( : 1 ; pd.colorAttachments[0].pixelFormat = swapChain->currentDrawableTexture().pixelFormat; -#if BX_PLATFORM_VISIONOS - if (m_mainFrameBuffer.m_swapChain->m_useLayerRenderer) { - pd.depthAttachmentPixelFormat = cp_layer_renderer_configuration_get_depth_format(swapChain->m_layerRendererConfiguration); - } - else -#endif // BX_PLATFORM_VISIONOS - { - pd.depthAttachmentPixelFormat = swapChain->m_backBufferDepth.m_obj.pixelFormat; + pd.depthAttachmentPixelFormat = NULL != swapChain->m_backBufferDepth + ? swapChain->m_backBufferDepth.m_obj.pixelFormat + : kMtlPixelFormatInvalid + ; } - pd.stencilAttachmentPixelFormat = swapChain->m_backBufferStencil.m_obj.pixelFormat; + + pd.stencilAttachmentPixelFormat = NULL != swapChain->m_backBufferStencil + ? swapChain->m_backBufferStencil.m_obj.pixelFormat + : kMtlPixelFormatInvalid + ; } else { @@ -2410,22 +2354,20 @@ void processArguments( if (isValid(frameBuffer.m_depthHandle) ) { - const TextureMtl& texture = m_textures[frameBuffer.m_depthHandle.idx]; - pd.depthAttachmentPixelFormat = texture.m_ptr.m_obj.pixelFormat; - pd.rasterSampleCount = NULL != texture.m_ptrMsaa - ? texture.m_ptrMsaa.sampleCount() + const TextureMtl& depthStencilTexture = m_textures[frameBuffer.m_depthHandle.idx]; + pd.depthAttachmentPixelFormat = depthStencilTexture.m_ptr.m_obj.pixelFormat; + pd.rasterSampleCount = NULL != depthStencilTexture.m_ptrMsaa + ? depthStencilTexture.m_ptrMsaa.sampleCount() : 1 ; - if (NULL != texture.m_ptrStencil) + + if (NULL != depthStencilTexture.m_ptrStencil) { - pd.stencilAttachmentPixelFormat = texture.m_ptrStencil.m_obj.pixelFormat; + pd.stencilAttachmentPixelFormat = depthStencilTexture.m_ptrStencil.m_obj.pixelFormat; } - else + else if (depthStencilTexture.m_textureFormat == TextureFormat::D24S8) { - if (texture.m_textureFormat == TextureFormat::D24S8) - { - pd.stencilAttachmentPixelFormat = texture.m_ptr.m_obj.pixelFormat; - } + pd.stencilAttachmentPixelFormat = depthStencilTexture.m_ptr.m_obj.pixelFormat; } } } @@ -2489,17 +2431,10 @@ void processArguments( } pd.vertexFunction = program.m_vsh->m_function; - pd.fragmentFunction = program.m_fsh != NULL ? program.m_fsh->m_function : NULL; -#if BX_PLATFORM_VISIONOS - if (m_mainFrameBuffer.m_swapChain->m_useLayerRenderer) - { - if (cp_layer_renderer_configuration_get_layout(m_mainFrameBuffer.m_swapChain->m_layerRendererConfiguration) == cp_layer_renderer_layout_layered) - { - auto properties = cp_layer_renderer_get_properties(m_mainFrameBuffer.m_swapChain->m_layerRenderer); - pd.maxVertexAmplificationCount = cp_layer_renderer_properties_get_view_count(properties); - } - } -#endif + pd.fragmentFunction = program.m_fsh != NULL + ? program.m_fsh->m_function + : NULL + ; VertexDescriptor vertexDesc = m_vertexDescriptor; reset(vertexDesc); @@ -2514,8 +2449,12 @@ void processArguments( for (uint32_t ii = 0; Attrib::Count != program.m_used[ii]; ++ii) { Attrib::Enum attr = Attrib::Enum(program.m_used[ii]); + if (attrSet[attr]) + { continue; + } + const uint32_t loc = program.m_attributes[attr]; uint8_t num; @@ -2547,8 +2486,9 @@ void processArguments( for (uint32_t ii = 0; Attrib::Count != program.m_used[ii]; ++ii) { - Attrib::Enum attr = Attrib::Enum(program.m_used[ii]); + const Attrib::Enum attr = Attrib::Enum(program.m_used[ii]); const uint32_t loc = program.m_attributes[attr]; + if (!attrSet[attr]) { vertexDesc.attributes[loc].format = MTLVertexFormatUChar2; @@ -2580,9 +2520,11 @@ void processArguments( if (NULL != reflection) { - BX_PRAGMA_DIAGNOSTIC_PUSH(); - BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wunguarded-availability-new"); - BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wincompatible-pointer-types"); +BX_PRAGMA_DIAGNOSTIC_PUSH(); +BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wunguarded-availability-new"); +BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wincompatible-pointer-types"); +BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wdeprecated-declarations"); + if (m_usesMTLBindings) { processArguments(pso, reflection.vertexBindings, reflection.fragmentBindings); @@ -2591,7 +2533,8 @@ void processArguments( { processArguments(pso, reflection.vertexArguments, reflection.fragmentArguments); } - BX_PRAGMA_DIAGNOSTIC_POP(); + +BX_PRAGMA_DIAGNOSTIC_POP(); } } @@ -2639,9 +2582,11 @@ void processArguments( , &reflection ); - BX_PRAGMA_DIAGNOSTIC_PUSH(); - BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wunguarded-availability-new"); - BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wincompatible-pointer-types"); +BX_PRAGMA_DIAGNOSTIC_PUSH(); +BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wunguarded-availability-new"); +BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wincompatible-pointer-types"); +BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG("-Wdeprecated-declarations"); + if (m_usesMTLBindings) { processArguments(pso, reflection.bindings, NULL); @@ -2650,7 +2595,8 @@ void processArguments( { processArguments(pso, reflection.arguments, NULL); } - BX_PRAGMA_DIAGNOSTIC_POP(); + +BX_PRAGMA_DIAGNOSTIC_POP(); for (uint32_t ii = 0; ii < 3; ++ii) { @@ -2668,16 +2614,18 @@ SamplerState getSamplerState(uint32_t _flags) if (NULL == sampler) { - m_samplerDescriptor.sAddressMode = s_textureAddress[(_flags&BGFX_SAMPLER_U_MASK)>>BGFX_SAMPLER_U_SHIFT]; - m_samplerDescriptor.tAddressMode = s_textureAddress[(_flags&BGFX_SAMPLER_V_MASK)>>BGFX_SAMPLER_V_SHIFT]; - m_samplerDescriptor.rAddressMode = s_textureAddress[(_flags&BGFX_SAMPLER_W_MASK)>>BGFX_SAMPLER_W_SHIFT]; - m_samplerDescriptor.minFilter = s_textureFilterMinMag[(_flags&BGFX_SAMPLER_MIN_MASK)>>BGFX_SAMPLER_MIN_SHIFT]; - m_samplerDescriptor.magFilter = s_textureFilterMinMag[(_flags&BGFX_SAMPLER_MAG_MASK)>>BGFX_SAMPLER_MAG_SHIFT]; - m_samplerDescriptor.mipFilter = s_textureFilterMip[(_flags&BGFX_SAMPLER_MIP_MASK)>>BGFX_SAMPLER_MIP_SHIFT]; - m_samplerDescriptor.lodMinClamp = 0; - m_samplerDescriptor.lodMaxClamp = FLT_MAX; - m_samplerDescriptor.normalizedCoordinates = TRUE; - m_samplerDescriptor.maxAnisotropy = (0 != (_flags & (BGFX_SAMPLER_MIN_ANISOTROPIC|BGFX_SAMPLER_MAG_ANISOTROPIC) ) ) + SamplerDescriptor desc = m_samplerDescriptor; + + desc.sAddressMode = s_textureAddress[(_flags&BGFX_SAMPLER_U_MASK)>>BGFX_SAMPLER_U_SHIFT]; + desc.tAddressMode = s_textureAddress[(_flags&BGFX_SAMPLER_V_MASK)>>BGFX_SAMPLER_V_SHIFT]; + desc.rAddressMode = s_textureAddress[(_flags&BGFX_SAMPLER_W_MASK)>>BGFX_SAMPLER_W_SHIFT]; + desc.minFilter = s_textureFilterMinMag[(_flags&BGFX_SAMPLER_MIN_MASK)>>BGFX_SAMPLER_MIN_SHIFT]; + desc.magFilter = s_textureFilterMinMag[(_flags&BGFX_SAMPLER_MAG_MASK)>>BGFX_SAMPLER_MAG_SHIFT]; + desc.mipFilter = s_textureFilterMip[(_flags&BGFX_SAMPLER_MIP_MASK)>>BGFX_SAMPLER_MIP_SHIFT]; + desc.lodMinClamp = 0; + desc.lodMaxClamp = FLT_MAX; + desc.normalizedCoordinates = TRUE; + desc.maxAnisotropy = (0 != (_flags & (BGFX_SAMPLER_MIN_ANISOTROPIC|BGFX_SAMPLER_MAG_ANISOTROPIC) ) ) ? m_mainFrameBuffer.m_swapChain->m_maxAnisotropy : 1 ; @@ -2685,13 +2633,13 @@ SamplerState getSamplerState(uint32_t _flags) if (0 != (g_caps.supported & BGFX_CAPS_TEXTURE_COMPARE_ALL) ) { const uint32_t cmpFunc = (_flags&BGFX_SAMPLER_COMPARE_MASK)>>BGFX_SAMPLER_COMPARE_SHIFT; - m_samplerDescriptor.compareFunction = 0 == cmpFunc + desc.compareFunction = 0 == cmpFunc ? MTLCompareFunctionNever : s_cmpFunc[cmpFunc] ; } - sampler = m_device.newSamplerStateWithDescriptor(m_samplerDescriptor); + sampler = m_device.newSamplerStateWithDescriptor(desc); m_samplerStateCache.add(_flags, sampler); } @@ -2723,22 +2671,22 @@ BlitCommandEncoder getBlitCommandEncoder() void endEncoding() { - if (0 != m_renderCommandEncoder) + if (NULL != m_renderCommandEncoder) { m_renderCommandEncoder.endEncoding(); - m_renderCommandEncoder = 0; + m_renderCommandEncoder = NULL; } - if (0 != m_computeCommandEncoder) + if (NULL != m_computeCommandEncoder) { m_computeCommandEncoder.endEncoding(); - m_computeCommandEncoder = 0; + m_computeCommandEncoder = NULL; } - if (0 != m_blitCommandEncoder) + if (NULL != m_blitCommandEncoder) { m_blitCommandEncoder.endEncoding(); - m_blitCommandEncoder = 0; + m_blitCommandEncoder = NULL; } } @@ -2784,7 +2732,7 @@ void endEncoding() typedef stl::vector PipelineProgramArray; - PipelineProgramArray m_pipelineProgram; + PipelineProgramArray m_pipelineProgram; StateCacheT m_pipelineStateCache; StateCacheT m_depthStencilStateCache; @@ -2798,11 +2746,8 @@ void endEncoding() Resolution m_resolution; void* m_capture; uint32_t m_captureSize; -#if BX_PLATFORM_VISIONOS - ar_session_t m_arSession; - ar_world_tracking_provider_t m_worldTracking; - ar_device_anchor_t m_deviceAnchor; -#endif + + bool m_variableRateShadingSupported; // descriptors RenderPipelineDescriptor m_renderPipelineDescriptor; @@ -2810,7 +2755,6 @@ void endEncoding() StencilDescriptor m_frontFaceStencilDescriptor; StencilDescriptor m_backFaceStencilDescriptor; VertexDescriptor m_vertexDescriptor; - TextureDescriptor m_textureDescriptor; SamplerDescriptor m_samplerDescriptor; // currently active objects data @@ -2934,7 +2878,7 @@ void writeString(bx::WriterI* _writer, const char* _str) if (NULL != lib) { m_function = lib.newFunctionWithName(SHADER_FUNCTION_NAME); - release(lib); + MTL_RELEASE_W(lib, 0); } BGFX_FATAL(NULL != m_function @@ -3100,7 +3044,7 @@ void writeString(bx::WriterI* _writer, const char* _str) const bool convert = m_textureFormat != m_requestedFormat; const uint8_t bpp = bimg::getBitsPerPixel(bimg::TextureFormat::Enum(m_textureFormat) ); - TextureDescriptor desc = s_renderMtl->m_textureDescriptor; + TextureDescriptor desc = newTextureDescriptor(); if (1 < ti.numLayers) { @@ -3158,17 +3102,17 @@ void writeString(bx::WriterI* _writer, const char* _str) const TextureFormatInfo& tfi = s_textureFormat[m_textureFormat]; - MTLPixelFormat format = MTLPixelFormatInvalid; + MTLPixelFormat format = kMtlPixelFormatInvalid; if (srgb) { format = tfi.m_fmtSrgb; - BX_WARN(format != MTLPixelFormatInvalid + BX_WARN(format != kMtlPixelFormatInvalid , "sRGB not supported for texture format %d" , m_textureFormat ); } - if (format == MTLPixelFormatInvalid) + if (format == kMtlPixelFormatInvalid) { // not swizzled and not sRGB, or sRGB unsupported format = tfi.m_fmt; @@ -3224,12 +3168,14 @@ void writeString(bx::WriterI* _writer, const char* _str) } if (m_requestedFormat == TextureFormat::D24S8 - && desc.pixelFormat == MTLPixelFormatDepth32Float) + && desc.pixelFormat == kMtlPixelFormatDepth32Float) { - desc.pixelFormat = MTLPixelFormatStencil8; + desc.pixelFormat = kMtlPixelFormatStencil8; m_ptrStencil = s_renderMtl->m_device.newTextureWithDescriptor(desc); } + MTL_RELEASE(desc, 0); + uint8_t* temp = NULL; if (convert) { @@ -3371,7 +3317,7 @@ void writeString(bx::WriterI* _writer, const char* _str) { BlitCommandEncoder bce = s_renderMtl->getBlitCommandEncoder(); - TextureDescriptor desc = s_renderMtl->m_textureDescriptor; + TextureDescriptor desc = newTextureDescriptor(); desc.textureType = _depth > 1 ? MTLTextureType3D : MTLTextureType2D; desc.pixelFormat = m_ptr.pixelFormat(); desc.width = _rect.m_width; @@ -3392,15 +3338,29 @@ void writeString(bx::WriterI* _writer, const char* _str) } Texture tempTexture = s_renderMtl->m_device.newTextureWithDescriptor(desc); + MTLRegion region = { { 0, 0, 0 }, { _rect.m_width, _rect.m_height, _depth }, }; + tempTexture.replaceRegion(region, 0, 0, data, srcpitch, srcpitch * _rect.m_height); - bce.copyFromTexture(tempTexture, 0, 0, MTLOriginMake(0,0,0), MTLSizeMake(_rect.m_width, _rect.m_height, _depth), - m_ptr, slice, _mip, MTLOriginMake(_rect.m_x, _rect.m_y, zz) ); - release(tempTexture); + + bce.copyFromTexture( + tempTexture + , 0 + , 0 + , MTLOriginMake(0,0,0) + , MTLSizeMake(_rect.m_width, _rect.m_height, _depth) + , m_ptr + , slice + , _mip + , MTLOriginMake(_rect.m_x, _rect.m_y, zz) + ); + + MTL_RELEASE(desc, 0); + MTL_RELEASE(tempTexture, 1); } if (NULL != temp) @@ -3436,11 +3396,11 @@ void writeString(bx::WriterI* _writer, const char* _str) } } - Texture TextureMtl::getTextureMipLevel(int _mip) + Texture TextureMtl::getTextureMipLevel(uint8_t _mip) { - if (_mip >= 0 - && _mip < m_numMips - && NULL != m_ptr) + _mip = bx::clamp(_mip, 0, m_numMips); + + if (NULL != m_ptr) { if (NULL == m_ptrMips[_mip]) { @@ -3449,8 +3409,8 @@ void writeString(bx::WriterI* _writer, const char* _str) m_ptrMips[_mip] = m_ptr.newTextureViewWithPixelFormat( m_ptr.pixelFormat() , MTLTextureType2DArray - , NSMakeRange(_mip,1) - , NSMakeRange(0,m_ptr.arrayLength() * 6) + , NSMakeRange(_mip, 1) + , NSMakeRange(0, m_ptr.arrayLength() * 6) ); } else @@ -3458,8 +3418,8 @@ void writeString(bx::WriterI* _writer, const char* _str) m_ptrMips[_mip] = m_ptr.newTextureViewWithPixelFormat( m_ptr.pixelFormat() , m_ptr.textureType() - , NSMakeRange(_mip,1) - , NSMakeRange(0,m_ptr.arrayLength() ) + , NSMakeRange(_mip, 1) + , NSMakeRange(0, m_ptr.arrayLength() ) ); } } @@ -3467,58 +3427,24 @@ void writeString(bx::WriterI* _writer, const char* _str) return m_ptrMips[_mip]; } - return 0; + return NULL; } SwapChainMtl::~SwapChainMtl() { -#if BX_PLATFORM_VISIONOS - MTL_RELEASE(m_layerRenderer); -#else - MTL_RELEASE(m_metalLayer); - MTL_RELEASE(m_drawable); -#endif // BX_PLATFORM_VISIONOS - - MTL_RELEASE(m_drawableTexture); + MTL_RELEASE(m_metalLayer, 2); + MTL_RELEASE(m_drawable, 0); - MTL_RELEASE(m_backBufferDepth); - MTL_RELEASE(m_backBufferStencil); - - if (NULL != m_backBufferColorMsaa) - { - MTL_RELEASE(m_backBufferColorMsaa); - } + MTL_RELEASE(m_drawableTexture, 0); + releaseBackBuffer(); } void SwapChainMtl::init(void* _nwh) { -#if BX_PLATFORM_VISIONOS - NSObject* nvh = (NSObject*)_nwh; - m_useLayerRenderer = ![nvh isKindOfClass:[CAMetalLayer class]]; - if (m_useLayerRenderer) - { - cp_layer_renderer_t layerRenderer = (cp_layer_renderer_t)_nwh; - m_layerRenderer = layerRenderer; - m_layerRendererConfiguration = cp_layer_renderer_get_configuration(m_layerRenderer); - - if (cp_layer_renderer_configuration_get_layout(m_layerRendererConfiguration) == cp_layer_renderer_layout_dedicated) - { - BX_WARN(false, "Dedicated layer renderer layout is not supported."); - } - - retain(m_layerRendererConfiguration); - retain(m_layerRenderer); - } - else -#endif // BX_PLATFORM_VISIONOS { - if (m_metalLayer) - { - release(m_metalLayer); - } + MTL_RELEASE(m_metalLayer, 2); -#if !BX_PLATFORM_VISIONOS if (NULL != NSClassFromString(@"MTKView") ) { MTKView *view = (MTKView *)_nwh; @@ -3529,7 +3455,6 @@ void writeString(bx::WriterI* _writer, const char* _str) m_metalLayer = (CAMetalLayer *)view.layer; } } -#endif if (NULL != NSClassFromString(@"CAMetalLayer") ) { @@ -3538,7 +3463,7 @@ void writeString(bx::WriterI* _writer, const char* _str) { CAMetalLayer* metalLayer = (CAMetalLayer*)_nwh; if (NULL == metalLayer - || ![metalLayer isKindOfClass:NSClassFromString(@"CAMetalLayer")]) + || ![metalLayer isKindOfClass:NSClassFromString(@"CAMetalLayer")]) { BX_WARN(false, "Unable to create Metal device. Please set platform data window to a CAMetalLayer"); return; @@ -3573,15 +3498,17 @@ void writeString(bx::WriterI* _writer, const char* _str) return; } - void (^setLayer)(void) = ^{ + void (^setLayer)(void) = + ^{ CALayer* layer = contentView.layer; + if(NULL != layer && [layer isKindOfClass:NSClassFromString(@"CAMetalLayer")]) { m_metalLayer = (CAMetalLayer*)layer; } else { - [contentView setWantsLayer:YES]; + [contentView setWantsLayer: YES]; m_metalLayer = [CAMetalLayer layer]; [contentView setLayer:m_metalLayer]; } @@ -3596,12 +3523,12 @@ void writeString(bx::WriterI* _writer, const char* _str) bx::Semaphore semaphore; bx::Semaphore* psemaphore = &semaphore; - CFRunLoopPerformBlock([[NSRunLoop mainRunLoop] getCFRunLoop], - kCFRunLoopCommonModes, - ^{ + CFRunLoopPerformBlock([[NSRunLoop mainRunLoop] getCFRunLoop], kCFRunLoopCommonModes, + ^{ setLayer(); psemaphore->post(); }); + semaphore.wait(); } } @@ -3615,30 +3542,58 @@ void writeString(bx::WriterI* _writer, const char* _str) return; } - m_metalLayer.device = s_renderMtl->m_device; - m_metalLayer.pixelFormat = MTLPixelFormatBGRA8Unorm; + m_metalLayer.device = s_renderMtl->m_device; m_metalLayer.magnificationFilter = kCAFilterNearest; + + const Resolution& resolution = s_renderMtl->m_resolution; + m_metalLayer.pixelFormat = (resolution.reset & BGFX_RESET_SRGB_BACKBUFFER) + ? s_textureFormat[resolution.formatColor].m_fmtSrgb + : s_textureFormat[resolution.formatColor].m_fmt + ; + retain(m_metalLayer); } m_nwh = _nwh; } - void SwapChainMtl::resize(FrameBufferMtl &_frameBuffer, uint32_t _width, uint32_t _height, uint32_t _flags, uint32_t _maximumDrawableCount) + void SwapChainMtl::releaseBackBuffer() { - const int32_t sampleCount = s_msaa[(_flags&BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT]; + MTL_RELEASE(m_backBufferStencil, m_backBufferDepth == m_backBufferStencil ? 1 : 0); + MTL_RELEASE_W(m_backBufferDepth, 0); + MTL_RELEASE_W(m_backBufferColorMsaa, 0); + } + + uint32_t SwapChainMtl::resize(uint32_t _width, uint32_t _height, TextureFormat::Enum _format, TextureFormat::Enum _depthFormat) + { + releaseBackBuffer(); + + const Resolution& resolution = s_renderMtl->m_resolution; + + const uint32_t resetFlags = resolution.reset; + const uint32_t maxFrameLatency = resolution.maxFrameLatency; + const TextureFormat::Enum formatColor = TextureFormat::Count == _format + ? resolution.formatColor + : _format + ; + const TextureFormat::Enum formatDepthStencil = TextureFormat::Count == _depthFormat + ? resolution.formatDepthStencil + : _depthFormat + ; + + const int32_t sampleCount = s_msaa[(resetFlags & BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT]; #if BX_PLATFORM_OSX # if __MAC_OS_X_VERSION_MAX_ALLOWED >= 101300 if (s_renderMtl->m_hasVSync) { - m_metalLayer.displaySyncEnabled = 0 != (_flags&BGFX_RESET_VSYNC); + m_metalLayer.displaySyncEnabled = !!(resetFlags & BGFX_RESET_VSYNC); } if (s_renderMtl->m_hasMaximumDrawableCount) { m_metalLayer.maximumDrawableCount = bx::clamp( - _maximumDrawableCount != 0 ? _maximumDrawableCount : BGFX_CONFIG_MAX_FRAME_LATENCY + maxFrameLatency != 0 ? maxFrameLatency : BGFX_CONFIG_MAX_FRAME_LATENCY , 2 , 3 ); @@ -3646,29 +3601,20 @@ void writeString(bx::WriterI* _writer, const char* _str) # endif // __MAC_OS_X_VERSION_MAX_ALLOWED >= 101300 #endif // BX_PLATFORM_OSX -#if BX_PLATFORM_VISIONOS - if (!m_useLayerRenderer) -#endif // BX_PLATFORM_VISIONOS { m_metalLayer.drawableSize = CGSizeMake(_width, _height); - m_metalLayer.pixelFormat = (_flags & BGFX_RESET_SRGB_BACKBUFFER) - ? MTLPixelFormatBGRA8Unorm_sRGB - : MTLPixelFormatBGRA8Unorm - ; + m_metalLayer.pixelFormat = (resetFlags & BGFX_RESET_SRGB_BACKBUFFER) + ? s_textureFormat[formatColor].m_fmtSrgb + : s_textureFormat[formatColor].m_fmt + ; } - TextureDescriptor desc = s_renderMtl->m_textureDescriptor; - - desc.textureType = sampleCount > 1 ? MTLTextureType2DMultisample : MTLTextureType2D; + TextureDescriptor desc = newTextureDescriptor(); - if (s_renderMtl->m_hasPixelFormatDepth32Float_Stencil8) - { - desc.pixelFormat = MTLPixelFormatDepth32Float_Stencil8; - } - else - { - desc.pixelFormat = MTLPixelFormatDepth32Float; - } + desc.textureType = sampleCount > 1 + ? MTLTextureType2DMultisample + : MTLTextureType2D + ; desc.width = _width; desc.height = _height; @@ -3685,115 +3631,60 @@ void writeString(bx::WriterI* _writer, const char* _str) desc.usage = MTLTextureUsageRenderTarget; } - if (NULL != m_backBufferDepth) + if (bimg::isDepth(bimg::TextureFormat::Enum(formatDepthStencil) ) ) { - release(m_backBufferDepth); - } + const MTLPixelFormat depthFormat = s_textureFormat[formatDepthStencil].m_fmt; -#if BX_PLATFORM_VISIONOS - if (m_useLayerRenderer) - { - if (m_layerRendererDrawable) { - m_backBufferDepth = cp_drawable_get_depth_texture(m_layerRendererDrawable, 0); + desc.pixelFormat = depthFormat; + m_backBufferDepth = s_renderMtl->m_device.newTextureWithDescriptor(desc); } - } - else -#endif // BX_PLATFORM_VISIONOS - { - m_backBufferDepth = s_renderMtl->m_device.newTextureWithDescriptor(desc); - } - if (NULL != m_backBufferStencil) - { - release(m_backBufferStencil); - } - if (s_renderMtl->m_hasPixelFormatDepth32Float_Stencil8) - { - m_backBufferStencil = m_backBufferDepth; - retain(m_backBufferStencil); - } - else - { - desc.pixelFormat = MTLPixelFormatStencil8; - m_backBufferStencil = s_renderMtl->m_device.newTextureWithDescriptor(desc); - } - - if (NULL != m_backBufferColorMsaa) - { - release(m_backBufferColorMsaa); - m_backBufferColorMsaa = NULL; - } - - if (sampleCount > 1) - { -#if BX_PLATFORM_VISIONOS - if (m_useLayerRenderer) + if (kMtlPixelFormatDepth24Unorm_Stencil8 == depthFormat + || kMtlPixelFormatDepth32Float_Stencil8 == depthFormat) { - desc.pixelFormat = MTLPixelFormatBGRA8Unorm_sRGB; + m_backBufferDepth.setLabel("SwapChain BackBuffer Depth/Stencil"); + + m_backBufferStencil = m_backBufferDepth; + retain(m_backBufferStencil); } else -#endif // BX_PLATFORM_VISIONOS { - desc.pixelFormat = m_metalLayer.pixelFormat; + m_backBufferDepth.setLabel("SwapChain BackBuffer Depth"); + + desc.pixelFormat = kMtlPixelFormatStencil8; + + m_backBufferStencil = s_renderMtl->m_device.newTextureWithDescriptor(desc); + m_backBufferStencil.setLabel("SwapChain BackBuffer Stencil"); } + } + + if (sampleCount > 1) + { + desc.pixelFormat = m_metalLayer.pixelFormat; m_backBufferColorMsaa = s_renderMtl->m_device.newTextureWithDescriptor(desc); + m_backBufferColorMsaa.setLabel("SwapChain BackBuffer Color MSAA"); } + MTL_RELEASE(desc, 0); + bx::HashMurmur2A murmur; murmur.begin(); murmur.add(1); -#if BX_PLATFORM_VISIONOS - if (!m_useLayerRenderer) -#endif // !BX_PLATFORM_VISIONOS - { - murmur.add( (uint32_t)m_metalLayer.pixelFormat); - } - murmur.add( (uint32_t)m_backBufferDepth.pixelFormat() ); - murmur.add( (uint32_t)m_backBufferStencil.pixelFormat() ); - murmur.add( (uint32_t)sampleCount); - _frameBuffer.m_pixelFormatHash = murmur.end(); + murmur.add(m_metalLayer.pixelFormat); + murmur.add(formatColor); + murmur.add(formatDepthStencil); + murmur.add(sampleCount); + + return murmur.end(); } - id SwapChainMtl::currentDrawableTexture() + id SwapChainMtl::currentDrawableTexture() { if (NULL == m_drawableTexture) { -#if BX_PLATFORM_VISIONOS - if (m_useLayerRenderer) - { - m_frame = cp_layer_renderer_query_next_frame(m_layerRenderer); - if (m_frame) - { - cp_frame_timing_t timing = cp_frame_predict_timing(m_frame); - if (timing == nullptr) { return nullptr; } - - cp_frame_start_update(m_frame); - - cp_frame_end_update(m_frame); - - cp_time_wait_until(cp_frame_timing_get_optimal_input_time(timing)); - cp_frame_start_submission(m_frame); - m_layerRendererDrawable = cp_frame_query_drawable(m_frame); - } - } - else -#endif // BX_PLATFORM_VISIONOS - { - m_drawable = m_metalLayer.nextDrawable; - } + m_drawable = m_metalLayer.nextDrawable; -#if BX_PLATFORM_VISIONOS - if (m_useLayerRenderer) - { - if (m_layerRendererDrawable != NULL) - { - m_drawableTexture = cp_drawable_get_color_texture(m_layerRendererDrawable, 0); - retain(m_drawableTexture); - } - } - else -#endif // BX_PLATFORM_VISIONOS if (m_drawable != NULL) { m_drawableTexture = m_drawable.texture; @@ -3802,21 +3693,12 @@ void writeString(bx::WriterI* _writer, const char* _str) } else { - TextureDescriptor desc = s_renderMtl->m_textureDescriptor; + TextureDescriptor desc = newTextureDescriptor(); desc.textureType = MTLTextureType2D; -#if BX_PLATFORM_VISIONOS - if (m_useLayerRenderer) - { - desc.pixelFormat = MTLPixelFormatBGRA8Unorm_sRGB; - } - else -#endif // BX_PLATFORM_VISIONOS - { - desc.pixelFormat = m_metalLayer.pixelFormat; - desc.width = m_metalLayer.drawableSize.width; - desc.height = m_metalLayer.drawableSize.height; - } + desc.pixelFormat = m_metalLayer.pixelFormat; + desc.width = m_metalLayer.drawableSize.width; + desc.height = m_metalLayer.drawableSize.height; desc.depth = 1; desc.mipmapLevelCount = 1; @@ -3835,6 +3717,8 @@ void writeString(bx::WriterI* _writer, const char* _str) } m_drawableTexture = s_renderMtl->m_device.newTextureWithDescriptor(desc); + MTL_CHECK_REFCOUNT(m_drawableTexture, 1); + MTL_RELEASE(desc, 0); } } @@ -3890,16 +3774,16 @@ void writeString(bx::WriterI* _writer, const char* _str) if (!isValid(m_depthHandle) ) { - murmur.add(uint32_t(MTLPixelFormatInvalid) ); - murmur.add(uint32_t(MTLPixelFormatInvalid) ); + murmur.add(uint32_t(kMtlPixelFormatInvalid) ); + murmur.add(uint32_t(kMtlPixelFormatInvalid) ); } else { const TextureMtl& depthTexture = s_renderMtl->m_textures[m_depthHandle.idx]; murmur.add(uint32_t(depthTexture.m_ptr.pixelFormat() ) ); murmur.add(NULL != depthTexture.m_ptrStencil - ? uint32_t(depthTexture.m_ptrStencil.pixelFormat() ) - : uint32_t(MTLPixelFormatInvalid) + ? depthTexture.m_ptrStencil.pixelFormat() + : kMtlPixelFormatInvalid ); } @@ -3915,13 +3799,14 @@ void writeString(bx::WriterI* _writer, const char* _str) { BX_UNUSED(_format, _depthFormat); m_swapChain = BX_NEW(g_allocator, SwapChainMtl); - m_num = 0; + m_num = 0; m_width = _width; m_height = _height; m_nwh = _nwh; m_denseIdx = _denseIdx; m_swapChain->init(_nwh); + resizeSwapChain(_width, _height, _format, _depthFormat); } void FrameBufferMtl::postReset() @@ -3938,7 +3823,7 @@ void writeString(bx::WriterI* _writer, const char* _str) m_num = 0; m_nwh = NULL; - m_depthHandle.idx = kInvalidHandle; + m_depthHandle = BGFX_INVALID_HANDLE; uint16_t denseIdx = m_denseIdx; m_denseIdx = UINT16_MAX; @@ -3950,7 +3835,7 @@ void writeString(bx::WriterI* _writer, const char* _str) { for (uint32_t ii = 0; ii < m_num; ++ii) { - if (0 != (m_colorAttachment[ii].resolve & BGFX_RESOLVE_AUTO_GEN_MIPS)) + if (0 != (m_colorAttachment[ii].resolve & BGFX_RESOLVE_AUTO_GEN_MIPS) ) { const TextureMtl& texture = s_renderMtl->m_textures[m_colorHandle[ii].idx]; const bool isRenderTarget = !!(texture.m_flags & BGFX_TEXTURE_RT_MASK); @@ -3970,6 +3855,11 @@ void writeString(bx::WriterI* _writer, const char* _str) s_renderMtl->endEncoding(); } + void FrameBufferMtl::resizeSwapChain(uint32_t _width, uint32_t _height, TextureFormat::Enum _format, TextureFormat::Enum _depthFormat) + { + m_pixelFormatHash = m_swapChain->resize(_width, _height, _format, _depthFormat); + } + void CommandQueueMtl::init(Device _device) { m_commandQueue = _device.newCommandQueue(); @@ -3979,7 +3869,7 @@ void writeString(bx::WriterI* _writer, const char* _str) void CommandQueueMtl::shutdown() { finish(true); - MTL_RELEASE(m_commandQueue); + MTL_RELEASE_W(m_commandQueue, 0); } CommandBuffer CommandQueueMtl::alloc() @@ -4016,7 +3906,7 @@ inline void commandBufferFinishedCallback(void* _data) m_activeCommandBuffer.waitUntilCompleted(); } - MTL_RELEASE(m_activeCommandBuffer); + MTL_RELEASE_I(m_activeCommandBuffer); } } @@ -4056,7 +3946,7 @@ inline void commandBufferFinishedCallback(void* _data) for (ResourceArray::iterator it = ra.begin(), itEnd = ra.end(); it != itEnd; ++it) { - bgfx::mtl::release(*it); + MTL_RELEASE_I(*it); } ra.clear(); @@ -4121,7 +4011,7 @@ static void setTimestamp(void* _data) void OcclusionQueryMTL::postReset() { - MTL_RELEASE(m_buffer); + MTL_RELEASE_W(m_buffer, 0); } void OcclusionQueryMTL::preReset() @@ -4201,7 +4091,7 @@ static void setTimestamp(void* _data) const TextureMtl& dst = m_textures[blit.m_dst.idx]; #if BX_PLATFORM_OSX - bool readBack = !!(dst.m_flags & BGFX_TEXTURE_READ_BACK); + const bool readBack = !!(dst.m_flags & BGFX_TEXTURE_READ_BACK); #endif // BX_PLATFORM_OSX if (MTLTextureType3D == src.m_ptr.textureType() ) @@ -4253,6 +4143,16 @@ static void setTimestamp(void* _data) } } + void RendererContextMtl::submitUniformCache(UniformCacheState& _ucs, uint16_t _view) + { + while (_ucs.hasItem(_view) ) + { + const UniformCacheItem& uci = _ucs.advance(); + + bx::memCopy(m_uniforms[uci.m_handle], &_ucs.m_frame->m_uniformCacheFrame.m_data[uci.m_offset], uci.m_size); + } + } + void RendererContextMtl::submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter) { m_cmd.finish(false); @@ -4262,6 +4162,22 @@ static void setTimestamp(void* _data) m_commandBuffer = m_cmd.alloc(); } + if (_render->m_capture) + { + CaptureManager captureMgr = getSharedCaptureManager(); + CaptureDescriptor captureDesc = newCaptureDescriptor(); + captureDesc.captureObject = m_device; + captureDesc.destination = MTLCaptureDestinationDeveloperTools; + + NSError* err = NULL; + [captureMgr startCaptureWithDescriptor: captureDesc error: &err]; + + if (NULL != err) + { + BX_TRACE("Failed to start capture. Error %d: %s", err.code, err.localizedDescription.UTF8String); + } + } + BGFX_MTL_PROFILER_BEGIN_LITERAL("rendererSubmit", kColorFrame); int64_t timeBegin = bx::getHPCounter(); @@ -4285,41 +4201,44 @@ static void setTimestamp(void* _data) if (m_screenshotTarget.width() != m_resolution.width || m_screenshotTarget.height() != m_resolution.height) { - MTL_RELEASE(m_screenshotTarget); + MTL_RELEASE(m_screenshotTarget, 0); } } if (NULL == m_screenshotTarget) { - m_textureDescriptor.textureType = MTLTextureType2D; - m_textureDescriptor.pixelFormat = getSwapChainPixelFormat(m_mainFrameBuffer.m_swapChain); - m_textureDescriptor.width = m_resolution.width; - m_textureDescriptor.height = m_resolution.height; - m_textureDescriptor.depth = 1; - m_textureDescriptor.mipmapLevelCount = 1; - m_textureDescriptor.sampleCount = 1; - m_textureDescriptor.arrayLength = 1; + TextureDescriptor desc = newTextureDescriptor(); + + desc.textureType = MTLTextureType2D; + desc.pixelFormat = getSwapChainPixelFormat(m_mainFrameBuffer.m_swapChain); + desc.width = m_resolution.width; + desc.height = m_resolution.height; + desc.depth = 1; + desc.mipmapLevelCount = 1; + desc.sampleCount = 1; + desc.arrayLength = 1; if (s_renderMtl->m_hasCPUCacheModesAndStorageModes) { - m_textureDescriptor.cpuCacheMode = MTLCPUCacheModeDefaultCache; - m_textureDescriptor.storageMode = BX_ENABLED(BX_PLATFORM_IOS) || BX_ENABLED(BX_PLATFORM_VISIONOS) + desc.cpuCacheMode = MTLCPUCacheModeDefaultCache; + desc.storageMode = BX_ENABLED(BX_PLATFORM_IOS) || BX_ENABLED(BX_PLATFORM_VISIONOS) ? (MTLStorageMode)0 // MTLStorageModeShared : (MTLStorageMode)1 // MTLStorageModeManaged ; - m_textureDescriptor.usage = 0 + desc.usage = 0 | MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead ; } - m_screenshotTarget = m_device.newTextureWithDescriptor(m_textureDescriptor); + m_screenshotTarget = m_device.newTextureWithDescriptor(desc); + MTL_RELEASE(desc, 0); } } else { - MTL_RELEASE(m_screenshotTarget); + MTL_RELEASE(m_screenshotTarget, 0); } m_uniformBuffer = m_uniformBuffers[m_bufferIndex]; @@ -4362,6 +4281,7 @@ static void setTimestamp(void* _data) uint16_t view = UINT16_MAX; FrameBufferHandle fbh = { BGFX_CONFIG_MAX_FRAME_BUFFERS }; + UniformCacheState ucs(_render); BlitState bs(_render); const uint64_t primType = 0; @@ -4433,6 +4353,7 @@ static void setTimestamp(void* _data) viewState.m_rect = _render->m_view[view].m_rect; + submitUniformCache(ucs, view); submitBlit(bs, view); if (!isCompute) @@ -4442,7 +4363,7 @@ static void setTimestamp(void* _data) viewScissorRect = viewHasScissor ? scissorRect : viewState.m_rect; Clear& clr = _render->m_view[view].m_clear; - Rect viewRect = viewState.m_rect; + const Rect viewRect = viewState.m_rect; bool clearWithRenderPass = false; if (NULL == m_renderCommandEncoder @@ -4594,10 +4515,24 @@ static void setTimestamp(void* _data) } } + if (m_variableRateShadingSupported) + { + RasterizationRateLayerDescriptor rrld = newRasterizationRateLayerDescriptor(s_shadingRate[_render->m_view[view].m_shadingRate]); + RasterizationRateMapDescriptor rrmd = newRasterizationRateMapDescriptor(); + rrmd.screenSize = MTLSizeMake(viewRect.m_width, viewRect.m_height, 0); + [rrmd + setLayer: rrld + atIndex: 0 + ]; + + renderPassDescriptor.rasterizationRateMap = m_device.newRasterizationRateMapWithDescriptor(rrmd); + } + rce = m_commandBuffer.renderCommandEncoderWithDescriptor(renderPassDescriptor); m_renderCommandEncoder = rce; m_renderCommandEncoderFrameBufferHandle = fbh; - MTL_RELEASE(renderPassDescriptor); + + MTL_RELEASE(renderPassDescriptor, 0); } else if (BX_ENABLED(BGFX_CONFIG_DEBUG_ANNOTATION) ) { @@ -4611,19 +4546,6 @@ static void setTimestamp(void* _data) rce.setTriangleFillMode(wireframe ? MTLTriangleFillModeLines : MTLTriangleFillModeFill); -#if BX_PLATFORM_VISIONOS - if (m_mainFrameBuffer.m_swapChain->m_useLayerRenderer) - { - if (cp_layer_renderer_configuration_get_layout(m_mainFrameBuffer.m_swapChain->m_layerRendererConfiguration) == cp_layer_renderer_layout_layered) - { - MTLViewport viewports[2]; - calculateViewPorts(viewports); - rce.setViewports(viewports, 1); - setVertexAmplification(rce); - } - } - else -#endif // BX_PLATFORM_VISIONOS { MTLViewport vp; vp.originX = viewState.m_rect.m_x; @@ -4681,7 +4603,6 @@ static void setTimestamp(void* _data) const RenderCompute& compute = renderItem.compute; - bool programChanged = false; rendererUpdateUniforms(this, _render->m_uniformBuffer[compute.m_uniformIdx], compute.m_uniformBegin, compute.m_uniformEnd); if (key.m_program.idx != currentProgram.idx) @@ -4697,7 +4618,6 @@ static void setTimestamp(void* _data) } m_computeCommandEncoder.setComputePipelineState(currentPso->m_cps); - programChanged = true; } if (isValid(currentProgram) @@ -4724,7 +4644,6 @@ static void setTimestamp(void* _data) m_uniformBufferVertexOffset += vertexUniformBufferSize; } - BX_UNUSED(programChanged); for (uint8_t stage = 0; stage < maxComputeBindings; ++stage) { @@ -5128,40 +5047,41 @@ static void setTimestamp(void* _data) switch (bind.m_type) { case Binding::Image: - { - if (bind.m_access == Access::ReadWrite && 0 == (g_caps.supported & BGFX_CAPS_IMAGE_RW)) { - BGFX_FATAL( - false - , Fatal::DebugCheck - , "Failed to set image with access: Access::ReadWrite, device is not support image read&write" - ); - } + if (bind.m_access == Access::ReadWrite && 0 == (g_caps.supported & BGFX_CAPS_IMAGE_RW) ) + { + BGFX_FATAL( + false + , Fatal::DebugCheck + , "Failed to set image with access: Access::ReadWrite, device is not support image read&write" + ); + } - if ( (bind.m_access == Access::Read && (0 == (g_caps.formats[bind.m_format] & BGFX_CAPS_FORMAT_TEXTURE_IMAGE_READ) ) ) - || (bind.m_access == Access::Write && (0 == (g_caps.formats[bind.m_format] & BGFX_CAPS_FORMAT_TEXTURE_IMAGE_WRITE) ) ) - || (bind.m_access == Access::ReadWrite && (0 == (g_caps.formats[bind.m_format] & (BGFX_CAPS_FORMAT_TEXTURE_IMAGE_READ|BGFX_CAPS_FORMAT_TEXTURE_IMAGE_WRITE) ) ) ) - ) - { - BGFX_FATAL( - false - , Fatal::DebugCheck - , "Failed to set image with access: %s, format:%s is not supported" - , s_accessNames[bind.m_access] - , bimg::getName(bimg::TextureFormat::Enum(bind.m_format) ) + if ( (bind.m_access == Access::Read && (0 == (g_caps.formats[bind.m_format] & BGFX_CAPS_FORMAT_TEXTURE_IMAGE_READ) ) ) + || (bind.m_access == Access::Write && (0 == (g_caps.formats[bind.m_format] & BGFX_CAPS_FORMAT_TEXTURE_IMAGE_WRITE) ) ) + || (bind.m_access == Access::ReadWrite && (0 == (g_caps.formats[bind.m_format] & (BGFX_CAPS_FORMAT_TEXTURE_IMAGE_READ|BGFX_CAPS_FORMAT_TEXTURE_IMAGE_WRITE) ) ) ) + ) + { + BGFX_FATAL( + false + , Fatal::DebugCheck + , "Failed to set image with access: %s, format:%s is not supported" + , s_accessNames[bind.m_access] + , bimg::getName(bimg::TextureFormat::Enum(bind.m_format) ) + ); + } + + TextureMtl& texture = m_textures[bind.m_idx]; + texture.commit( + stage + , 0 != (bindingTypes[stage] & PipelineStateMtl::BindToVertexShader) + , 0 != (bindingTypes[stage] & PipelineStateMtl::BindToFragmentShader) + , bind.m_samplerFlags + , bind.m_mip ); } + break; - TextureMtl& texture = m_textures[bind.m_idx]; - texture.commit( - stage - , 0 != (bindingTypes[stage] & PipelineStateMtl::BindToVertexShader) - , 0 != (bindingTypes[stage] & PipelineStateMtl::BindToFragmentShader) - , bind.m_samplerFlags - , bind.m_mip - ); - } - break; case Binding::Texture: { TextureMtl& texture = m_textures[bind.m_idx]; @@ -5482,7 +5402,17 @@ static void setTimestamp(void* _data) } endEncoding(); - m_renderCommandEncoderFrameBufferHandle.idx = kInvalidHandle; + + m_renderCommandEncoderFrameBufferHandle = BGFX_INVALID_HANDLE; + + if (_render->m_capture) + { + CaptureManager captureMgr = getSharedCaptureManager(); + if ([captureMgr isCapturing]) + { + [captureMgr stopCapture]; + } + } if (m_screenshotTarget) { @@ -5490,9 +5420,9 @@ static void setTimestamp(void* _data) renderPassDescriptor.colorAttachments[0].texture = m_mainFrameBuffer.m_swapChain->currentDrawableTexture(); renderPassDescriptor.colorAttachments[0].storeAction = MTLStoreActionStore; - rce = m_commandBuffer.renderCommandEncoderWithDescriptor(renderPassDescriptor); + rce = m_commandBuffer.renderCommandEncoderWithDescriptor(renderPassDescriptor); - MTL_RELEASE(renderPassDescriptor); + MTL_RELEASE(renderPassDescriptor, 0); rce.setCullMode(MTLCullModeNone); diff --git a/libs/bgfx/src/renderer_noop.cpp b/libs/bgfx/src/renderer_noop.cpp index 285d2f3..ca947a4 100644 --- a/libs/bgfx/src/renderer_noop.cpp +++ b/libs/bgfx/src/renderer_noop.cpp @@ -189,7 +189,7 @@ namespace bgfx { namespace noop { } - void overrideInternal(TextureHandle /*_handle*/, uintptr_t /*_ptr*/) override + void overrideInternal(TextureHandle /*_handle*/, uintptr_t /*_ptr*/, uint16_t /*_layerIndex*/) override { } diff --git a/libs/bgfx/src/renderer_vk.cpp b/libs/bgfx/src/renderer_vk.cpp index 97ba394..63de6f5 100644 --- a/libs/bgfx/src/renderer_vk.cpp +++ b/libs/bgfx/src/renderer_vk.cpp @@ -57,6 +57,24 @@ namespace bgfx { namespace vk { 16, VK_SAMPLE_COUNT_16_BIT }, }; + struct ShadingRateVk + { + VkExtent2D fragmentSize; + const VkExtent2D initFragmentSize; + }; + + static ShadingRateVk s_shadingRate[] = + { + { { 1, 1 }, { 1, 1 } }, + { { 1, 2 }, { 1, 2 } }, + { { 2, 1 }, { 2, 1 } }, + { { 2, 2 }, { 2, 2 } }, + { { 2, 4 }, { 2, 4 } }, + { { 4, 2 }, { 4, 2 } }, + { { 4, 4 }, { 4, 4 } }, + }; + static_assert(ShadingRate::Count == BX_COUNTOF(s_shadingRate) ); + static const VkBlendFactor s_blendFactor[][2] = { { VkBlendFactor(0), VkBlendFactor(0) }, // ignored @@ -178,6 +196,10 @@ VK_IMPORT_DEVICE { VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ETC2 { VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ETC2A { VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, { $_, $_, $_, $_ } }, // ETC2A1 + { VK_FORMAT_EAC_R11_UNORM_BLOCK, VK_FORMAT_EAC_R11_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // EACR11 + { VK_FORMAT_EAC_R11_SNORM_BLOCK, VK_FORMAT_EAC_R11_SNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // EACR11S + { VK_FORMAT_EAC_R11G11_UNORM_BLOCK, VK_FORMAT_EAC_R11G11_UNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // EACRG11 + { VK_FORMAT_EAC_R11G11_SNORM_BLOCK, VK_FORMAT_EAC_R11G11_SNORM_BLOCK, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // EACRG11S { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // PTC12 { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // PTC14 { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // PTC12A @@ -252,7 +274,7 @@ VK_IMPORT_DEVICE { VK_FORMAT_R4G4B4A4_UNORM_PACK16, VK_FORMAT_R4G4B4A4_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $A, $B, $G, $R } }, // RGBA4 { VK_FORMAT_A1R5G5B5_UNORM_PACK16, VK_FORMAT_A1R5G5B5_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // BGR5A1 { VK_FORMAT_A1R5G5B5_UNORM_PACK16, VK_FORMAT_A1R5G5B5_UNORM_PACK16, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $B, $G, $R, $A } }, // RGB5A1 - { VK_FORMAT_A2R10G10B10_UNORM_PACK32, VK_FORMAT_A2R10G10B10_UNORM_PACK32, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $B, $G, $R, $A } }, // RGB10A2 + { VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RGB10A2 { VK_FORMAT_B10G11R11_UFLOAT_PACK32, VK_FORMAT_B10G11R11_UFLOAT_PACK32, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // RG11B10F { VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // UnknownDepth { VK_FORMAT_UNDEFINED, VK_FORMAT_R16_UNORM, VK_FORMAT_D16_UNORM, VK_FORMAT_UNDEFINED, { $_, $_, $_, $_ } }, // D16 @@ -360,6 +382,7 @@ VK_IMPORT_DEVICE EXT_memory_budget, EXT_shader_viewport_index_layer, KHR_draw_indirect_count, + KHR_fragment_shading_rate, KHR_get_physical_device_properties2, # if BX_PLATFORM_ANDROID @@ -399,6 +422,7 @@ VK_IMPORT_DEVICE { "VK_EXT_memory_budget", 1, false, false, true, Layer::Count }, { "VK_EXT_shader_viewport_index_layer", 1, false, false, true, Layer::Count }, { "VK_KHR_draw_indirect_count", 1, false, false, true, Layer::Count }, + { "VK_KHR_fragment_shading_rate", 1, false, false, true, Layer::Count }, { "VK_KHR_get_physical_device_properties2", 1, false, false, true, Layer::Count }, # if BX_PLATFORM_ANDROID { VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, 1, false, false, true, Layer::Count }, @@ -919,7 +943,6 @@ VK_IMPORT_DEVICE template<> VkObjectType getType() { return VK_OBJECT_TYPE_SURFACE_KHR; } template<> VkObjectType getType() { return VK_OBJECT_TYPE_SWAPCHAIN_KHR; } - template static BX_NO_INLINE void setDebugObjectName(VkDevice _device, Ty _object, const char* _format, ...) { @@ -1130,7 +1153,7 @@ VK_IMPORT_DEVICE ); } -#define MAX_DESCRIPTOR_SETS (1024 * BGFX_CONFIG_MAX_FRAME_LATENCY) +#define MAX_DESCRIPTOR_SETS (BGFX_CONFIG_RENDERER_VULKAN_MAX_DESCRIPTOR_SETS_PER_FRAME * BGFX_CONFIG_MAX_FRAME_LATENCY) struct RendererContextVK : public RendererContextI { @@ -1145,6 +1168,7 @@ VK_IMPORT_DEVICE , m_captureBuffer(VK_NULL_HANDLE) , m_captureMemory() , m_captureSize(0) + , m_variableRateShadingSupported(false) { } @@ -1174,13 +1198,12 @@ VK_IMPORT_DEVICE const bool headless = NULL == g_platformData.nwh; const void* nextFeatures = NULL; - VkPhysicalDeviceLineRasterizationFeaturesEXT lineRasterizationFeatures; - VkPhysicalDeviceCustomBorderColorFeaturesEXT customBorderColorFeatures; - bx::memSet(&lineRasterizationFeatures, 0, sizeof(lineRasterizationFeatures) ); - bx::memSet(&customBorderColorFeatures, 0, sizeof(customBorderColorFeatures) ); + VkPhysicalDeviceLineRasterizationFeaturesEXT lineRasterizationFeatures = {}; + VkPhysicalDeviceCustomBorderColorFeaturesEXT customBorderColorFeatures = {}; + VkPhysicalDeviceFragmentShadingRateFeaturesKHR fragmentShadingRate = {}; - m_fbh.idx = kInvalidHandle; + m_fbh = BGFX_INVALID_HANDLE; bx::memSet(m_uniforms, 0, sizeof(m_uniforms) ); bx::memSet(&m_resolution, 0, sizeof(m_resolution) ); @@ -1194,7 +1217,10 @@ VK_IMPORT_DEVICE m_renderDocDll = loadRenderDoc(); } - setGraphicsDebuggerPresent(NULL != m_renderDocDll); + setGraphicsDebuggerPresent(false + || NULL != m_renderDocDll + || NULL != findModule("Nvda.Graphics.Interception.dll") + ); m_vulkan1Dll = bx::dlopen( #if BX_PLATFORM_WINDOWS @@ -1241,9 +1267,10 @@ VK_IMPORT s_extension[Extension::EXT_debug_report].m_initialize = _init.debug; - s_extension[Extension::EXT_shader_viewport_index_layer].m_initialize = !!(_init.capabilities & BGFX_CAPS_VIEWPORT_LAYER_ARRAY); - s_extension[Extension::EXT_conservative_rasterization ].m_initialize = !!(_init.capabilities & BGFX_CAPS_CONSERVATIVE_RASTER ); - s_extension[Extension::KHR_draw_indirect_count ].m_initialize = !!(_init.capabilities & BGFX_CAPS_DRAW_INDIRECT_COUNT ); + s_extension[Extension::EXT_conservative_rasterization ].m_initialize = !!(_init.capabilities & BGFX_CAPS_CONSERVATIVE_RASTER ); + s_extension[Extension::EXT_shader_viewport_index_layer].m_initialize = !!(_init.capabilities & BGFX_CAPS_VIEWPORT_LAYER_ARRAY ); + s_extension[Extension::KHR_draw_indirect_count ].m_initialize = !!(_init.capabilities & BGFX_CAPS_DRAW_INDIRECT_COUNT ); + s_extension[Extension::KHR_fragment_shading_rate ].m_initialize = !!(_init.capabilities & BGFX_CAPS_VARIABLE_RATE_SHADING); dumpExtensions(VK_NULL_HANDLE, s_extension); @@ -1304,7 +1331,7 @@ VK_IMPORT BX_TRACE("\t%s", enabledExtension[ii]); } - uint32_t vulkanApiVersionSelector; + uint32_t vulkanApiVersionSelector = 0; if (NULL != vkEnumerateInstanceVersion) { @@ -1320,10 +1347,8 @@ VK_IMPORT goto error; } } - else - { - vulkanApiVersionSelector = VK_API_VERSION_1_0; - } + + vulkanApiVersionSelector = bx::max(vulkanApiVersionSelector, VK_API_VERSION_1_2); VkApplicationInfo appInfo; appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; @@ -1386,10 +1411,10 @@ VK_IMPORT BX_TRACE("Instance functions:"); -#define VK_IMPORT_INSTANCE_FUNC(_optional, _func) \ - _func = (PFN_##_func)vkGetInstanceProcAddr(m_instance, #_func); \ - BX_TRACE("\t%p " #_func, _func); \ - imported &= _optional || NULL != _func +#define VK_IMPORT_INSTANCE_FUNC(_optional, _func) \ + _func = (PFN_##_func)vkGetInstanceProcAddr(m_instance, #_func); \ + BX_TRACE("\t%p " #_func, _func); \ + imported &= _optional || NULL != _func VK_IMPORT_INSTANCE #undef VK_IMPORT_INSTANCE_FUNC @@ -1455,8 +1480,12 @@ VK_IMPORT_INSTANCE for (uint32_t ii = 0; ii < numPhysicalDevices; ++ii) { - VkPhysicalDeviceProperties pdp; - vkGetPhysicalDeviceProperties(physicalDevices[ii], &pdp); + VkPhysicalDeviceProperties2 pdp2; + pdp2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; + pdp2.pNext = NULL; + vkGetPhysicalDeviceProperties2(physicalDevices[ii], &pdp2); + + VkPhysicalDeviceProperties& pdp = pdp2.properties; BX_TRACE("Physical device %d:", ii); BX_TRACE("\t Name: %s", pdp.deviceName); @@ -1545,11 +1574,19 @@ VK_IMPORT_INSTANCE bx::memCopy(&s_extension[0], &physicalDeviceExtensions[physicalDeviceIdx][0], sizeof(s_extension) ); - vkGetPhysicalDeviceProperties(m_physicalDevice, &m_deviceProperties); - g_caps.vendorId = uint16_t(m_deviceProperties.vendorID); - g_caps.deviceId = uint16_t(m_deviceProperties.deviceID); + m_deviceShadingRateImageProperties = {}; + m_deviceShadingRateImageProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; + + m_deviceProperties = {}; + m_deviceProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; + m_deviceProperties.pNext = &m_deviceShadingRateImageProperties; - BX_TRACE("Using physical device %d: %s", physicalDeviceIdx, m_deviceProperties.deviceName); + vkGetPhysicalDeviceProperties2(m_physicalDevice, &m_deviceProperties); + + g_caps.vendorId = uint16_t(m_deviceProperties.properties.vendorID); + g_caps.deviceId = uint16_t(m_deviceProperties.properties.deviceID); + + BX_TRACE("Using physical device %d: %s", physicalDeviceIdx, m_deviceProperties.properties.deviceName); VkPhysicalDeviceFeatures supportedFeatures; @@ -1587,6 +1624,17 @@ VK_IMPORT_INSTANCE vkGetPhysicalDeviceFeatures(m_physicalDevice, &supportedFeatures); } + if (s_extension[Extension::KHR_fragment_shading_rate].m_supported) + { + fragmentShadingRate.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; + fragmentShadingRate.pNext = (VkBaseOutStructure*)nextFeatures; + fragmentShadingRate.pipelineFragmentShadingRate = VK_TRUE; + fragmentShadingRate.primitiveFragmentShadingRate = VK_TRUE; + fragmentShadingRate.attachmentFragmentShadingRate = VK_FALSE; + + nextFeatures = &fragmentShadingRate; + } + bx::memSet(&m_deviceFeatures, 0, sizeof(m_deviceFeatures) ); m_deviceFeatures.fullDrawIndexUint32 = supportedFeatures.fullDrawIndexUint32; @@ -1619,7 +1667,7 @@ VK_IMPORT_INSTANCE && customBorderColorFeatures.customBorderColors ; - m_timerQuerySupport = m_deviceProperties.limits.timestampComputeAndGraphics; + m_timerQuerySupport = m_deviceProperties.properties.limits.timestampComputeAndGraphics; const bool indirectDrawSupport = true && m_deviceFeatures.multiDrawIndirect @@ -1653,24 +1701,30 @@ VK_IMPORT_INSTANCE | (s_extension[Extension::EXT_conservative_rasterization ].m_supported ? BGFX_CAPS_CONSERVATIVE_RASTER : 0) | (s_extension[Extension::EXT_shader_viewport_index_layer].m_supported ? BGFX_CAPS_VIEWPORT_LAYER_ARRAY : 0) | (s_extension[Extension::KHR_draw_indirect_count ].m_supported && indirectDrawSupport ? BGFX_CAPS_DRAW_INDIRECT_COUNT : 0) + | (s_extension[Extension::KHR_fragment_shading_rate ].m_supported ? BGFX_CAPS_VARIABLE_RATE_SHADING : 0) ; - const uint32_t maxAttachments = bx::min(m_deviceProperties.limits.maxFragmentOutputAttachments, m_deviceProperties.limits.maxColorAttachments); + m_variableRateShadingSupported = s_extension[Extension::KHR_fragment_shading_rate].m_supported; - g_caps.limits.maxTextureSize = m_deviceProperties.limits.maxImageDimension2D; - g_caps.limits.maxTextureLayers = m_deviceProperties.limits.maxImageArrayLayers; + const uint32_t maxAttachments = bx::min( + m_deviceProperties.properties.limits.maxFragmentOutputAttachments + , m_deviceProperties.properties.limits.maxColorAttachments + ); + + g_caps.limits.maxTextureSize = m_deviceProperties.properties.limits.maxImageDimension2D; + g_caps.limits.maxTextureLayers = m_deviceProperties.properties.limits.maxImageArrayLayers; g_caps.limits.maxFBAttachments = bx::min(maxAttachments, BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS); - g_caps.limits.maxTextureSamplers = bx::min(m_deviceProperties.limits.maxPerStageResources, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS); - g_caps.limits.maxComputeBindings = bx::min(m_deviceProperties.limits.maxPerStageResources, BGFX_MAX_COMPUTE_BINDINGS); - g_caps.limits.maxVertexStreams = bx::min(m_deviceProperties.limits.maxVertexInputBindings, BGFX_CONFIG_MAX_VERTEX_STREAMS); + g_caps.limits.maxTextureSamplers = bx::min(m_deviceProperties.properties.limits.maxPerStageResources, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS); + g_caps.limits.maxComputeBindings = bx::min(m_deviceProperties.properties.limits.maxPerStageResources, BGFX_MAX_COMPUTE_BINDINGS); + g_caps.limits.maxVertexStreams = bx::min(m_deviceProperties.properties.limits.maxVertexInputBindings, BGFX_CONFIG_MAX_VERTEX_STREAMS); { const VkSampleCountFlags sampleMask = ~0 - & m_deviceProperties.limits.framebufferColorSampleCounts - & m_deviceProperties.limits.framebufferDepthSampleCounts + & m_deviceProperties.properties.limits.framebufferColorSampleCounts + & m_deviceProperties.properties.limits.framebufferDepthSampleCounts ; - for (uint16_t ii = 0, last = 0; ii < BX_COUNTOF(s_msaa); ii++) + for (uint16_t ii = 0, last = 0; ii < BX_COUNTOF(s_msaa); ++ii) { const VkSampleCountFlags sampleBit = s_msaa[ii].Sample; @@ -1685,6 +1739,17 @@ VK_IMPORT_INSTANCE } } + { + const VkExtent2D maxFragmentSize = m_deviceShadingRateImageProperties.maxFragmentSize; + + for (uint32_t ii = 0; ii < BX_COUNTOF(s_shadingRate); ++ii) + { + ShadingRateVk& shadingRate = s_shadingRate[ii]; + shadingRate.fragmentSize.width = bx::min(shadingRate.initFragmentSize.width, maxFragmentSize.width); + shadingRate.fragmentSize.height = bx::min(shadingRate.initFragmentSize.height, maxFragmentSize.height); + } + } + for (uint32_t ii = 0; ii < TextureFormat::Count; ++ii) { uint16_t support = BGFX_CAPS_FORMAT_TEXTURE_NONE; @@ -1891,10 +1956,10 @@ VK_IMPORT_INSTANCE errorState = ErrorState::DeviceCreated; BX_TRACE("Device functions:"); -#define VK_IMPORT_DEVICE_FUNC(_optional, _func) \ - _func = (PFN_##_func)vkGetDeviceProcAddr(m_device, #_func); \ - BX_TRACE("\t%p " #_func, _func); \ - imported &= _optional || NULL != _func +#define VK_IMPORT_DEVICE_FUNC(_optional, _func) \ + _func = (PFN_##_func)vkGetDeviceProcAddr(m_device, #_func); \ + BX_TRACE("\t%p " #_func, _func); \ + imported &= _optional || NULL != _func VK_IMPORT_DEVICE #undef VK_IMPORT_DEVICE_FUNC @@ -1907,12 +1972,12 @@ VK_IMPORT_DEVICE vkGetDeviceQueue(m_device, m_globalQueueFamily, 0, &m_globalQueue); { - m_numFramesInFlight = _init.resolution.maxFrameLatency == 0 + m_maxFrameLatency = _init.resolution.maxFrameLatency == 0 ? BGFX_CONFIG_MAX_FRAME_LATENCY : _init.resolution.maxFrameLatency ; - result = m_cmd.init(m_globalQueueFamily, m_globalQueue, m_numFramesInFlight); + result = m_cmd.init(m_globalQueueFamily, m_globalQueue); if (VK_SUCCESS != result) { @@ -1949,7 +2014,13 @@ VK_IMPORT_DEVICE m_swapChainFormats[ii] = TextureFormat::Enum(ii); } - result = m_backBuffer.create(UINT16_MAX, g_platformData.nwh, m_resolution.width, m_resolution.height, m_resolution.format); + result = m_backBuffer.create( + UINT16_MAX + , g_platformData.nwh + , m_resolution.width + , m_resolution.height + , m_resolution.formatColor + ); if (VK_SUCCESS != result) { @@ -1984,12 +2055,15 @@ VK_IMPORT_DEVICE dpci.poolSizeCount = BX_COUNTOF(dps); dpci.pPoolSizes = dps; - result = vkCreateDescriptorPool(m_device, &dpci, m_allocatorCb, &m_descriptorPool); - - if (VK_SUCCESS != result) + for (uint32_t ii = 0; ii < m_maxFrameLatency; ++ii) { - BX_TRACE("Init error: vkCreateDescriptorPool failed %d: %s.", result, getName(result) ); - goto error; + result = vkCreateDescriptorPool(m_device, &dpci, m_allocatorCb, &m_descriptorPool[ii]); + + if (VK_SUCCESS != result) + { + BX_TRACE("Init error: vkCreateDescriptorPool failed %d: %s.", result, getName(result) ); + goto error; + } } VkPipelineCacheCreateInfo pcci; @@ -2011,16 +2085,16 @@ VK_IMPORT_DEVICE const uint32_t size = 128; const uint32_t count = BGFX_CONFIG_MAX_DRAW_CALLS; - for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii) + for (uint32_t ii = 0; ii < m_maxFrameLatency; ++ii) { BX_TRACE("Create scratch buffer %d", ii); m_scratchBuffer[ii].createUniform(size, count); } - for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii) + for (uint32_t ii = 0; ii < m_maxFrameLatency; ++ii) { BX_TRACE("Create scratch staging buffer %d", ii); - m_scratchStagingBuffer[ii].createStaging(BGFX_CONFIG_PER_FRAME_SCRATCH_STAGING_BUFFER_SIZE); + m_scratchStagingBuffer[ii].createStaging(BGFX_CONFIG_MAX_SCRATCH_STAGING_BUFFER_PER_FRAME_SIZE); } } @@ -2085,13 +2159,13 @@ VK_IMPORT_DEVICE [[fallthrough]]; case ErrorState::DescriptorCreated: - for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii) + for (uint32_t ii = 0; ii < m_maxFrameLatency; ++ii) { m_scratchBuffer[ii].destroy(); m_scratchStagingBuffer[ii].destroy(); + vkDestroy(m_descriptorPool[ii]); } vkDestroy(m_pipelineCache); - vkDestroy(m_descriptorPool); [[fallthrough]]; case ErrorState::SwapChainCreated: @@ -2148,12 +2222,12 @@ VK_IMPORT_DEVICE m_samplerBorderColorCache.invalidate(); m_imageViewCache.invalidate(); - for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii) + for (uint32_t ii = 0; ii < m_maxFrameLatency; ++ii) { m_scratchBuffer[ii].destroy(); } - for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii) + for (uint32_t ii = 0; ii < m_maxFrameLatency; ++ii) { m_scratchStagingBuffer[ii].destroy(); } @@ -2190,7 +2264,11 @@ VK_IMPORT_DEVICE m_cmd.shutdown(); vkDestroy(m_pipelineCache); - vkDestroy(m_descriptorPool); + + for (uint32_t ii = 0; ii < m_maxFrameLatency; ++ii) + { + vkDestroy(m_descriptorPool[ii]); + } vkDestroyDevice(m_device, m_allocatorCb); @@ -2357,7 +2435,7 @@ VK_IMPORT_DEVICE m_commandBuffer , stagingBuffer , texture.m_currentImageLayout - , texture.m_aspectMask + , texture.m_aspectFlags , _mip ); @@ -2380,8 +2458,7 @@ VK_IMPORT_DEVICE const Memory* mem = alloc(size); bx::StaticMemoryBlockWriter writer(mem->data, mem->size); - uint32_t magic = BGFX_CHUNK_MAGIC_TEX; - bx::write(&writer, magic, bx::ErrorAssert{}); + bx::write(&writer, kChunkMagicTex, bx::ErrorAssert{}); TextureCreate tc; tc.m_width = _width; @@ -2400,7 +2477,7 @@ VK_IMPORT_DEVICE bgfx::release(mem); } - void overrideInternal(TextureHandle /*_handle*/, uintptr_t /*_ptr*/) override + void overrideInternal(TextureHandle /*_handle*/, uintptr_t /*_ptr*/, uint16_t /*_layerIndex*/) override { } @@ -2441,11 +2518,6 @@ VK_IMPORT_DEVICE { FrameBufferVK& frameBuffer = m_frameBuffers[_handle.idx]; - if (_handle.idx == m_fbh.idx) - { - setFrameBuffer(BGFX_INVALID_HANDLE, false); - } - uint16_t denseIdx = frameBuffer.destroy(); if (UINT16_MAX != denseIdx) { @@ -2554,10 +2626,10 @@ VK_IMPORT_DEVICE dul.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT; dul.pNext = NULL; dul.pLabelName = _marker; - dul.color[0] = ((abgr >> 24) & 0xff) / 255.0f; - dul.color[1] = ((abgr >> 16) & 0xff) / 255.0f; - dul.color[2] = ((abgr >> 8) & 0xff) / 255.0f; - dul.color[3] = ((abgr >> 0) & 0xff) / 255.0f; + dul.color[0] = ( (abgr >> 24) & 0xff) / 255.0f; + dul.color[1] = ( (abgr >> 16) & 0xff) / 255.0f; + dul.color[2] = ( (abgr >> 8) & 0xff) / 255.0f; + dul.color[3] = ( (abgr >> 0) & 0xff) / 255.0f; vkCmdInsertDebugUtilsLabelEXT(m_commandBuffer, &dul); } @@ -2611,6 +2683,8 @@ VK_IMPORT_DEVICE void submitBlit(BlitState& _bs, uint16_t _view); + void submitUniformCache(UniformCacheState& _ucs, uint16_t _view); + void submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter) override; void blitSetup(TextVideoMemBlitter& _blitter) override @@ -2785,7 +2859,7 @@ VK_IMPORT_DEVICE float maxAnisotropy = 1.0f; if (!!(_resolution.reset & BGFX_RESET_MAXANISOTROPY) ) { - maxAnisotropy = m_deviceProperties.limits.maxSamplerAnisotropy; + maxAnisotropy = m_deviceProperties.properties.limits.maxSamplerAnisotropy; } if (m_maxAnisotropy != maxAnisotropy) @@ -2815,10 +2889,11 @@ VK_IMPORT_DEVICE ); if (false - || m_resolution.format != _resolution.format - || m_resolution.width != _resolution.width - || m_resolution.height != _resolution.height - || m_resolution.reset != flags + || m_resolution.formatColor != _resolution.formatColor + || m_resolution.formatDepthStencil != _resolution.formatDepthStencil + || m_resolution.width != _resolution.width + || m_resolution.height != _resolution.height + || m_resolution.reset != flags || m_backBuffer.m_swapChain.m_needToRecreateSurface || m_backBuffer.m_swapChain.m_needToRecreateSwapchain) { @@ -2873,7 +2948,8 @@ VK_IMPORT_DEVICE void setFrameBuffer(FrameBufferHandle _fbh, bool _acquire = true) { - BGFX_PROFILER_SCOPE("Vk::setFrameBuffer()", kColorFrame); + BGFX_PROFILER_SCOPE("RendererContextVK::setFrameBuffer()", kColorFrame); + BX_ASSERT(false || isValid(_fbh) || NULL != m_backBuffer.m_nwh @@ -3194,7 +3270,7 @@ VK_IMPORT_DEVICE } } - VkResult getRenderPass(uint8_t _num, const VkFormat* _formats, const VkImageAspectFlags* _aspects, const bool* _resolve, VkSampleCountFlagBits _samples, ::VkRenderPass* _renderPass) + VkResult getRenderPass(uint8_t _num, const VkFormat* _formats, const VkImageAspectFlags* _aspects, const bool* _resolve, VkSampleCountFlagBits _samples, ::VkRenderPass* _renderPass, uint16_t _clearFlags) { VkResult result = VK_SUCCESS; @@ -3207,6 +3283,7 @@ VK_IMPORT_DEVICE hash.begin(); hash.add(_samples); hash.add(_formats, sizeof(VkFormat) * _num); + hash.add(_clearFlags); if (NULL != _resolve) { hash.add(_resolve, sizeof(bool) * _num); @@ -3257,6 +3334,12 @@ VK_IMPORT_DEVICE { colorAr[numColorAr].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; colorAr[numColorAr].attachment = ii; + ad[numColorAr].loadOp = 0 != (_clearFlags & BGFX_CLEAR_COLOR) ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD; + + if (BGFX_CLEAR_NONE != (_clearFlags & (BGFX_CLEAR_DISCARD_COLOR_0 << ii) ) ) + { + ad[numColorAr].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; + } resolveAr[numColorAr].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; resolveAr[numColorAr].attachment = VK_ATTACHMENT_UNUSED; @@ -3277,7 +3360,10 @@ VK_IMPORT_DEVICE } else if (_aspects[ii] & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) ) { - ad[ii].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD; + ad[ii].loadOp = 0 != (_clearFlags & BGFX_CLEAR_DEPTH) ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD; + ad[ii].storeOp = 0 != (_clearFlags & BGFX_CLEAR_DISCARD_DEPTH) ? VK_ATTACHMENT_STORE_OP_DONT_CARE : VK_ATTACHMENT_STORE_OP_STORE; + ad[ii].stencilLoadOp = 0 != (_clearFlags & BGFX_CLEAR_STENCIL) ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD; + ad[ii].stencilStoreOp = 0 != (_clearFlags & BGFX_CLEAR_DISCARD_STENCIL) ? VK_ATTACHMENT_STORE_OP_DONT_CARE : VK_ATTACHMENT_STORE_OP_STORE; ad[ii].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE; ad[ii].initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; ad[ii].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; @@ -3358,7 +3444,7 @@ VK_IMPORT_DEVICE return result; } - VkResult getRenderPass(uint8_t _num, const Attachment* _attachments, ::VkRenderPass* _renderPass) + VkResult getRenderPass(uint8_t _num, const Attachment* _attachments, ::VkRenderPass* _renderPass, uint16_t _clearFlags) { VkFormat formats[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS]; VkImageAspectFlags aspects[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS]; @@ -3368,38 +3454,46 @@ VK_IMPORT_DEVICE { const TextureVK& texture = m_textures[_attachments[ii].handle.idx]; formats[ii] = texture.m_format; - aspects[ii] = texture.m_aspectMask; + aspects[ii] = texture.m_aspectFlags; samples = texture.m_sampler.Sample; } - return getRenderPass(_num, formats, aspects, NULL, samples, _renderPass); + return getRenderPass(_num, formats, aspects, NULL, samples, _renderPass, _clearFlags); } - VkResult getRenderPass(const SwapChainVK& swapChain, ::VkRenderPass* _renderPass) + VkResult getRenderPass(const SwapChainVK& swapChain, ::VkRenderPass* _renderPass, uint16_t _clearFlags) { const VkFormat formats[2] = { swapChain.m_sci.imageFormat, swapChain.m_backBufferDepthStencil.m_format }; + const VkImageAspectFlags aspects[2] = { VK_IMAGE_ASPECT_COLOR_BIT, - swapChain.m_backBufferDepthStencil.m_aspectMask + swapChain.m_backBufferDepthStencil.m_aspectFlags }; + const bool resolve[2] = { swapChain.m_supportsManualResolve ? false : true, false }; + const VkSampleCountFlagBits samples = swapChain.m_sampler.Sample; - return getRenderPass(BX_COUNTOF(formats), formats, aspects, resolve, samples, _renderPass); + const uint8_t num = swapChain.hasDepthStencil() + ? BX_COUNTOF(formats) + : 1 + ; + + return getRenderPass(num, formats, aspects, resolve, samples, _renderPass, _clearFlags); } VkSampler getSampler(uint32_t _flags, VkFormat _format, const float _palette[][4]) { - uint32_t index = ((_flags & BGFX_SAMPLER_BORDER_COLOR_MASK) >> BGFX_SAMPLER_BORDER_COLOR_SHIFT); + uint32_t index = ( (_flags & BGFX_SAMPLER_BORDER_COLOR_MASK) >> BGFX_SAMPLER_BORDER_COLOR_SHIFT); index = bx::min(BGFX_CONFIG_MAX_COLOR_PALETTE - 1, index); _flags &= BGFX_SAMPLER_BITS_MASK; @@ -3463,7 +3557,7 @@ VK_IMPORT_DEVICE const uint32_t cmpFunc = (_flags&BGFX_SAMPLER_COMPARE_MASK)>>BGFX_SAMPLER_COMPARE_SHIFT; - const float maxLodBias = m_deviceProperties.limits.maxSamplerLodBias; + const float maxLodBias = m_deviceProperties.properties.limits.maxSamplerLodBias; const float lodBias = bx::clamp(float(BGFX_CONFIG_MIP_LOD_BIAS), -maxLodBias, maxLodBias); VkSamplerCreateInfo sci; @@ -3508,7 +3602,7 @@ VK_IMPORT_DEVICE { const TextureVK& texture = m_textures[_handle.idx]; - _stencil = _stencil && !!(texture.m_aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT); + _stencil = _stencil && !!(texture.m_aspectFlags & VK_IMAGE_ASPECT_STENCIL_BIT); bx::HashMurmur2A hash; hash.begin(); @@ -3697,14 +3791,17 @@ VK_IMPORT_DEVICE VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_BLEND_CONSTANTS, VK_DYNAMIC_STATE_STENCIL_REFERENCE, + VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR, // optional }; VkPipelineDynamicStateCreateInfo dynamicState; dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; dynamicState.pNext = NULL; dynamicState.flags = 0; - dynamicState.dynamicStateCount = BX_COUNTOF(dynamicStates); - dynamicState.pDynamicStates = dynamicStates; + dynamicState.dynamicStateCount = BX_COUNTOF(dynamicStates) - + (m_variableRateShadingSupported ? 0 : 1) + ; + dynamicState.pDynamicStates = dynamicStates; VkPipelineShaderStageCreateInfo shaderStages[2]; shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; @@ -3837,7 +3934,7 @@ VK_IMPORT_DEVICE VkDescriptorSetAllocateInfo dsai; dsai.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; dsai.pNext = NULL; - dsai.descriptorPool = m_descriptorPool; + dsai.descriptorPool = m_descriptorPool[m_cmd.m_currentFrameInFlight]; dsai.descriptorSetCount = 1; dsai.pSetLayouts = &program.m_descriptorSetLayout; @@ -4252,14 +4349,14 @@ VK_IMPORT_DEVICE { mrtFormat[ii] = bgfx::TextureFormat::Enum(m_textures[fb.m_texture[ii].idx].m_requestedFormat); } - depthAspectMask = isValid(fb.m_depth) ? m_textures[fb.m_depth.idx].m_aspectMask : 0; + depthAspectMask = isValid(fb.m_depth) ? m_textures[fb.m_depth.idx].m_aspectFlags : 0; rect[0].layerCount = fb.m_attachment[0].numLayers; } else { numMrt = 1; - mrtFormat[0] = fb.m_swapChain.m_colorFormat; - depthAspectMask = fb.m_swapChain.m_backBufferDepthStencil.m_aspectMask; + mrtFormat[0] = fb.m_swapChain.m_colorFormat; + depthAspectMask = fb.m_swapChain.m_backBufferDepthStencil.m_aspectFlags; } VkClearAttachment attachments[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS + 1]; @@ -4379,7 +4476,7 @@ VK_IMPORT_DEVICE { // Check LRU cache. int memoryType = selectMemoryType(requirements->memoryTypeBits, propertyFlags, 0); - bool found = m_memoryLru.find(requirements->size, memoryType, memory); + bool found = m_memoryLru.find(bx::narrowCast(requirements->size), memoryType, memory); if (found) { return VK_SUCCESS; @@ -4402,9 +4499,10 @@ VK_IMPORT_DEVICE if (searchIndex >= 0) { BGFX_PROFILER_SCOPE("vkAllocateMemory", kColorResource); + ma.memoryTypeIndex = searchIndex; memory->memoryTypeIndex = searchIndex; - memory->size = ma.allocationSize; + memory->size = bx::narrowCast(ma.allocationSize); memory->offset = 0; result = vkAllocateMemory(m_device, &ma, m_allocatorCb, &memory->mem); } @@ -4417,7 +4515,8 @@ VK_IMPORT_DEVICE VkResult createHostBuffer(uint32_t _size, VkMemoryPropertyFlags _flags, ::VkBuffer* _buffer, DeviceMemoryAllocationVK* _memory, bool _forcePrivateDeviceAllocation, const void* _data = NULL) { - BGFX_PROFILER_SCOPE("createHostBuffer", kColorResource); + BGFX_PROFILER_SCOPE("RendererContextVK::createHostBuffer", kColorResource); + VkResult result = VK_SUCCESS; VkBufferCreateInfo bci; @@ -4464,6 +4563,7 @@ VK_IMPORT_DEVICE if (_data != NULL) { BGFX_PROFILER_SCOPE("map and copy data", kColorResource); + void* dst; result = vkMapMemory(m_device, _memory->mem, _memory->offset, _size, 0, &dst); if (VK_SUCCESS != result) @@ -4490,12 +4590,12 @@ VK_IMPORT_DEVICE StagingBufferVK allocFromScratchStagingBuffer(uint32_t _size, uint32_t _align, const void* _data = NULL) { - BGFX_PROFILER_SCOPE("allocFromScratchStagingBuffer", kColorResource); + BGFX_PROFILER_SCOPE("RendererContextVK::allocFromScratchStagingBuffer", kColorResource); StagingBufferVK result; ScratchBufferVK &scratch = m_scratchStagingBuffer[m_cmd.m_currentFrameInFlight]; - if (_size <= BGFX_CONFIG_MAX_STAGING_SIZE_FOR_SCRATCH_BUFFER) + if (_size <= BGFX_CONFIG_MAX_STAGING_SCRATCH_BUFFER_SIZE) { const uint32_t scratchOffset = scratch.alloc(_size, _align); @@ -4511,6 +4611,7 @@ VK_IMPORT_DEVICE if (_data != NULL) { BGFX_PROFILER_SCOPE("copy to scratch", kColorResource); + bx::memCopy(result.m_data, _data, _size); } @@ -4519,7 +4620,7 @@ VK_IMPORT_DEVICE } // Not enough space or too big, we will create a new staging buffer on the spot. - VK_CHECK(createStagingBuffer(_size, &result.m_buffer, &result.m_deviceMem, _data)); + VK_CHECK(createStagingBuffer(_size, &result.m_buffer, &result.m_deviceMem, _data) ); result.m_isFromScratch = false; result.m_offset = 0; @@ -4546,9 +4647,10 @@ VK_IMPORT_DEVICE VkPhysicalDevice m_physicalDevice; uint32_t m_instanceApiVersion; - VkPhysicalDeviceProperties m_deviceProperties; - VkPhysicalDeviceMemoryProperties m_memoryProperties; - VkPhysicalDeviceFeatures m_deviceFeatures; + VkPhysicalDeviceFragmentShadingRatePropertiesKHR m_deviceShadingRateImageProperties; + VkPhysicalDeviceProperties2 m_deviceProperties; + VkPhysicalDeviceMemoryProperties m_memoryProperties; + VkPhysicalDeviceFeatures m_deviceFeatures; bool m_lineAASupport; bool m_borderColorSupport; @@ -4566,14 +4668,14 @@ VK_IMPORT_DEVICE ScratchBufferVK m_scratchBuffer[BGFX_CONFIG_MAX_FRAME_LATENCY]; ScratchBufferVK m_scratchStagingBuffer[BGFX_CONFIG_MAX_FRAME_LATENCY]; - uint32_t m_numFramesInFlight; + uint32_t m_maxFrameLatency; CommandQueueVK m_cmd; VkCommandBuffer m_commandBuffer; VkDevice m_device; uint32_t m_globalQueueFamily; VkQueue m_globalQueue; - VkDescriptorPool m_descriptorPool; + VkDescriptorPool m_descriptorPool[BGFX_CONFIG_MAX_FRAME_LATENCY]; VkPipelineCache m_pipelineCache; TimerQueryVK m_gpuTimer; @@ -4610,6 +4712,8 @@ VK_IMPORT_DEVICE DeviceMemoryAllocationVK m_captureMemory; uint32_t m_captureSize; + bool m_variableRateShadingSupported; + TextVideoMem m_textVideoMem; uint8_t m_fsScratch[64<<10]; @@ -4679,8 +4783,6 @@ VK_DESTROY { if (VK_NULL_HANDLE != _obj) { - BGFX_PROFILER_SCOPE("vkFreeDescriptorSets", kColorResource); - vkFreeDescriptorSets(s_renderVK->m_device, s_renderVK->m_descriptorPool, 1, &_obj); _obj = VK_NULL_HANDLE; } } @@ -4702,7 +4804,7 @@ VK_DESTROY void MemoryLruVK::recycle(DeviceMemoryAllocationVK &_alloc) { - if (MAX_ENTRIES == lru.getNumHandles()) + if (MAX_ENTRIES == lru.getNumHandles() ) { // Evict LRU uint16_t handle = lru.getBack(); @@ -4720,7 +4822,7 @@ VK_DESTROY } totalSizeCached += _alloc.size; - while (totalSizeCached > BGFX_CONFIG_MAX_BYTES_CACHED_DEVICE_MEMORY_ALLOCATIONS) + while (totalSizeCached > BGFX_CONFIG_CACHED_DEVICE_MEMORY_ALLOCATIONS_SIZE) { BX_ASSERT(lru.getNumHandles() > 0, "Memory badly counted."); uint16_t handle = lru.getBack(); @@ -4750,7 +4852,7 @@ VK_DESTROY // with a handful of tiny allocations. if (alloc.size >= _size && _size * 2 >= alloc.size) { - uint32_t waste = alloc.size - _size; + uint32_t waste = bx::narrowCast(alloc.size - _size); if (waste < bestWaste) { bestIdx = slot; @@ -4842,7 +4944,7 @@ VK_DESTROY void ScratchBufferVK::createUniform(uint32_t _size, uint32_t _count) { - const VkPhysicalDeviceLimits& deviceLimits = s_renderVK->m_deviceProperties.limits; + const VkPhysicalDeviceLimits& deviceLimits = s_renderVK->m_deviceProperties.properties.limits; const uint32_t align = uint32_t(deviceLimits.minUniformBufferOffsetAlignment); create(_size, _count, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, align); @@ -4850,7 +4952,7 @@ VK_DESTROY void ScratchBufferVK::createStaging(uint32_t _size) { - const VkPhysicalDeviceLimits& deviceLimits = s_renderVK->m_deviceProperties.limits; + const VkPhysicalDeviceLimits& deviceLimits = s_renderVK->m_deviceProperties.properties.limits; const uint32_t align = uint32_t(deviceLimits.optimalBufferCopyOffsetAlignment); create(_size, 1, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, align); @@ -4895,7 +4997,7 @@ VK_DESTROY void ScratchBufferVK::flush(bool _reset) { - const VkPhysicalDeviceLimits& deviceLimits = s_renderVK->m_deviceProperties.limits; + const VkPhysicalDeviceLimits& deviceLimits = s_renderVK->m_deviceProperties.properties.limits; VkDevice device = s_renderVK->m_device; const uint32_t align = uint32_t(deviceLimits.nonCoherentAtomSize); @@ -5469,7 +5571,7 @@ VK_DESTROY if (NULL != m_fsh) { - for (uint16_t ii = 0; ii < m_fsh->m_numBindings; ii++) + for (uint16_t ii = 0; ii < m_fsh->m_numBindings; ++ii) { const VkDescriptorSetLayoutBinding& fsBinding = m_fsh->m_bindings[ii]; uint16_t vsBindingIdx = UINT16_MAX; @@ -5584,7 +5686,7 @@ VK_DESTROY return result; } - m_frequency = uint64_t(1000000000.0 / double(s_renderVK->m_deviceProperties.limits.timestampPeriod) ); + m_frequency = uint64_t(1000000000.0 / double(s_renderVK->m_deviceProperties.properties.limits.timestampPeriod) ); for (uint32_t ii = 0; ii < BX_COUNTOF(m_result); ++ii) { @@ -5607,6 +5709,7 @@ VK_DESTROY uint32_t TimerQueryVK::begin(uint32_t _resultIdx, uint32_t _frameNum) { BGFX_PROFILER_SCOPE("TimerQueryVK::begin", kColorFrame); + while (0 == m_control.reserve(1) ) { m_control.consume(1); @@ -5635,9 +5738,10 @@ VK_DESTROY void TimerQueryVK::end(uint32_t _idx) { BGFX_PROFILER_SCOPE("TimerQueryVK::end", kColorFrame); + Query& query = m_query[_idx]; query.m_ready = true; - query.m_completed = s_renderVK->m_cmd.m_submitted + s_renderVK->m_cmd.m_numFramesInFlight; + query.m_completed = s_renderVK->m_cmd.m_submitted + s_renderVK->m_maxFrameLatency; const VkCommandBuffer commandBuffer = s_renderVK->m_commandBuffer; const uint32_t offset = _idx * 2 + 0; @@ -5698,6 +5802,7 @@ VK_DESTROY VkResult OcclusionQueryVK::init() { BGFX_PROFILER_SCOPE("OcclusionQueryVK::init", kColorFrame); + VkResult result = VK_SUCCESS; const VkDevice device = s_renderVK->m_device; @@ -5755,6 +5860,7 @@ VK_DESTROY void OcclusionQueryVK::begin(OcclusionQueryHandle _handle) { BGFX_PROFILER_SCOPE("OcclusionQueryVK::shutdown", kColorFrame); + m_control.reserve(1); const VkCommandBuffer commandBuffer = s_renderVK->m_commandBuffer; @@ -5766,6 +5872,7 @@ VK_DESTROY void OcclusionQueryVK::end() { BGFX_PROFILER_SCOPE("OcclusionQueryVK::end", kColorFrame); + const VkCommandBuffer commandBuffer = s_renderVK->m_commandBuffer; const OcclusionQueryHandle handle = m_handle[m_control.m_current]; @@ -5777,6 +5884,7 @@ VK_DESTROY void OcclusionQueryVK::flush(Frame* _render) { BGFX_PROFILER_SCOPE("OcclusionQueryVK::flush", kColorFrame); + if (0 < m_control.available() ) { VkCommandBuffer commandBuffer = s_renderVK->m_commandBuffer; @@ -5866,6 +5974,7 @@ VK_DESTROY void ReadbackVK::copyImageToBuffer(VkCommandBuffer _commandBuffer, VkBuffer _buffer, VkImageLayout _layout, VkImageAspectFlags _aspect, uint8_t _mip) const { BGFX_PROFILER_SCOPE("ReadbackVK::copyImageToBuffer", kColorFrame); + uint32_t mipWidth = bx::uint32_max(1, m_width >> _mip); uint32_t mipHeight = bx::uint32_max(1, m_height >> _mip); @@ -5924,25 +6033,20 @@ VK_DESTROY void ReadbackVK::readback(VkDeviceMemory _memory, VkDeviceSize _offset, void* _data, uint8_t _mip) const { BGFX_PROFILER_SCOPE("ReadbackVK::readback", kColorResource); + if (m_image == VK_NULL_HANDLE) { return; } - uint32_t mipHeight = bx::uint32_max(1, m_height >> _mip); - uint32_t rowPitch = pitch(_mip); + const uint32_t mipHeight = bx::uint32_max(1, m_height >> _mip); + const uint32_t rowPitch = pitch(_mip); - uint8_t* src; + const uint8_t* src; VK_CHECK(vkMapMemory(s_renderVK->m_device, _memory, 0, VK_WHOLE_SIZE, 0, (void**)&src) ); src += _offset; - uint8_t* dst = (uint8_t*)_data; - for (uint32_t yy = 0; yy < mipHeight; ++yy) - { - bx::memCopy(dst, src, rowPitch); - src += rowPitch; - dst += rowPitch; - } + bx::gather(_data, src, rowPitch, rowPitch, mipHeight); vkUnmapMemory(s_renderVK->m_device, _memory); } @@ -5950,6 +6054,7 @@ VK_DESTROY VkResult TextureVK::create(VkCommandBuffer _commandBuffer, uint32_t _width, uint32_t _height, uint64_t _flags, VkFormat _format) { BGFX_PROFILER_SCOPE("TextureVK::create", kColorResource); + BX_ASSERT(0 != (_flags & BGFX_TEXTURE_RT_MASK), ""); _flags |= BGFX_TEXTURE_RT_WRITE_ONLY; @@ -5962,7 +6067,7 @@ VK_DESTROY m_textureFormat = uint8_t(bimg::TextureFormat::Count); m_format = _format; m_components = { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY }; - m_aspectMask = getAspectMask(m_format); + m_aspectFlags = getAspectMask(m_format); m_sampler = s_msaa[bx::uint32_satsub( (m_flags & BGFX_TEXTURE_RT_MSAA_MASK) >> BGFX_TEXTURE_RT_MSAA_SHIFT, 1)]; m_type = VK_IMAGE_VIEW_TYPE_2D; m_numMips = 1; @@ -5972,7 +6077,7 @@ VK_DESTROY if (VK_SUCCESS == result) { - const VkImageLayout layout = 0 != (m_aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) ) + const VkImageLayout layout = 0 != (m_aspectFlags & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) ) ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL ; @@ -5985,6 +6090,7 @@ VK_DESTROY VkResult TextureVK::createImages(VkCommandBuffer _commandBuffer) { BGFX_PROFILER_SCOPE("TextureVK::createImages", kColorResource); + VkResult result = VK_SUCCESS; const VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb; @@ -6019,9 +6125,10 @@ VK_DESTROY | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | (m_flags & BGFX_TEXTURE_RT_MASK - ? (m_aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) + ? (m_aspectFlags & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) ? VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT - : VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) + : VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT + ) : 0 ) | (m_flags & BGFX_TEXTURE_COMPUTE_WRITE ? VK_IMAGE_USAGE_STORAGE_BIT : 0) @@ -6115,6 +6222,7 @@ VK_DESTROY void* TextureVK::create(VkCommandBuffer _commandBuffer, const Memory* _mem, uint64_t _flags, uint8_t _skip) { BGFX_PROFILER_SCOPE("TextureVK::create", kColorResource); + bimg::ImageContainer imageContainer; if (bimg::imageParse(imageContainer, _mem->data, _mem->size) ) @@ -6152,7 +6260,7 @@ VK_DESTROY const bool convert = m_textureFormat != m_requestedFormat; const uint8_t bpp = bimg::getBitsPerPixel(bimg::TextureFormat::Enum(m_textureFormat) ); - m_aspectMask = getAspectMask(m_format); + m_aspectFlags = getAspectMask(m_format); m_sampler = s_msaa[bx::uint32_satsub( (m_flags & BGFX_TEXTURE_RT_MSAA_MASK) >> BGFX_TEXTURE_RT_MSAA_SHIFT, 1)]; if (imageContainer.m_cubeMap) @@ -6329,7 +6437,7 @@ VK_DESTROY bufferCopyInfo[ii].bufferOffset = totalMemSize; bufferCopyInfo[ii].bufferRowLength = 0; // assume that image data are tightly aligned bufferCopyInfo[ii].bufferImageHeight = 0; // assume that image data are tightly aligned - bufferCopyInfo[ii].imageSubresource.aspectMask = m_aspectMask; + bufferCopyInfo[ii].imageSubresource.aspectMask = m_aspectFlags; bufferCopyInfo[ii].imageSubresource.mipLevel = imageInfos[ii].mipLevel; bufferCopyInfo[ii].imageSubresource.baseArrayLayer = imageInfos[ii].layer; bufferCopyInfo[ii].imageSubresource.layerCount = 1; @@ -6341,7 +6449,7 @@ VK_DESTROY if (totalMemSize > 0) { const VkDevice device = s_renderVK->m_device; - const bimg::ImageBlockInfo &dstBlockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(m_textureFormat)); + const bimg::ImageBlockInfo &dstBlockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(m_textureFormat) ); StagingBufferVK stagingBuffer = s_renderVK->allocFromScratchStagingBuffer(totalMemSize, dstBlockInfo.blockSize); @@ -6412,6 +6520,7 @@ VK_DESTROY void TextureVK::destroy() { BGFX_PROFILER_SCOPE("TextureVK::destroy", kColorResource); + m_readback.destroy(); if (VK_NULL_HANDLE != m_textureImage) @@ -6426,6 +6535,7 @@ VK_DESTROY s_renderVK->recycleMemory(m_singleMsaaDeviceMem); } + m_aspectFlags = VK_IMAGE_ASPECT_NONE; m_currentImageLayout = VK_IMAGE_LAYOUT_UNDEFINED; m_currentSingleMsaaImageLayout = VK_IMAGE_LAYOUT_UNDEFINED; } @@ -6433,6 +6543,7 @@ VK_DESTROY void TextureVK::update(VkCommandBuffer _commandBuffer, uint8_t _side, uint8_t _mip, const Rect& _rect, uint16_t _z, uint16_t _depth, uint16_t _pitch, const Memory* _mem) { BGFX_PROFILER_SCOPE("TextureVK::update", kColorResource); + const uint32_t bpp = bimg::getBitsPerPixel(bimg::TextureFormat::Enum(m_textureFormat) ); const bimg::ImageBlockInfo& blockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(m_textureFormat) ); uint32_t rectpitch = _rect.m_width * bpp / 8; @@ -6451,7 +6562,7 @@ VK_DESTROY region.bufferOffset = 0; region.bufferRowLength = (_pitch == UINT16_MAX ? 0 : _pitch * 8 / bpp); region.bufferImageHeight = 0; - region.imageSubresource.aspectMask = m_aspectMask; + region.imageSubresource.aspectMask = m_aspectFlags; region.imageSubresource.mipLevel = _mip; region.imageSubresource.baseArrayLayer = 0; region.imageSubresource.layerCount = 1; @@ -6464,7 +6575,7 @@ VK_DESTROY if (convert) { temp = (uint8_t*)bx::alloc(g_allocator, slicepitch); - bimg::imageDecodeToBgra8(g_allocator, temp, data, _rect.m_width, _rect.m_height, srcpitch, bimg::TextureFormat::Enum(m_requestedFormat)); + bimg::imageDecodeToBgra8(g_allocator, temp, data, _rect.m_width, _rect.m_height, srcpitch, bimg::TextureFormat::Enum(m_requestedFormat) ); data = temp; region.imageExtent = @@ -6512,6 +6623,7 @@ VK_DESTROY void TextureVK::resolve(VkCommandBuffer _commandBuffer, uint8_t _resolve, uint32_t _layer, uint32_t _numLayers, uint32_t _mip) { BGFX_PROFILER_SCOPE("TextureVK::resolve", kColorResource); + const bool needResolve = VK_NULL_HANDLE != m_singleMsaaImage; const bool needMipGen = true @@ -6569,7 +6681,8 @@ VK_DESTROY if (needMipGen) { - BGFX_PROFILER_SCOPE("TextureVK::resolve genMipmaps", kColorResource); + BGFX_PROFILER_SCOPE("Resolve - Generate Mipmaps", kColorResource); + setImageMemoryBarrier(_commandBuffer, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); int32_t mipWidth = bx::max(int32_t(m_width) >> _mip, 1); @@ -6583,20 +6696,21 @@ VK_DESTROY VkImageBlit blit; blit.srcOffsets[0] = { 0, 0, 0 }; blit.srcOffsets[1] = { mipWidth, mipHeight, 1 }; - blit.srcSubresource.aspectMask = m_aspectMask; + blit.srcSubresource.aspectMask = m_aspectFlags; blit.srcSubresource.mipLevel = 0; blit.srcSubresource.baseArrayLayer = _layer; blit.srcSubresource.layerCount = numLayers; blit.dstOffsets[0] = { 0, 0, 0 }; blit.dstOffsets[1] = { mipWidth, mipHeight, 1 }; - blit.dstSubresource.aspectMask = m_aspectMask; + blit.dstSubresource.aspectMask = m_aspectFlags; blit.dstSubresource.mipLevel = 0; blit.dstSubresource.baseArrayLayer = _layer; blit.dstSubresource.layerCount = numLayers; for (uint32_t i = _mip + 1; i < m_numMips; i++) { - BGFX_PROFILER_SCOPE("mipmap", kColorResource); + BGFX_PROFILER_SCOPE("Mipmap", kColorResource); + blit.srcOffsets[1] = { mipWidth, mipHeight, 1 }; blit.srcSubresource.mipLevel = i - 1; @@ -6609,7 +6723,7 @@ VK_DESTROY vk::setImageMemoryBarrier( _commandBuffer , m_textureImage - , m_aspectMask + , m_aspectFlags , VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL , VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL , blit.srcSubresource.mipLevel @@ -6633,7 +6747,7 @@ VK_DESTROY vk::setImageMemoryBarrier( _commandBuffer , m_textureImage - , m_aspectMask + , m_aspectFlags , VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL , VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL , _mip @@ -6650,6 +6764,7 @@ VK_DESTROY void TextureVK::copyBufferToTexture(VkCommandBuffer _commandBuffer, VkBuffer _stagingBuffer, uint32_t _bufferImageCopyCount, VkBufferImageCopy* _bufferImageCopy) { BGFX_PROFILER_SCOPE("TextureVK::copyBufferToTexture", kColorResource); + const VkImageLayout oldLayout = m_currentImageLayout == VK_IMAGE_LAYOUT_UNDEFINED ? m_sampledLayout : m_currentImageLayout @@ -6708,7 +6823,7 @@ VK_DESTROY vk::setImageMemoryBarrier( _commandBuffer , image - , m_aspectMask + , m_aspectFlags , currentLayout , _newImageLayout ); @@ -6725,7 +6840,7 @@ VK_DESTROY { BX_ASSERT(false || !_renderTarget - || !(m_aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) ) + || !(m_aspectFlags & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) ) , "3D image can't be a depth attachment" ); } @@ -6744,14 +6859,14 @@ VK_DESTROY viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; viewInfo.pNext = NULL; viewInfo.flags = 0; - viewInfo.image = ((VK_NULL_HANDLE != m_singleMsaaImage) && !_renderTarget) + viewInfo.image = ( (VK_NULL_HANDLE != m_singleMsaaImage) && !_renderTarget) ? m_singleMsaaImage : m_textureImage ; viewInfo.viewType = _type; viewInfo.format = m_format; viewInfo.components = m_components; - viewInfo.subresourceRange.aspectMask = m_aspectMask & _aspectMask; + viewInfo.subresourceRange.aspectMask = m_aspectFlags & _aspectMask; viewInfo.subresourceRange.baseMipLevel = _mip; viewInfo.subresourceRange.levelCount = _numMips; viewInfo.subresourceRange.baseArrayLayer = _layer; @@ -6792,21 +6907,23 @@ VK_DESTROY { case VK_FORMAT_S8_UINT: return VK_IMAGE_ASPECT_STENCIL_BIT; - break; + case VK_FORMAT_D16_UNORM: case VK_FORMAT_X8_D24_UNORM_PACK32: case VK_FORMAT_D32_SFLOAT: return VK_IMAGE_ASPECT_DEPTH_BIT; + case VK_FORMAT_D16_UNORM_S8_UINT: case VK_FORMAT_D24_UNORM_S8_UINT: case VK_FORMAT_D32_SFLOAT_S8_UINT: return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; + default: return VK_IMAGE_ASPECT_COLOR_BIT; } } - VkResult SwapChainVK::create(VkCommandBuffer _commandBuffer, void* _nwh, const Resolution& _resolution, TextureFormat::Enum _depthFormat) + VkResult SwapChainVK::create(VkCommandBuffer _commandBuffer, void* _nwh, const Resolution& _resolution) { struct ErrorState { @@ -6830,7 +6947,6 @@ VK_DESTROY m_nwh = _nwh; m_resolution = _resolution; - m_depthFormat = TextureFormat::Count == _depthFormat ? TextureFormat::D24S8 : _depthFormat; m_queue = s_renderVK->m_globalQueue; @@ -6851,7 +6967,6 @@ VK_DESTROY m_sci.imageArrayLayers = 1; m_sci.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; m_sci.queueFamilyIndexCount = 0; - m_sci.pQueueFamilyIndices = NULL; m_sci.preTransform = BX_ENABLED(BX_PLATFORM_NX) ? VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR : VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR @@ -6952,6 +7067,7 @@ VK_DESTROY void SwapChainVK::update(VkCommandBuffer _commandBuffer, void* _nwh, const Resolution& _resolution) { BGFX_PROFILER_SCOPE("SwapChainVK::update", kColorFrame); + const VkPhysicalDevice physicalDevice = s_renderVK->m_physicalDevice; m_lastImageRenderedSemaphore = VK_NULL_HANDLE; @@ -6969,9 +7085,10 @@ VK_DESTROY const bool recreateSwapchain = false || m_needToRecreateSwapchain - || m_resolution.format != _resolution.format - || m_resolution.width != _resolution.width - || m_resolution.height != _resolution.height + || m_resolution.formatColor != _resolution.formatColor + || m_resolution.formatDepthStencil != _resolution.formatDepthStencil + || m_resolution.width != _resolution.width + || m_resolution.height != _resolution.height || (m_resolution.reset & recreateSwapchainMask) != (_resolution.reset & recreateSwapchainMask) || recreateSurface ; @@ -7008,8 +7125,8 @@ VK_DESTROY } } - VkSurfaceCapabilitiesKHR surfaceCapabilities; - VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, m_surface, &surfaceCapabilities) ); + VkSurfaceCapabilitiesKHR surfaceCapabilities = {}; + VkResult result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, m_surface, &surfaceCapabilities); const uint32_t width = bx::clamp( m_resolution.width @@ -7025,7 +7142,8 @@ VK_DESTROY // swapchain can't have size 0 // on some platforms this happens when minimized if (width == 0 - || height == 0) + || height == 0 + || VK_SUCCESS != result) { m_sci.oldSwapchain = VK_NULL_HANDLE; s_renderVK->kick(true); @@ -7043,7 +7161,8 @@ VK_DESTROY VkResult SwapChainVK::createSurface() { BGFX_PROFILER_SCOPE("SwapChainVK::createSurface", kColorFrame); - VkResult result = VK_ERROR_INITIALIZATION_FAILED; + + VkResult result = VK_ERROR_EXTENSION_NOT_PRESENT; const VkInstance instance = s_renderVK->m_instance; const VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb; @@ -7077,20 +7196,22 @@ VK_DESTROY } #elif BX_PLATFORM_LINUX { - if (g_platformData.type == bgfx::NativeWindowHandleType::Wayland - && s_extension[Extension::KHR_wayland_surface].m_supported - && NULL != vkCreateWaylandSurfaceKHR - ) + if (g_platformData.type == bgfx::NativeWindowHandleType::Wayland) { - BX_TRACE("Attempting Wayland surface creation."); - VkWaylandSurfaceCreateInfoKHR sci; - sci.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; - sci.pNext = NULL; - sci.flags = 0; - sci.display = (wl_display*)g_platformData.ndt; - sci.surface = (wl_surface*)m_nwh; - result = vkCreateWaylandSurfaceKHR(instance, &sci, allocatorCb, &m_surface); - BX_WARN(VK_SUCCESS == result, "vkCreateWaylandSurfaceKHR failed %d: %s.", result, getName(result) ); + if (s_extension[Extension::KHR_wayland_surface].m_supported + && NULL != vkCreateWaylandSurfaceKHR + ) + { + BX_TRACE("Attempting Wayland surface creation."); + VkWaylandSurfaceCreateInfoKHR sci; + sci.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; + sci.pNext = NULL; + sci.flags = 0; + sci.display = (wl_display*)g_platformData.ndt; + sci.surface = (wl_surface*)m_nwh; + result = vkCreateWaylandSurfaceKHR(instance, &sci, allocatorCb, &m_surface); + BX_WARN(VK_SUCCESS == result, "vkCreateWaylandSurfaceKHR failed %d: %s.", result, getName(result) ); + } } else { @@ -7224,6 +7345,7 @@ VK_DESTROY VkResult SwapChainVK::createSwapChain() { BGFX_PROFILER_SCOPE("SwapChainVK::createSwapchain", kColorFrame); + VkResult result = VK_SUCCESS; const VkPhysicalDevice physicalDevice = s_renderVK->m_physicalDevice; @@ -7235,7 +7357,7 @@ VK_DESTROY // - https://github.com/mpv-player/mpv/issues/8360 // - https://github.com/bkaradzic/bgfx/issues/3227 result = vkDeviceWaitIdle(device); - BX_WARN(VK_SUCCESS == result, "Create swapchain error: vkDeviceWaitIdle() failed: %d: %s", result, getName(result)); + BX_WARN(VK_SUCCESS == result, "Create swapchain error: vkDeviceWaitIdle() failed: %d: %s", result, getName(result) ); VkSurfaceCapabilitiesKHR surfaceCapabilities; result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, m_surface, &surfaceCapabilities); @@ -7267,7 +7389,8 @@ VK_DESTROY const VkColorSpaceKHR surfaceColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; const bool srgb = !!(m_resolution.reset & BGFX_RESET_SRGB_BACKBUFFER); - m_colorFormat = findSurfaceFormat(m_resolution.format, surfaceColorSpace, srgb); + m_colorFormat = findSurfaceFormat(m_resolution.formatColor, surfaceColorSpace, srgb); + m_depthFormat = bgfx::TextureFormat::UnknownDepth; if (TextureFormat::Count == m_colorFormat) { @@ -7366,6 +7489,8 @@ VK_DESTROY , BX_COUNTOF(m_backBufferColorImage) ); + setDebugObjectName(device, m_swapChain, "m_swapChain"); + if (m_numSwapChainImages < m_sci.minImageCount) { BX_TRACE("Create swapchain error: vkGetSwapchainImagesKHR: numSwapchainImages %d < minImageCount %d." @@ -7422,6 +7547,8 @@ VK_DESTROY return result; } + setDebugObjectName(device, m_backBufferColorImageView[ii], "m_backBufferColorImageView[%d]", ii); + m_backBufferColorImageLayout[ii] = VK_IMAGE_LAYOUT_UNDEFINED; } @@ -7443,6 +7570,9 @@ VK_DESTROY BX_TRACE("Create swapchain error: vkCreateSemaphore failed %d: %s.", result, getName(result) ); return result; } + + setDebugObjectName(device, m_presentDoneSemaphore[ii], "m_presentDoneSemaphore[%d]", ii); + setDebugObjectName(device, m_renderDoneSemaphore[ii], "m_renderDoneSemaphore[%d]", ii); } m_backBufferColorIdx = 0; @@ -7457,6 +7587,7 @@ VK_DESTROY void SwapChainVK::releaseSwapChain() { BGFX_PROFILER_SCOPE("SwapChainVK::releaseSwapChain", kColorFrame); + for (uint32_t ii = 0; ii < BX_COUNTOF(m_backBufferColorImageView); ++ii) { release(m_backBufferColorImageView[ii]); @@ -7476,6 +7607,7 @@ VK_DESTROY VkResult SwapChainVK::createAttachments(VkCommandBuffer _commandBuffer) { BGFX_PROFILER_SCOPE("SwapChainVK::createAttachments", kColorFrame); + VkResult result = VK_SUCCESS; const uint32_t samplerIndex = (m_resolution.reset & BGFX_RESET_MSAA_MASK) >> BGFX_RESET_MSAA_SHIFT; @@ -7487,63 +7619,76 @@ VK_DESTROY : BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER ; - // the spec guarantees that at least one of D24S8 and D32FS8 is supported - VkFormat depthFormat = VK_FORMAT_D32_SFLOAT_S8_UINT; - - if (g_caps.formats[m_depthFormat] & requiredCaps) - { - depthFormat = s_textureFormat[m_depthFormat].m_fmtDsv; - } - else if (g_caps.formats[TextureFormat::D24S8] & requiredCaps) - { - depthFormat = s_textureFormat[TextureFormat::D24S8].m_fmtDsv; - } - - result = m_backBufferDepthStencil.create( - _commandBuffer - , m_sci.imageExtent.width - , m_sci.imageExtent.height - , textureFlags - , depthFormat - ); - - if (VK_SUCCESS != result) + if (bimg::isDepth(bimg::TextureFormat::Enum(m_resolution.formatDepthStencil) ) ) { - BX_TRACE("Create swapchain error: creating depth stencil image failed %d: %s.", result, getName(result) ); - return result; - } - - result = m_backBufferDepthStencil.createView(0, 1, 0, 1, VK_IMAGE_VIEW_TYPE_2D, m_backBufferDepthStencil.m_aspectMask, true, &m_backBufferDepthStencilImageView); + // the spec guarantees that at least one of D24S8 and D32FS8 is supported + VkFormat depthFormat = VK_FORMAT_D32_SFLOAT_S8_UINT; - if (VK_SUCCESS != result) - { - BX_TRACE("Create swapchain error: creating depth stencil image view failed %d: %s.", result, getName(result) ); - return result; - } + if (g_caps.formats[m_resolution.formatDepthStencil] & requiredCaps) + { + depthFormat = s_textureFormat[m_resolution.formatDepthStencil].m_fmtDsv; + } + else if (g_caps.formats[TextureFormat::D24S8] & requiredCaps) + { + depthFormat = s_textureFormat[TextureFormat::D24S8].m_fmtDsv; + } - if (m_sampler.Count > 1) - { - result = m_backBufferColorMsaa.create( + result = m_backBufferDepthStencil.create( _commandBuffer , m_sci.imageExtent.width , m_sci.imageExtent.height , textureFlags - , m_sci.imageFormat + , depthFormat ); if (VK_SUCCESS != result) { - BX_TRACE("Create swapchain error: creating MSAA color image failed %d: %s.", result, getName(result) ); + BX_TRACE("Create swapchain error: creating depth stencil image failed %d: %s.", result, getName(result) ); return result; } - result = m_backBufferColorMsaa.createView(0, 1, 0, 1, VK_IMAGE_VIEW_TYPE_2D, m_backBufferColorMsaa.m_aspectMask, true, &m_backBufferColorMsaaImageView); + result = m_backBufferDepthStencil.createView(0, 1, 0, 1 + , VK_IMAGE_VIEW_TYPE_2D + , m_backBufferDepthStencil.m_aspectFlags + , true + , &m_backBufferDepthStencilImageView + ); if (VK_SUCCESS != result) { - BX_TRACE("Create swapchain error: creating MSAA color image view failed %d: %s.", result, getName(result) ); + BX_TRACE("Create swapchain error: creating depth stencil image view failed %d: %s.", result, getName(result) ); return result; } + + if (m_sampler.Count > 1) + { + result = m_backBufferColorMsaa.create( + _commandBuffer + , m_sci.imageExtent.width + , m_sci.imageExtent.height + , textureFlags + , m_sci.imageFormat + ); + + if (VK_SUCCESS != result) + { + BX_TRACE("Create swapchain error: creating MSAA color image failed %d: %s.", result, getName(result) ); + return result; + } + + result = m_backBufferColorMsaa.createView(0, 1, 0, 1 + , VK_IMAGE_VIEW_TYPE_2D + , m_backBufferColorMsaa.m_aspectFlags + , true + , &m_backBufferColorMsaaImageView + ); + + if (VK_SUCCESS != result) + { + BX_TRACE("Create swapchain error: creating MSAA color image view failed %d: %s.", result, getName(result) ); + return result; + } + } } return result; @@ -7552,6 +7697,7 @@ VK_DESTROY void SwapChainVK::releaseAttachments() { BGFX_PROFILER_SCOPE("SwapChainVK::releaseAttachments", kColorFrame); + release(m_backBufferDepthStencilImageView); release(m_backBufferColorMsaaImageView); @@ -7562,13 +7708,14 @@ VK_DESTROY VkResult SwapChainVK::createFrameBuffer() { BGFX_PROFILER_SCOPE("SwapChainVK::createFrameBuffer", kColorFrame); + VkResult result = VK_SUCCESS; const VkDevice device = s_renderVK->m_device; const VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb; VkRenderPass renderPass; - result = s_renderVK->getRenderPass(*this, &renderPass); + result = s_renderVK->getRenderPass(*this, &renderPass, 0); if (VK_SUCCESS != result) { @@ -7577,14 +7724,18 @@ VK_DESTROY for (uint32_t ii = 0; ii < m_numSwapChainImages; ++ii) { - uint32_t numAttachments = 2; - ::VkImageView attachments[3] = + uint32_t numAttachments = 0; + ::VkImageView attachments[3]; + + attachments[numAttachments++] = m_sampler.Count > 1 + ? m_backBufferColorMsaaImageView + : m_backBufferColorImageView[ii] + ; + + if (NULL != m_backBufferDepthStencilImageView) { - m_sampler.Count > 1 - ? m_backBufferColorMsaaImageView - : m_backBufferColorImageView[ii], - m_backBufferDepthStencilImageView, - }; + attachments[numAttachments++] = m_backBufferDepthStencilImageView; + } if (m_sampler.Count > 1 && !m_supportsManualResolve) { @@ -7624,6 +7775,7 @@ VK_DESTROY uint32_t SwapChainVK::findPresentMode(bool _vsync) { BGFX_PROFILER_SCOPE("SwapChainVK::findPresentMode", kColorFrame); + VkResult result = VK_SUCCESS; const VkPhysicalDevice physicalDevice = s_renderVK->m_physicalDevice; @@ -7686,6 +7838,7 @@ VK_DESTROY TextureFormat::Enum SwapChainVK::findSurfaceFormat(TextureFormat::Enum _format, VkColorSpaceKHR _colorSpace, bool _srgb) { BGFX_PROFILER_SCOPE("SwapChainVK::findSurfaceFormat", kColorFrame); + VkResult result = VK_SUCCESS; TextureFormat::Enum selectedFormat = TextureFormat::Count; @@ -7718,7 +7871,7 @@ VK_DESTROY TextureFormat::RGBA8, }; - for (uint32_t ii = 0; ii < BX_COUNTOF(requestedFormats) && TextureFormat::Count == selectedFormat; ii++) + for (uint32_t ii = 0; ii < BX_COUNTOF(requestedFormats) && TextureFormat::Count == selectedFormat; ++ii) { const TextureFormat::Enum requested = requestedFormats[ii]; const VkFormat requestedVkFormat = _srgb @@ -7760,6 +7913,7 @@ VK_DESTROY bool SwapChainVK::acquire(VkCommandBuffer _commandBuffer) { BGFX_PROFILER_SCOPE("SwapChainVK::acquire", kColorFrame); + if (VK_NULL_HANDLE == m_swapChain || m_needToRecreateSwapchain) { @@ -7777,6 +7931,7 @@ VK_DESTROY VkResult result; { BGFX_PROFILER_SCOPE("vkAcquireNextImageKHR", kColorFrame); + result = vkAcquireNextImageKHR( device , m_swapChain @@ -7790,7 +7945,7 @@ VK_DESTROY if (result != VK_SUCCESS) { - BX_TRACE("vkAcquireNextImageKHR(...): result = %s", getName(result)); + BX_TRACE("vkAcquireNextImageKHR(...): result = %s", getName(result) ); } switch (result) @@ -7816,6 +7971,7 @@ VK_DESTROY if (VK_NULL_HANDLE != m_backBufferFence[m_backBufferColorIdx]) { BGFX_PROFILER_SCOPE("vkWaitForFences", kColorFrame); + VK_CHECK(vkWaitForFences( device , 1 @@ -7836,6 +7992,7 @@ VK_DESTROY void SwapChainVK::present() { BGFX_PROFILER_SCOPE("SwapChainVk::present", kColorFrame); + if (VK_NULL_HANDLE != m_swapChain && m_needPresent) { @@ -7851,12 +8008,13 @@ VK_DESTROY VkResult result; { BGFX_PROFILER_SCOPE("vkQueuePresentHKR", kColorFrame); + result = vkQueuePresentKHR(m_queue, &pi); } if (result != VK_SUCCESS) { - BX_TRACE("vkQueuePresentKHR(...): result = %s", getName(result)); + BX_TRACE("vkQueuePresentKHR(...): result = %s", getName(result) ); } switch (result) @@ -7908,34 +8066,38 @@ VK_DESTROY void FrameBufferVK::create(uint8_t _num, const Attachment* _attachment) { BGFX_PROFILER_SCOPE("FrameBufferVK::create", kColorFrame); + m_numTh = _num; bx::memCopy(m_attachment, _attachment, sizeof(Attachment) * _num); postReset(); } - VkResult FrameBufferVK::create(uint16_t _denseIdx, void* _nwh, uint32_t _width, uint32_t _height, TextureFormat::Enum _format, TextureFormat::Enum _depthFormat) + VkResult FrameBufferVK::create(uint16_t _denseIdx, void* _nwh, uint32_t _width, uint32_t _height, TextureFormat::Enum _colorFormat, TextureFormat::Enum _depthFormat) { BGFX_PROFILER_SCOPE("FrameBufferVK::create", kColorFrame); + VkResult result = VK_SUCCESS; Resolution resolution = s_renderVK->m_resolution; - resolution.format = TextureFormat::Count == _format ? resolution.format : _format; + resolution.formatColor = TextureFormat::Count == _colorFormat ? resolution.formatColor : _colorFormat; + resolution.formatDepthStencil = TextureFormat::Count == _depthFormat ? resolution.formatDepthStencil : _depthFormat; resolution.width = _width; resolution.height = _height; + if (_denseIdx != UINT16_MAX) { resolution.reset &= ~BGFX_RESET_MSAA_MASK; } - result = m_swapChain.create(s_renderVK->m_commandBuffer, _nwh, resolution, _depthFormat); + result = m_swapChain.create(s_renderVK->m_commandBuffer, _nwh, resolution); if (VK_SUCCESS != result) { return result; } - result = s_renderVK->getRenderPass(m_swapChain, &m_renderPass); + result = s_renderVK->getRenderPass(m_swapChain, &m_renderPass, 0); if (VK_SUCCESS != result) { @@ -7951,9 +8113,26 @@ VK_DESTROY return result; } + VkRenderPass FrameBufferVK::getRenderPass(uint16_t _clearFlags) const + { + VkRenderPass renderPass; + + if (m_numTh > 0) + { + VK_CHECK(s_renderVK->getRenderPass(m_numTh, m_attachment, &renderPass, _clearFlags) ); + } + else + { + VK_CHECK(s_renderVK->getRenderPass(m_swapChain, &renderPass, _clearFlags) ); + } + + return renderPass; + } + void FrameBufferVK::preReset() { BGFX_PROFILER_SCOPE("FrameBufferVK::preReset", kColorFrame); + if (VK_NULL_HANDLE != m_framebuffer) { s_renderVK->release(m_framebuffer); @@ -7968,12 +8147,13 @@ VK_DESTROY void FrameBufferVK::postReset() { BGFX_PROFILER_SCOPE("FrameBufferVK::postReset", kColorFrame); + if (m_numTh > 0) { const VkDevice device = s_renderVK->m_device; const VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb; - VK_CHECK(s_renderVK->getRenderPass(m_numTh, m_attachment, &m_renderPass) ); + VK_CHECK(s_renderVK->getRenderPass(m_numTh, m_attachment, &m_renderPass, 0) ); m_depth = BGFX_INVALID_HANDLE; m_num = 0; @@ -7988,17 +8168,17 @@ VK_DESTROY , at.mip , 1 , at.numLayers > 1 ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D - , texture.m_aspectMask + , texture.m_aspectFlags , true , &m_textureImageViews[ii] ) ); - if (texture.m_aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) + if (texture.m_aspectFlags & VK_IMAGE_ASPECT_COLOR_BIT) { m_texture[m_num] = at.handle; m_num++; } - else if (texture.m_aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) ) + else if (texture.m_aspectFlags & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) ) { m_depth = at.handle; } @@ -8029,8 +8209,9 @@ VK_DESTROY void FrameBufferVK::update(VkCommandBuffer _commandBuffer, const Resolution& _resolution) { BGFX_PROFILER_SCOPE("FrameBufferVK::update", kColorResource); + m_swapChain.update(_commandBuffer, m_nwh, _resolution); - VK_CHECK(s_renderVK->getRenderPass(m_swapChain, &m_renderPass) ); + VK_CHECK(s_renderVK->getRenderPass(m_swapChain, &m_renderPass, 0) ); // Don't believe the passed Resolution, as the Vulkan driver might have // specified another resolution, which we had to obey. m_width = m_swapChain.m_sci.imageExtent.width; @@ -8046,6 +8227,7 @@ VK_DESTROY } BGFX_PROFILER_SCOPE("FrameBufferVK::resolve", kColorFrame); + if (NULL == m_nwh) { for (uint32_t ii = 0; ii < m_numTh; ++ii) @@ -8078,6 +8260,7 @@ VK_DESTROY uint16_t FrameBufferVK::destroy() { BGFX_PROFILER_SCOPE("FrameBufferVK::destroy", kColorFrame); + preReset(); if (NULL != m_nwh) @@ -8101,6 +8284,7 @@ VK_DESTROY bool FrameBufferVK::acquire(VkCommandBuffer _commandBuffer) { BGFX_PROFILER_SCOPE("FrameBufferVK::acquire", kColorFrame); + bool acquired = true; if (NULL != m_nwh) @@ -8118,6 +8302,7 @@ VK_DESTROY void FrameBufferVK::present() { BGFX_PROFILER_SCOPE("FrameBufferVK::present", kColorFrame); + m_swapChain.present(); m_needPresent = false; } @@ -8130,13 +8315,12 @@ VK_DESTROY ; } - VkResult CommandQueueVK::init(uint32_t _queueFamily, VkQueue _queue, uint32_t _numFramesInFlight) + VkResult CommandQueueVK::init(uint32_t _queueFamily, VkQueue _queue) { - m_queueFamily = _queueFamily; - m_queue = _queue; - m_numFramesInFlight = bx::clamp(_numFramesInFlight, 1, BGFX_CONFIG_MAX_FRAME_LATENCY); + m_queueFamily = _queueFamily; + m_queue = _queue; m_activeCommandBuffer = VK_NULL_HANDLE; - m_consumeIndex = 0; + m_consumeIndex = 0; return reset(); } @@ -8176,12 +8360,15 @@ VK_DESTROY VkResult result = VK_SUCCESS; - for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii) + const VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb; + const VkDevice device = s_renderVK->m_device; + + for (uint32_t ii = 0, maxFrameLatency = s_renderVK->m_maxFrameLatency; ii < maxFrameLatency; ++ii) { result = vkCreateCommandPool( - s_renderVK->m_device + device , &cpci - , s_renderVK->m_allocatorCb + , allocatorCb , &m_commandList[ii].m_commandPool ); @@ -8194,7 +8381,7 @@ VK_DESTROY cbai.commandPool = m_commandList[ii].m_commandPool; result = vkAllocateCommandBuffers( - s_renderVK->m_device + device , &cbai , &m_commandList[ii].m_commandBuffer ); @@ -8206,9 +8393,9 @@ VK_DESTROY } result = vkCreateFence( - s_renderVK->m_device + device , &fci - , s_renderVK->m_allocatorCb + , allocatorCb , &m_commandList[ii].m_fence ); @@ -8227,7 +8414,7 @@ VK_DESTROY kick(true); finish(true); - for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii) + for (uint32_t ii = 0, maxFrameLatency = s_renderVK->m_maxFrameLatency; ii < maxFrameLatency; ++ii) { vkDestroy(m_commandList[ii].m_fence); m_commandList[ii].m_commandBuffer = VK_NULL_HANDLE; @@ -8238,6 +8425,7 @@ VK_DESTROY VkResult CommandQueueVK::alloc(VkCommandBuffer* _commandBuffer) { BGFX_PROFILER_SCOPE("CommandQueueVK::alloc", kColorResource); + VkResult result = VK_SUCCESS; if (m_activeCommandBuffer == VK_NULL_HANDLE) @@ -8247,6 +8435,7 @@ VK_DESTROY { BGFX_PROFILER_SCOPE("vkWaitForFences", kColorFrame); + result = vkWaitForFences(device, 1, &commandList.m_fence, VK_TRUE, UINT64_MAX); } @@ -8310,6 +8499,7 @@ VK_DESTROY void CommandQueueVK::kick(bool _wait) { BGFX_PROFILER_SCOPE("CommandQueueVK::kick", kColorDraw); + if (VK_NULL_HANDLE != m_activeCommandBuffer) { const VkDevice device = s_renderVK->m_device; @@ -8342,19 +8532,20 @@ VK_DESTROY m_numSignalSemaphores = 0; { - BGFX_PROFILER_SCOPE("CommandQueueVK::kick vkQueueSubmit", kColorDraw); + BGFX_PROFILER_SCOPE("vkQueueSubmit", kColorDraw); + VK_CHECK(vkQueueSubmit(m_queue, 1, &si, m_completedFence) ); } if (_wait) { - BGFX_PROFILER_SCOPE("CommandQueue::kick vkWaitForFences", kColorDraw); + BGFX_PROFILER_SCOPE("vkWaitForFences", kColorDraw); VK_CHECK(vkWaitForFences(device, 1, &m_completedFence, VK_TRUE, UINT64_MAX) ); } m_activeCommandBuffer = VK_NULL_HANDLE; - m_currentFrameInFlight = (m_currentFrameInFlight + 1) % m_numFramesInFlight; + m_currentFrameInFlight = (m_currentFrameInFlight + 1) % s_renderVK->m_maxFrameLatency; m_submitted++; } } @@ -8362,9 +8553,10 @@ VK_DESTROY void CommandQueueVK::finish(bool _finishAll) { BGFX_PROFILER_SCOPE("CommandQueueVK::finish", kColorDraw); + if (_finishAll) { - for (uint32_t ii = 0; ii < m_numFramesInFlight; ++ii) + for (uint32_t ii = 0, maxFrameLatency = s_renderVK->m_maxFrameLatency; ii < maxFrameLatency; ++ii) { consume(); } @@ -8393,12 +8585,14 @@ VK_DESTROY void CommandQueueVK::consume() { BGFX_PROFILER_SCOPE("CommandQueueVK::consume", kColorResource); - m_consumeIndex = (m_consumeIndex + 1) % m_numFramesInFlight; + + m_consumeIndex = (m_consumeIndex + 1) % s_renderVK->m_maxFrameLatency; for (DeviceMemoryAllocationVK &alloc : m_recycleAllocs[m_consumeIndex]) { s_renderVK->m_memoryLru.recycle(alloc); } + m_recycleAllocs[m_consumeIndex].clear(); for (const Resource& resource : m_release[m_consumeIndex]) @@ -8432,6 +8626,7 @@ VK_DESTROY void RendererContextVK::submitBlit(BlitState& _bs, uint16_t _view) { BGFX_PROFILER_SCOPE("RendererContextVK::submitBlit", kColorFrame); + VkImageLayout srcLayouts[BGFX_CONFIG_MAX_BLIT_ITEMS]; VkImageLayout dstLayouts[BGFX_CONFIG_MAX_BLIT_ITEMS]; @@ -8482,14 +8677,14 @@ VK_DESTROY ); VkImageCopy copyInfo; - copyInfo.srcSubresource.aspectMask = src.m_aspectMask; + copyInfo.srcSubresource.aspectMask = src.m_aspectFlags; copyInfo.srcSubresource.mipLevel = blit.m_srcMip; copyInfo.srcSubresource.baseArrayLayer = 0; copyInfo.srcSubresource.layerCount = 1; copyInfo.srcOffset.x = blit.m_srcX; copyInfo.srcOffset.y = blit.m_srcY; copyInfo.srcOffset.z = 0; - copyInfo.dstSubresource.aspectMask = dst.m_aspectMask; + copyInfo.dstSubresource.aspectMask = dst.m_aspectFlags; copyInfo.dstSubresource.mipLevel = blit.m_dstMip; copyInfo.dstSubresource.baseArrayLayer = 0; copyInfo.dstSubresource.layerCount = 1; @@ -8549,6 +8744,16 @@ VK_DESTROY } } + void RendererContextVK::submitUniformCache(UniformCacheState& _ucs, uint16_t _view) + { + while (_ucs.hasItem(_view) ) + { + const UniformCacheItem& uci = _ucs.advance(); + + bx::memCopy(m_uniforms[uci.m_handle], &_ucs.m_frame->m_uniformCacheFrame.m_data[uci.m_offset], uci.m_size); + } + } + void RendererContextVK::submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter) { BX_UNUSED(_clearQuad); @@ -8563,7 +8768,7 @@ VK_DESTROY renderDocTriggerCapture(); } - BGFX_VK_PROFILER_BEGIN_LITERAL("rendererSubmit", kColorView); + BGFX_VK_PROFILER_BEGIN_LITERAL("rendererSubmit", kColorFrame); int64_t timeBegin = bx::getHPCounter(); int64_t captureElapsed = 0; @@ -8578,6 +8783,7 @@ VK_DESTROY if (0 < _render->m_iboffset) { BGFX_PROFILER_SCOPE("bgfx/Update transient index buffer", kColorResource); + TransientIndexBuffer* ib = _render->m_transientIb; m_indexBuffers[ib->handle.idx].update(m_commandBuffer, 0, _render->m_iboffset, ib->data); } @@ -8585,6 +8791,7 @@ VK_DESTROY if (0 < _render->m_vboffset) { BGFX_PROFILER_SCOPE("bgfx/Update transient vertex buffer", kColorResource); + TransientVertexBuffer* vb = _render->m_transientVb; m_vertexBuffers[vb->handle.idx].update(m_commandBuffer, 0, _render->m_vboffset, vb->data); } @@ -8613,6 +8820,7 @@ VK_DESTROY uint16_t view = UINT16_MAX; FrameBufferHandle fbh = { BGFX_CONFIG_MAX_FRAME_BUFFERS }; + UniformCacheState ucs(_render); BlitState bs(_render); uint64_t blendFactor = UINT64_MAX; @@ -8636,6 +8844,9 @@ VK_DESTROY const uint64_t f2 = BGFX_STATE_BLEND_FACTOR<<4; const uint64_t f3 = BGFX_STATE_BLEND_INV_FACTOR<<4; + VkDescriptorPool& descriptorPool = m_descriptorPool[m_cmd.m_currentFrameInFlight]; + vkResetDescriptorPool(m_device, descriptorPool, 0); + ScratchBufferVK& scratchBuffer = m_scratchBuffer[m_cmd.m_currentFrameInFlight]; ScratchBufferVK& scratchStagingBuffer = m_scratchStagingBuffer[m_cmd.m_currentFrameInFlight]; @@ -8685,33 +8896,64 @@ VK_DESTROY if (viewChanged) { - if (beginRenderPass) + view = key.m_view; + currentProgram = BGFX_INVALID_HANDLE; + hasPredefined = false; + + if (_render->m_view[view].m_fbh.idx != fbh.idx) + { + if ( beginRenderPass ) + { + vkCmdEndRenderPass(m_commandBuffer); + beginRenderPass = false; + } + + fbh = _render->m_view[view].m_fbh; + setFrameBuffer(fbh); + } + } + + if (!isCompute + && (viewChanged || wasCompute) ) + { + if (wasCompute) + { + wasCompute = false; + currentBindHash = 0; + } + + if (beginRenderPass && (false + || _render->m_view[view].m_fbh.idx != fbh.idx + || _render->m_view[view].m_rect.m_x != viewState.m_rect.m_x + || _render->m_view[view].m_rect.m_y != viewState.m_rect.m_y + || _render->m_view[view].m_rect.m_width != viewState.m_rect.m_width + || _render->m_view[view].m_rect.m_height != viewState.m_rect.m_height + ) ) { vkCmdEndRenderPass(m_commandBuffer); beginRenderPass = false; } - view = key.m_view; - currentProgram = BGFX_INVALID_HANDLE; - hasPredefined = false; - if (item > 1) { profiler.end(); } + if (beginRenderPass && bs.hasItem(view) ) + { + vkCmdEndRenderPass(m_commandBuffer); + beginRenderPass = false; + } + + submitUniformCache(ucs, view); + submitBlit(bs, view); + BGFX_VK_PROFILER_END(); setViewType(view, " "); BGFX_VK_PROFILER_BEGIN(view, kColorView); profiler.begin(view); - if (_render->m_view[view].m_fbh.idx != fbh.idx) - { - fbh = _render->m_view[view].m_fbh; - setFrameBuffer(fbh); - } - const FrameBufferVK& fb = isValid(m_fbh) ? m_frameBuffers[m_fbh.idx] : m_backBuffer @@ -8721,6 +8963,8 @@ VK_DESTROY if (isFrameBufferValid) { + VkRenderPass renderPass = fb.getRenderPass(_render->m_view[view].m_clear.m_flags); + viewState.m_rect = _render->m_view[view].m_rect; Rect rect = _render->m_view[view].m_rect; Rect scissorRect = _render->m_view[view].m_scissor; @@ -8743,7 +8987,7 @@ VK_DESTROY } rpbi.framebuffer = fb.m_currentFramebuffer; - rpbi.renderPass = fb.m_renderPass; + rpbi.renderPass = renderPass; rpbi.renderArea.offset.x = rect.m_x; rpbi.renderArea.offset.y = rect.m_y; rpbi.renderArea.extent.width = rect.m_width; @@ -8765,19 +9009,126 @@ VK_DESTROY rc.extent.height = viewScissorRect.m_height; vkCmdSetScissor(m_commandBuffer, 0, 1, &rc); - const Clear& clr = _render->m_view[view].m_clear; - if (BGFX_CLEAR_NONE != clr.m_flags) + if (!beginRenderPass) { - vkCmdBeginRenderPass(m_commandBuffer, &rpbi, VK_SUBPASS_CONTENTS_INLINE); + uint32_t numMrt; + bgfx::TextureFormat::Enum mrtFormat[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS]; + VkImageAspectFlags depthAspectMask; - Rect clearRect = rect; - clearRect.setIntersect(rect, viewScissorRect); - clearQuad(clearRect, clr, _render->m_colorPalette); + if (NULL == fb.m_nwh) + { + numMrt = fb.m_num; + for (uint8_t ii = 0; ii < fb.m_num; ++ii) + { + mrtFormat[ii] = bgfx::TextureFormat::Enum(m_textures[fb.m_texture[ii].idx].m_requestedFormat); + } - vkCmdEndRenderPass(m_commandBuffer); + depthAspectMask = isValid(fb.m_depth) ? m_textures[fb.m_depth.idx].m_aspectFlags : 0; + } + else + { + numMrt = 1; + mrtFormat[0] = fb.m_swapChain.m_colorFormat; + depthAspectMask = fb.m_swapChain.m_backBufferDepthStencil.m_aspectFlags; + } + + VkClearValue clearValues[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS + 1]; + uint32_t mrt = 0; + + const Clear& clr = _render->m_view[view].m_clear; + + for (uint32_t ii = 0; ii < numMrt; ++ii) + { + if (BGFX_CLEAR_COLOR & clr.m_flags) + { + VkClearColorValue& clearValue = clearValues[mrt].color; + + const bimg::ImageBlockInfo& blockInfo = bimg::getBlockInfo(bimg::TextureFormat::Enum(mrtFormat[ii]) ); + const bx::EncodingType::Enum type = bx::EncodingType::Enum(blockInfo.encoding); + + if (BGFX_CLEAR_COLOR_USE_PALETTE & clr.m_flags) + { + const uint8_t index = bx::min(BGFX_CONFIG_MAX_COLOR_PALETTE - 1, clr.m_index[ii]); + const float* rgba = _render->m_colorPalette[index]; + + switch (type) + { + case bx::EncodingType::Int: + case bx::EncodingType::Uint: + clearValue.int32[0] = int32_t(rgba[0]); + clearValue.int32[1] = int32_t(rgba[1]); + clearValue.int32[2] = int32_t(rgba[2]); + clearValue.int32[3] = int32_t(rgba[3]); + break; + default: + bx::memCopy(&clearValue.float32, rgba, sizeof(clearValue.float32) ); + break; + } + } + else + { + switch (type) + { + case bx::EncodingType::Int: + case bx::EncodingType::Uint: + clearValue.uint32[0] = clr.m_index[0]; + clearValue.uint32[1] = clr.m_index[1]; + clearValue.uint32[2] = clr.m_index[2]; + clearValue.uint32[3] = clr.m_index[3]; + break; + default: + bx::unpackRgba8(clearValue.float32, clr.m_index); + break; + } + } + } + ++mrt; + } + + depthAspectMask &= 0 + | (clr.m_flags & BGFX_CLEAR_DEPTH ? VK_IMAGE_ASPECT_DEPTH_BIT : 0) + | (clr.m_flags & BGFX_CLEAR_STENCIL ? VK_IMAGE_ASPECT_STENCIL_BIT : 0) + ; + + if (0 != depthAspectMask) + { + clearValues[mrt].depthStencil.stencil = clr.m_stencil; + clearValues[mrt].depthStencil.depth = clr.m_depth; + ++mrt; + } + + rpbi.clearValueCount = mrt; + rpbi.pClearValues = clearValues; + + vkCmdBeginRenderPass(m_commandBuffer, &rpbi, VK_SUBPASS_CONTENTS_INLINE); + beginRenderPass = true; + } + else + { + const Clear& clr = _render->m_view[view].m_clear; + if (BGFX_CLEAR_NONE != clr.m_flags) + { + Rect clearRect = rect; + clearRect.setIntersect(rect, viewScissorRect); + clearQuad(clearRect, clr, _render->m_colorPalette); + + } } - submitBlit(bs, view); + if (m_variableRateShadingSupported) + { + VkFragmentShadingRateCombinerOpKHR combinerOp[] = + { + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR + }; + + vkCmdSetFragmentShadingRateKHR( + m_commandBuffer + , &s_shadingRate[_render->m_view[view].m_shadingRate].fragmentSize + , combinerOp + ); + } } } @@ -8791,6 +9142,12 @@ VK_DESTROY BGFX_VK_PROFILER_END(); setViewType(view, "C"); BGFX_VK_PROFILER_BEGIN(view, kColorCompute); + + if (beginRenderPass) + { + vkCmdEndRenderPass(m_commandBuffer); + beginRenderPass = false; + } } // renderpass external subpass dependencies handle graphics -> compute and compute -> graphics @@ -8938,25 +9295,6 @@ VK_DESTROY const uint64_t changedFlags = currentState.m_stateFlags ^ draw.m_stateFlags; currentState.m_stateFlags = draw.m_stateFlags; - if (!beginRenderPass) - { - if (wasCompute) - { - wasCompute = false; - currentBindHash = 0; - } - - BGFX_VK_PROFILER_END(); - setViewType(view, " "); - BGFX_VK_PROFILER_BEGIN(view, kColorDraw); - - vkCmdBeginRenderPass(m_commandBuffer, &rpbi, VK_SUBPASS_CONTENTS_INLINE); - beginRenderPass = true; - - currentProgram = BGFX_INVALID_HANDLE; - currentState.m_scissor = !draw.m_scissor; - } - if (0 != draw.m_streamMask) { const bool bindAttribs = hasVertexStreamChanged(currentState, draw); @@ -9228,7 +9566,7 @@ VK_DESTROY m_occlusionQuery.begin(draw.m_occlusionQuery); } - const uint8_t primIndex = uint8_t((draw.m_stateFlags & BGFX_STATE_PT_MASK) >> BGFX_STATE_PT_SHIFT); + const uint8_t primIndex = uint8_t( (draw.m_stateFlags & BGFX_STATE_PT_MASK) >> BGFX_STATE_PT_SHIFT); const PrimInfo& prim = s_primInfo[primIndex]; uint32_t numPrimsSubmitted = 0; @@ -9487,7 +9825,7 @@ VK_DESTROY , BGFX_REV_NUMBER ); - const VkPhysicalDeviceProperties& pdp = m_deviceProperties; + const VkPhysicalDeviceProperties& pdp = m_deviceProperties.properties; tvm.printf(0, pos++, 0x8f, " Device: %s (%s)" , pdp.deviceName , getName(pdp.deviceType) diff --git a/libs/bgfx/src/renderer_vk.h b/libs/bgfx/src/renderer_vk.h index c561852..e0a9082 100644 --- a/libs/bgfx/src/renderer_vk.h +++ b/libs/bgfx/src/renderer_vk.h @@ -27,8 +27,10 @@ # define VK_IMPORT_INSTANCE_PLATFORM #endif // BX_PLATFORM_* +#define VK_NO_STDDEF_H #define VK_NO_STDINT_H #define VK_NO_PROTOTYPES +//#define VK_USE_64_BIT_PTR_DEFINES 0 #include #include @@ -90,7 +92,7 @@ VK_IMPORT_INSTANCE_FUNC(false, vkEnumeratePhysicalDevices); \ VK_IMPORT_INSTANCE_FUNC(false, vkEnumerateDeviceExtensionProperties); \ VK_IMPORT_INSTANCE_FUNC(false, vkEnumerateDeviceLayerProperties); \ - VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceProperties); \ + VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceProperties2); \ VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceFormatProperties); \ VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceFeatures); \ VK_IMPORT_INSTANCE_FUNC(false, vkGetPhysicalDeviceImageFormatProperties); \ @@ -110,115 +112,119 @@ /* VK_EXT_debug_report */ \ VK_IMPORT_INSTANCE_FUNC(true, vkCreateDebugReportCallbackEXT); \ VK_IMPORT_INSTANCE_FUNC(true, vkDestroyDebugReportCallbackEXT); \ + /* VK_KHR_fragment_shading_rate */ \ + VK_IMPORT_INSTANCE_FUNC(true, vkGetPhysicalDeviceFragmentShadingRatesKHR); \ VK_IMPORT_INSTANCE_PLATFORM -#define VK_IMPORT_DEVICE \ - VK_IMPORT_DEVICE_FUNC(false, vkGetDeviceQueue); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateFence); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyFence); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateSemaphore); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroySemaphore); \ - VK_IMPORT_DEVICE_FUNC(false, vkResetFences); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateCommandPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyCommandPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkResetCommandPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkAllocateCommandBuffers); \ - VK_IMPORT_DEVICE_FUNC(false, vkFreeCommandBuffers); \ - VK_IMPORT_DEVICE_FUNC(false, vkGetBufferMemoryRequirements); \ - VK_IMPORT_DEVICE_FUNC(false, vkGetImageMemoryRequirements); \ - VK_IMPORT_DEVICE_FUNC(false, vkGetImageSubresourceLayout); \ - VK_IMPORT_DEVICE_FUNC(false, vkAllocateMemory); \ - VK_IMPORT_DEVICE_FUNC(false, vkFreeMemory); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateImage); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyImage); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateImageView); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyImageView); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateFramebuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyFramebuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateRenderPass); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyRenderPass); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateShaderModule); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyShaderModule); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreatePipelineCache); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipelineCache); \ - VK_IMPORT_DEVICE_FUNC(false, vkGetPipelineCacheData); \ - VK_IMPORT_DEVICE_FUNC(false, vkMergePipelineCaches); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateGraphicsPipelines); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateComputePipelines); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipeline); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreatePipelineLayout); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipelineLayout); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateSampler); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroySampler); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateDescriptorSetLayout); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyDescriptorSetLayout); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateDescriptorPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyDescriptorPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkResetDescriptorPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkAllocateDescriptorSets); \ - VK_IMPORT_DEVICE_FUNC(false, vkFreeDescriptorSets); \ - VK_IMPORT_DEVICE_FUNC(false, vkUpdateDescriptorSets); \ - VK_IMPORT_DEVICE_FUNC(false, vkCreateQueryPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkDestroyQueryPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkQueueSubmit); \ - VK_IMPORT_DEVICE_FUNC(false, vkQueueWaitIdle); \ - VK_IMPORT_DEVICE_FUNC(false, vkDeviceWaitIdle); \ - VK_IMPORT_DEVICE_FUNC(false, vkWaitForFences); \ - VK_IMPORT_DEVICE_FUNC(false, vkBeginCommandBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkEndCommandBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdPipelineBarrier); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdBeginRenderPass); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdEndRenderPass); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdSetViewport); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdDraw); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndexed); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndirect); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndexedIndirect); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdDispatch); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdDispatchIndirect); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdBindPipeline); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdSetStencilReference); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdSetBlendConstants); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdSetScissor); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdBindDescriptorSets); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdBindIndexBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdBindVertexBuffers); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdClearColorImage); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdClearDepthStencilImage); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdClearAttachments); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdResolveImage); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyBufferToImage); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyImage); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyImageToBuffer); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdBlitImage); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdResetQueryPool); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdWriteTimestamp); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdBeginQuery); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdEndQuery); \ - VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyQueryPoolResults); \ - VK_IMPORT_DEVICE_FUNC(false, vkMapMemory); \ - VK_IMPORT_DEVICE_FUNC(false, vkUnmapMemory); \ - VK_IMPORT_DEVICE_FUNC(false, vkFlushMappedMemoryRanges); \ - VK_IMPORT_DEVICE_FUNC(false, vkInvalidateMappedMemoryRanges); \ - VK_IMPORT_DEVICE_FUNC(false, vkBindBufferMemory); \ - VK_IMPORT_DEVICE_FUNC(false, vkBindImageMemory); \ - /* VK_KHR_swapchain */ \ - VK_IMPORT_DEVICE_FUNC(true, vkCreateSwapchainKHR); \ - VK_IMPORT_DEVICE_FUNC(true, vkDestroySwapchainKHR); \ - VK_IMPORT_DEVICE_FUNC(true, vkGetSwapchainImagesKHR); \ - VK_IMPORT_DEVICE_FUNC(true, vkAcquireNextImageKHR); \ - VK_IMPORT_DEVICE_FUNC(true, vkQueuePresentKHR); \ - /* VK_EXT_debug_utils */ \ - VK_IMPORT_DEVICE_FUNC(true, vkSetDebugUtilsObjectNameEXT); \ - VK_IMPORT_DEVICE_FUNC(true, vkCmdBeginDebugUtilsLabelEXT); \ - VK_IMPORT_DEVICE_FUNC(true, vkCmdEndDebugUtilsLabelEXT); \ - VK_IMPORT_DEVICE_FUNC(true, vkCmdInsertDebugUtilsLabelEXT); \ - /* VK_KHR_draw_indirect_count */ \ - VK_IMPORT_DEVICE_FUNC(true, vkCmdDrawIndirectCountKHR); \ - VK_IMPORT_DEVICE_FUNC(true, vkCmdDrawIndexedIndirectCountKHR); \ +#define VK_IMPORT_DEVICE \ + VK_IMPORT_DEVICE_FUNC(false, vkGetDeviceQueue); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateFence); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyFence); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateSemaphore); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroySemaphore); \ + VK_IMPORT_DEVICE_FUNC(false, vkResetFences); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateCommandPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyCommandPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkResetCommandPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkAllocateCommandBuffers); \ + VK_IMPORT_DEVICE_FUNC(false, vkFreeCommandBuffers); \ + VK_IMPORT_DEVICE_FUNC(false, vkGetBufferMemoryRequirements); \ + VK_IMPORT_DEVICE_FUNC(false, vkGetImageMemoryRequirements); \ + VK_IMPORT_DEVICE_FUNC(false, vkGetImageSubresourceLayout); \ + VK_IMPORT_DEVICE_FUNC(false, vkAllocateMemory); \ + VK_IMPORT_DEVICE_FUNC(false, vkFreeMemory); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateImageView); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyImageView); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateFramebuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyFramebuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateRenderPass); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyRenderPass); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateShaderModule); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyShaderModule); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreatePipelineCache); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipelineCache); \ + VK_IMPORT_DEVICE_FUNC(false, vkGetPipelineCacheData); \ + VK_IMPORT_DEVICE_FUNC(false, vkMergePipelineCaches); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateGraphicsPipelines); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateComputePipelines); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipeline); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreatePipelineLayout); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyPipelineLayout); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateSampler); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroySampler); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateDescriptorSetLayout); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyDescriptorSetLayout); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateDescriptorPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyDescriptorPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkResetDescriptorPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkAllocateDescriptorSets); \ + VK_IMPORT_DEVICE_FUNC(false, vkFreeDescriptorSets); \ + VK_IMPORT_DEVICE_FUNC(false, vkUpdateDescriptorSets); \ + VK_IMPORT_DEVICE_FUNC(false, vkCreateQueryPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkDestroyQueryPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkQueueSubmit); \ + VK_IMPORT_DEVICE_FUNC(false, vkQueueWaitIdle); \ + VK_IMPORT_DEVICE_FUNC(false, vkDeviceWaitIdle); \ + VK_IMPORT_DEVICE_FUNC(false, vkWaitForFences); \ + VK_IMPORT_DEVICE_FUNC(false, vkBeginCommandBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkEndCommandBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdPipelineBarrier); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBeginRenderPass); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdEndRenderPass); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdSetViewport); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdDraw); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndexed); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndirect); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdDrawIndexedIndirect); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdDispatch); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdDispatchIndirect); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBindPipeline); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdSetStencilReference); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdSetBlendConstants); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdSetScissor); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBindDescriptorSets); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBindIndexBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBindVertexBuffers); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdClearColorImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdClearDepthStencilImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdClearAttachments); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdResolveImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyBufferToImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyImageToBuffer); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBlitImage); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdResetQueryPool); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdWriteTimestamp); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdBeginQuery); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdEndQuery); \ + VK_IMPORT_DEVICE_FUNC(false, vkCmdCopyQueryPoolResults); \ + VK_IMPORT_DEVICE_FUNC(false, vkMapMemory); \ + VK_IMPORT_DEVICE_FUNC(false, vkUnmapMemory); \ + VK_IMPORT_DEVICE_FUNC(false, vkFlushMappedMemoryRanges); \ + VK_IMPORT_DEVICE_FUNC(false, vkInvalidateMappedMemoryRanges); \ + VK_IMPORT_DEVICE_FUNC(false, vkBindBufferMemory); \ + VK_IMPORT_DEVICE_FUNC(false, vkBindImageMemory); \ + /* VK_KHR_swapchain */ \ + VK_IMPORT_DEVICE_FUNC(true, vkCreateSwapchainKHR); \ + VK_IMPORT_DEVICE_FUNC(true, vkDestroySwapchainKHR); \ + VK_IMPORT_DEVICE_FUNC(true, vkGetSwapchainImagesKHR); \ + VK_IMPORT_DEVICE_FUNC(true, vkAcquireNextImageKHR); \ + VK_IMPORT_DEVICE_FUNC(true, vkQueuePresentKHR); \ + /* VK_EXT_debug_utils */ \ + VK_IMPORT_DEVICE_FUNC(true, vkSetDebugUtilsObjectNameEXT); \ + VK_IMPORT_DEVICE_FUNC(true, vkCmdBeginDebugUtilsLabelEXT); \ + VK_IMPORT_DEVICE_FUNC(true, vkCmdEndDebugUtilsLabelEXT); \ + VK_IMPORT_DEVICE_FUNC(true, vkCmdInsertDebugUtilsLabelEXT); \ + /* VK_KHR_draw_indirect_count */ \ + VK_IMPORT_DEVICE_FUNC(true, vkCmdDrawIndirectCountKHR); \ + VK_IMPORT_DEVICE_FUNC(true, vkCmdDrawIndexedIndirectCountKHR); \ + /* VK_KHR_fragment_shading_rate */ \ + VK_IMPORT_DEVICE_FUNC(true, vkCmdSetFragmentShadingRateKHR); \ #define VK_DESTROY \ VK_DESTROY_FUNC(Buffer); \ @@ -677,6 +683,7 @@ VK_DESTROY_FUNC(DescriptorSet); : m_directAccessPtr(NULL) , m_sampler({ 1, VK_SAMPLE_COUNT_1_BIT }) , m_format(VK_FORMAT_UNDEFINED) + , m_aspectFlags(VK_IMAGE_ASPECT_NONE) , m_textureImage(VK_NULL_HANDLE) , m_textureDeviceMem() , m_currentImageLayout(VK_IMAGE_LAYOUT_UNDEFINED) @@ -716,7 +723,7 @@ VK_DESTROY_FUNC(DescriptorSet); VkImageViewType m_type; VkFormat m_format; VkComponentMapping m_components; - VkImageAspectFlags m_aspectMask; + VkImageAspectFlags m_aspectFlags; VkImage m_textureImage; DeviceMemoryAllocationVK m_textureDeviceMem; @@ -744,11 +751,12 @@ VK_DESTROY_FUNC(DescriptorSet); , m_swapChain(VK_NULL_HANDLE) , m_lastImageRenderedSemaphore(VK_NULL_HANDLE) , m_lastImageAcquiredSemaphore(VK_NULL_HANDLE) + , m_backBufferDepthStencilImageView(VK_NULL_HANDLE) , m_backBufferColorMsaaImageView(VK_NULL_HANDLE) { } - VkResult create(VkCommandBuffer _commandBuffer, void* _nwh, const Resolution& _resolution, TextureFormat::Enum _depthFormat = TextureFormat::Count); + VkResult create(VkCommandBuffer _commandBuffer, void* _nwh, const Resolution& _resolution); void destroy(); @@ -772,6 +780,8 @@ VK_DESTROY_FUNC(DescriptorSet); void transitionImage(VkCommandBuffer _commandBuffer); + bool hasDepthStencil() const { return VK_NULL_HANDLE != m_backBufferDepthStencilImageView; } + VkQueue m_queue; VkSwapchainCreateInfoKHR m_sci; @@ -837,6 +847,8 @@ VK_DESTROY_FUNC(DescriptorSet); void preReset(); void postReset(); + VkRenderPass getRenderPass(uint16_t _clearFlags) const; + void resolve(); bool acquire(VkCommandBuffer _commandBuffer); @@ -868,7 +880,7 @@ VK_DESTROY_FUNC(DescriptorSet); struct CommandQueueVK { - VkResult init(uint32_t _queueFamily, VkQueue _queue, uint32_t _numFramesInFlight); + VkResult init(uint32_t _queueFamily, VkQueue _queue); VkResult reset(); void shutdown(); @@ -885,8 +897,6 @@ VK_DESTROY_FUNC(DescriptorSet); uint32_t m_queueFamily; VkQueue m_queue; - uint32_t m_numFramesInFlight; - uint32_t m_currentFrameInFlight; uint32_t m_consumeIndex; diff --git a/libs/bgfx/src/shader_dxbc.cpp b/libs/bgfx/src/shader_dxbc.cpp index e5932d9..6cf7c42 100644 --- a/libs/bgfx/src/shader_dxbc.cpp +++ b/libs/bgfx/src/shader_dxbc.cpp @@ -139,27 +139,27 @@ namespace bgfx { 1, 0 }, // CUT_STREAM { 1, 0 }, // EMITTHENCUT_STREAM { 1, 0 }, // INTERFACE_CALL - { 0, 0 }, // BUFINFO + { 2, 0 }, // BUFINFO { 2, 0 }, // DERIV_RTX_COARSE { 2, 0 }, // DERIV_RTX_FINE { 2, 0 }, // DERIV_RTY_COARSE { 2, 0 }, // DERIV_RTY_FINE { 5, 0 }, // GATHER4_C { 5, 0 }, // GATHER4_PO - { 0, 0 }, // GATHER4_PO_C + { 6, 0 }, // GATHER4_PO_C { 2, 0 }, // RCP - { 0, 0 }, // F32TOF16 - { 0, 0 }, // F16TOF32 - { 0, 0 }, // UADDC - { 0, 0 }, // USUBB - { 0, 0 }, // COUNTBITS - { 0, 0 }, // FIRSTBIT_HI - { 0, 0 }, // FIRSTBIT_LO - { 0, 0 }, // FIRSTBIT_SHI + { 2, 0 }, // F32TOF16 + { 2, 0 }, // F16TOF32 + { 4, 0 }, // UADDC + { 4, 0 }, // USUBB + { 2, 0 }, // COUNTBITS + { 2, 0 }, // FIRSTBIT_HI + { 2, 0 }, // FIRSTBIT_LO + { 2, 0 }, // FIRSTBIT_SHI { 4, 0 }, // UBFE { 4, 0 }, // IBFE { 5, 0 }, // BFI - { 0, 0 }, // BFREV + { 2, 0 }, // BFREV { 5, 0 }, // SWAPC { 1, 0 }, // DCL_STREAM { 1, 0 }, // DCL_FUNCTION_BODY @@ -198,16 +198,16 @@ namespace bgfx { 3, 0 }, // ATOMIC_UMIN { 2, 0 }, // IMM_ATOMIC_ALLOC { 2, 0 }, // IMM_ATOMIC_CONSUME - { 0, 0 }, // IMM_ATOMIC_IADD - { 0, 0 }, // IMM_ATOMIC_AND - { 0, 0 }, // IMM_ATOMIC_OR - { 0, 0 }, // IMM_ATOMIC_XOR - { 0, 0 }, // IMM_ATOMIC_EXCH - { 0, 0 }, // IMM_ATOMIC_CMP_EXCH - { 0, 0 }, // IMM_ATOMIC_IMAX - { 0, 0 }, // IMM_ATOMIC_IMIN - { 0, 0 }, // IMM_ATOMIC_UMAX - { 0, 0 }, // IMM_ATOMIC_UMIN + { 4, 0 }, // IMM_ATOMIC_IADD + { 4, 0 }, // IMM_ATOMIC_AND + { 4, 0 }, // IMM_ATOMIC_OR + { 4, 0 }, // IMM_ATOMIC_XOR + { 4, 0 }, // IMM_ATOMIC_EXCH + { 5, 0 }, // IMM_ATOMIC_CMP_EXCH + { 4, 0 }, // IMM_ATOMIC_IMAX + { 4, 0 }, // IMM_ATOMIC_IMIN + { 4, 0 }, // IMM_ATOMIC_UMAX + { 4, 0 }, // IMM_ATOMIC_UMIN { 0, 0 }, // SYNC { 3, 0 }, // DADD { 3, 0 }, // DMAX @@ -219,8 +219,8 @@ namespace bgfx { 3, 0 }, // DNE { 2, 0 }, // DMOV { 4, 0 }, // DMOVC - { 0, 0 }, // DTOF - { 0, 0 }, // FTOD + { 2, 0 }, // DTOF + { 2, 0 }, // FTOD { 3, 0 }, // EVAL_SNAPPED { 3, 0 }, // EVAL_SAMPLE_INDEX { 2, 0 }, // EVAL_CENTROID diff --git a/libs/bgfx/src/version.h b/libs/bgfx/src/version.h index 81d3d10..78cf78a 100644 --- a/libs/bgfx/src/version.h +++ b/libs/bgfx/src/version.h @@ -9,5 +9,5 @@ * */ -#define BGFX_REV_NUMBER 8889 -#define BGFX_REV_SHA1 "4cc041f59f90fee9272ca9b57b292e2c23df1c69" +#define BGFX_REV_NUMBER 9039 +#define BGFX_REV_SHA1 "a617e13eebb698e1f52e1135a773af80b4dcab3f" diff --git a/libs/bgfx/tools/geometryv/geometryv.cpp b/libs/bgfx/tools/geometryv/geometryv.cpp index 87d2048..2286823 100644 --- a/libs/bgfx/tools/geometryv/geometryv.cpp +++ b/libs/bgfx/tools/geometryv/geometryv.cpp @@ -1124,8 +1124,6 @@ int _main_(int _argc, char** _argv) if (ImGui::BeginPopupModal("About", &view.m_about, ImGuiWindowFlags_AlwaysAutoResize) ) { - ImGui::SetWindowFontScale(1.0f); - ImGui::Text( "geometryv, bgfx geometry viewer tool " ICON_KI_WRENCH ", version %d.%d.%d.\n" "Copyright 2019-2019 Attila Kocsis. All rights reserved.\n" @@ -1149,8 +1147,6 @@ int _main_(int _argc, char** _argv) if (ImGui::BeginPopupModal("Help", &view.m_help, ImGuiWindowFlags_AlwaysAutoResize) ) { - ImGui::SetWindowFontScale(1.0f); - ImGui::Text("Key bindings:\n\n"); ImGui::PushFont(ImGui::Font::Mono); diff --git a/libs/bgfx/tools/shaderc/shaderc_metal.cpp b/libs/bgfx/tools/shaderc/shaderc_metal.cpp index 9f073b9..70d4044 100644 --- a/libs/bgfx/tools/shaderc/shaderc_metal.cpp +++ b/libs/bgfx/tools/shaderc/shaderc_metal.cpp @@ -23,7 +23,6 @@ BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG_GCC("-Wshadow") // warning: declaration of 'u #include #include #include -#include #include #include BX_PRAGMA_DIAGNOSTIC_POP() diff --git a/libs/bgfx/tools/shaderc/shaderc_spirv.cpp b/libs/bgfx/tools/shaderc/shaderc_spirv.cpp index f7910de..c085dbc 100644 --- a/libs/bgfx/tools/shaderc/shaderc_spirv.cpp +++ b/libs/bgfx/tools/shaderc/shaderc_spirv.cpp @@ -22,7 +22,6 @@ BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG_GCC("-Wshadow") // warning: declaration of 'u #define ENABLE_OPT 1 #include #include -#include #include #include #include diff --git a/libs/bgfx/tools/texturev/texturev.cpp b/libs/bgfx/tools/texturev/texturev.cpp index b4e1476..f96c184 100644 --- a/libs/bgfx/tools/texturev/texturev.cpp +++ b/libs/bgfx/tools/texturev/texturev.cpp @@ -1963,8 +1963,6 @@ int _main_(int _argc, char** _argv) if (ImGui::BeginPopupModal("About", &view.m_about, ImGuiWindowFlags_AlwaysAutoResize) ) { - ImGui::SetWindowFontScale(1.0f); - ImGui::Text( "texturev, bgfx texture viewer tool " ICON_KI_WRENCH ", version %d.%d.%d.\n" "Copyright 2011-2025 Branimir Karadzic. All rights reserved.\n" @@ -1988,8 +1986,6 @@ int _main_(int _argc, char** _argv) if (ImGui::BeginPopupModal("Help", &view.m_help, ImGuiWindowFlags_AlwaysAutoResize) ) { - ImGui::SetWindowFontScale(1.0f); - ImGui::Text("Key bindings:\n\n"); ImGui::PushFont(ImGui::Font::Mono); diff --git a/libs/bimg/include/bimg/bimg.h b/libs/bimg/include/bimg/bimg.h index 4ef89da..b464b98 100644 --- a/libs/bimg/include/bimg/bimg.h +++ b/libs/bimg/include/bimg/bimg.h @@ -59,6 +59,10 @@ namespace bimg ETC2, //!< ETC2 RGB8 ETC2A, //!< ETC2 RGBA8 ETC2A1, //!< ETC2 RGB8A1 + EACR11, //!< EAC R11 UNORM + EACR11S, //!< EAC R11 SNORM + EACRG11, //!< EAC RG11 UNORM + EACRG11S, //!< EAC RG11 SNORM PTC12, //!< PVRTC1 RGB 2BPP PTC14, //!< PVRTC1 RGB 4BPP PTC12A, //!< PVRTC1 RGBA 2BPP diff --git a/libs/bimg/src/bimg_p.h b/libs/bimg/src/bimg_p.h index 9fcac80..985e26c 100644 --- a/libs/bimg/src/bimg_p.h +++ b/libs/bimg/src/bimg_p.h @@ -31,13 +31,13 @@ } \ BX_MACRO_BLOCK_END -#define _BIMG_ASSERT(_condition, _format, ...) \ - BX_MACRO_BLOCK_BEGIN \ - if (!BX_IGNORE_C4127(_condition) \ - && bx::assertFunction(bx::Location::current(), "ASSERT " #_condition " -> " _format, ##__VA_ARGS__) ) \ - { \ - bx::debugBreak(); \ - } \ +#define _BIMG_ASSERT(_condition, _format, ...) \ + BX_MACRO_BLOCK_BEGIN \ + if (!BX_IGNORE_C4127(_condition) \ + && bx::assertFunction(bx::Location::current(), 0, "ASSERT " #_condition " -> " _format, ##__VA_ARGS__) ) \ + { \ + bx::debugBreak(); \ + } \ BX_MACRO_BLOCK_END #include diff --git a/libs/bimg/src/image.cpp b/libs/bimg/src/image.cpp index 2f0ff0b..ff391cf 100644 --- a/libs/bimg/src/image.cpp +++ b/libs/bimg/src/image.cpp @@ -36,6 +36,10 @@ namespace bimg { 4, 4, 4, 8, 1, 1, 0, 0, 0, 0, 0, 0, uint8_t(bx::EncodingType::Unorm) }, // ETC2 { 8, 4, 4, 16, 1, 1, 0, 0, 0, 0, 0, 0, uint8_t(bx::EncodingType::Unorm) }, // ETC2A { 4, 4, 4, 8, 1, 1, 0, 0, 0, 0, 0, 0, uint8_t(bx::EncodingType::Unorm) }, // ETC2A1 + { 4, 4, 4, 8, 1, 1, 0, 0, 0, 0, 0, 0, uint8_t(bx::EncodingType::Unorm) }, // EACR11 UNORM + { 4, 4, 4, 8, 1, 1, 0, 0, 0, 0, 0, 0, uint8_t(bx::EncodingType::Snorm) }, // EACR11 SNORM + { 8, 4, 4, 16, 1, 1, 0, 0, 0, 0, 0, 0, uint8_t(bx::EncodingType::Unorm) }, // EACRG11 UNORM + { 8, 4, 4, 16, 1, 1, 0, 0, 0, 0, 0, 0, uint8_t(bx::EncodingType::Snorm) }, // EACRG11 SNORM { 2, 8, 4, 8, 2, 2, 0, 0, 0, 0, 0, 0, uint8_t(bx::EncodingType::Unorm) }, // PTC12 { 4, 4, 4, 8, 2, 2, 0, 0, 0, 0, 0, 0, uint8_t(bx::EncodingType::Unorm) }, // PTC14 { 2, 8, 4, 8, 2, 2, 0, 0, 0, 0, 0, 0, uint8_t(bx::EncodingType::Unorm) }, // PTC12A @@ -137,6 +141,10 @@ namespace bimg "ETC2", // ETC2 "ETC2A", // ETC2A "ETC2A1", // ETC2A1 + "EACR11", // EAC R11 UNORM + "EACR11S", // EAC R11 SNORM + "EACRG11", // EAC RG11 UNORM + "EACRG11S", // EAC RG11 SNORM "PTC12", // PTC12 "PTC14", // PTC14 "PTC12A", // PTC12A @@ -1070,6 +1078,10 @@ namespace bimg { NULL, NULL }, // ETC2 { NULL, NULL }, // ETC2A { NULL, NULL }, // ETC2A1 + { NULL, NULL }, // EACR11 UNORM + { NULL, NULL }, // EACR11 SNORM + { NULL, NULL }, // EACRG11 UNORM + { NULL, NULL }, // EACRG11 SNORM { NULL, NULL }, // PTC12 { NULL, NULL }, // PTC14 { NULL, NULL }, // PTC12A @@ -4036,93 +4048,97 @@ namespace bimg static const KtxFormatInfo s_translateKtxFormat[] = { - { KTX_COMPRESSED_RGBA_S3TC_DXT1_EXT, KTX_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, KTX_RGBA, KTX_ZERO, }, // BC1 - { KTX_COMPRESSED_RGBA_S3TC_DXT3_EXT, KTX_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, KTX_RGBA, KTX_ZERO, }, // BC2 - { KTX_COMPRESSED_RGBA_S3TC_DXT5_EXT, KTX_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, KTX_RGBA, KTX_ZERO, }, // BC3 - { KTX_COMPRESSED_LUMINANCE_LATC1_EXT, KTX_ZERO, KTX_RED, KTX_ZERO, }, // BC4 - { KTX_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT, KTX_ZERO, KTX_RG, KTX_ZERO, }, // BC5 - { KTX_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, KTX_ZERO, KTX_RGB, KTX_ZERO, }, // BC6H - { KTX_COMPRESSED_RGBA_BPTC_UNORM_ARB, KTX_ZERO, KTX_RGBA, KTX_ZERO, }, // BC7 - { KTX_ETC1_RGB8_OES, KTX_ZERO, KTX_RGB, KTX_ZERO, }, // ETC1 - { KTX_COMPRESSED_RGB8_ETC2, KTX_ZERO, KTX_RGB, KTX_ZERO, }, // ETC2 - { KTX_COMPRESSED_RGBA8_ETC2_EAC, KTX_COMPRESSED_SRGB8_ETC2, KTX_RGBA, KTX_ZERO, }, // ETC2A - { KTX_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, KTX_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, KTX_RGB, KTX_ZERO, }, // ETC2A1 - { KTX_COMPRESSED_RGB_PVRTC_2BPPV1_IMG, KTX_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT, KTX_RGB, KTX_ZERO, }, // PTC12 - { KTX_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, KTX_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT, KTX_RGB, KTX_ZERO, }, // PTC14 - { KTX_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, KTX_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT, KTX_RGBA, KTX_ZERO, }, // PTC12A - { KTX_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, KTX_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT, KTX_RGBA, KTX_ZERO, }, // PTC14A - { KTX_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG, KTX_ZERO, KTX_RGBA, KTX_ZERO, }, // PTC22 - { KTX_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG, KTX_ZERO, KTX_RGBA, KTX_ZERO, }, // PTC24 - { KTX_ATC_RGB_AMD, KTX_ZERO, KTX_RGB, KTX_ZERO, }, // ATC - { KTX_ATC_RGBA_EXPLICIT_ALPHA_AMD, KTX_ZERO, KTX_RGBA, KTX_ZERO, }, // ATCE - { KTX_ATC_RGBA_INTERPOLATED_ALPHA_AMD, KTX_ZERO, KTX_RGBA, KTX_ZERO, }, // ATCI - { KTX_COMPRESSED_RGBA_ASTC_4x4_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC4x4 - { KTX_COMPRESSED_RGBA_ASTC_5x4_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC5x4 - { KTX_COMPRESSED_RGBA_ASTC_5x5_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC5x5 - { KTX_COMPRESSED_RGBA_ASTC_6x5_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC6x5 - { KTX_COMPRESSED_RGBA_ASTC_6x6_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC6x6 - { KTX_COMPRESSED_RGBA_ASTC_8x5_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC8x5 - { KTX_COMPRESSED_RGBA_ASTC_8x6_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC8x6 - { KTX_COMPRESSED_RGBA_ASTC_8x8_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC8x8 - { KTX_COMPRESSED_RGBA_ASTC_10x5_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC10x5 - { KTX_COMPRESSED_RGBA_ASTC_10x6_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC10x6 - { KTX_COMPRESSED_RGBA_ASTC_10x8_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC10x8 - { KTX_COMPRESSED_RGBA_ASTC_10x10_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC10x10 - { KTX_COMPRESSED_RGBA_ASTC_12x10_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC12x10 - { KTX_COMPRESSED_RGBA_ASTC_12x12_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC12x12 - { KTX_ZERO, KTX_ZERO, KTX_ZERO, KTX_ZERO, }, // Unknown - { KTX_ZERO, KTX_ZERO, KTX_ZERO, KTX_ZERO, }, // R1 - { KTX_ALPHA, KTX_ZERO, KTX_ALPHA, KTX_UNSIGNED_BYTE, }, // A8 - { KTX_R8, KTX_ZERO, KTX_RED, KTX_UNSIGNED_BYTE, }, // R8 - { KTX_R8I, KTX_ZERO, KTX_RED, KTX_BYTE, }, // R8S - { KTX_R8UI, KTX_ZERO, KTX_RED, KTX_UNSIGNED_BYTE, }, // R8S - { KTX_R8_SNORM, KTX_ZERO, KTX_RED, KTX_BYTE, }, // R8S - { KTX_R16, KTX_ZERO, KTX_RED, KTX_UNSIGNED_SHORT, }, // R16 - { KTX_R16I, KTX_ZERO, KTX_RED, KTX_SHORT, }, // R16I - { KTX_R16UI, KTX_ZERO, KTX_RED, KTX_UNSIGNED_SHORT, }, // R16U - { KTX_R16F, KTX_ZERO, KTX_RED, KTX_HALF_FLOAT, }, // R16F - { KTX_R16_SNORM, KTX_ZERO, KTX_RED, KTX_SHORT, }, // R16S - { KTX_R32I, KTX_ZERO, KTX_RED, KTX_INT, }, // R32I - { KTX_R32UI, KTX_ZERO, KTX_RED, KTX_UNSIGNED_INT, }, // R32U - { KTX_R32F, KTX_ZERO, KTX_RED, KTX_FLOAT, }, // R32F - { KTX_RG8, KTX_ZERO, KTX_RG, KTX_UNSIGNED_BYTE, }, // RG8 - { KTX_RG8I, KTX_ZERO, KTX_RG, KTX_BYTE, }, // RG8I - { KTX_RG8UI, KTX_ZERO, KTX_RG, KTX_UNSIGNED_BYTE, }, // RG8U - { KTX_RG8_SNORM, KTX_ZERO, KTX_RG, KTX_BYTE, }, // RG8S - { KTX_RG16, KTX_ZERO, KTX_RG, KTX_UNSIGNED_SHORT, }, // RG16 - { KTX_RG16I, KTX_ZERO, KTX_RG, KTX_SHORT, }, // RG16 - { KTX_RG16UI, KTX_ZERO, KTX_RG, KTX_UNSIGNED_SHORT, }, // RG16 - { KTX_RG16F, KTX_ZERO, KTX_RG, KTX_FLOAT, }, // RG16F - { KTX_RG16_SNORM, KTX_ZERO, KTX_RG, KTX_SHORT, }, // RG16S - { KTX_RG32I, KTX_ZERO, KTX_RG, KTX_INT, }, // RG32I - { KTX_RG32UI, KTX_ZERO, KTX_RG, KTX_UNSIGNED_INT, }, // RG32U - { KTX_RG32F, KTX_ZERO, KTX_RG, KTX_FLOAT, }, // RG32F - { KTX_RGB8, KTX_SRGB8, KTX_RGB, KTX_UNSIGNED_BYTE, }, // RGB8 - { KTX_RGB8I, KTX_ZERO, KTX_RGB, KTX_BYTE, }, // RGB8I - { KTX_RGB8UI, KTX_ZERO, KTX_RGB, KTX_UNSIGNED_BYTE, }, // RGB8U - { KTX_RGB8_SNORM, KTX_ZERO, KTX_RGB, KTX_BYTE, }, // RGB8S - { KTX_RGB9_E5, KTX_ZERO, KTX_RGB, KTX_UNSIGNED_INT_5_9_9_9_REV, }, // RGB9E5F - { KTX_BGRA, KTX_SRGB8_ALPHA8, KTX_BGRA, KTX_UNSIGNED_BYTE, }, // BGRA8 - { KTX_RGBA8, KTX_SRGB8_ALPHA8, KTX_RGBA, KTX_UNSIGNED_BYTE, }, // RGBA8 - { KTX_RGBA8I, KTX_ZERO, KTX_RGBA, KTX_BYTE, }, // RGBA8I - { KTX_RGBA8UI, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_BYTE, }, // RGBA8U - { KTX_RGBA8_SNORM, KTX_ZERO, KTX_RGBA, KTX_BYTE, }, // RGBA8S - { KTX_RGBA16, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_SHORT, }, // RGBA16 - { KTX_RGBA16I, KTX_ZERO, KTX_RGBA, KTX_SHORT, }, // RGBA16I - { KTX_RGBA16UI, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_SHORT, }, // RGBA16U - { KTX_RGBA16F, KTX_ZERO, KTX_RGBA, KTX_HALF_FLOAT, }, // RGBA16F - { KTX_RGBA16_SNORM, KTX_ZERO, KTX_RGBA, KTX_SHORT, }, // RGBA16S - { KTX_RGBA32I, KTX_ZERO, KTX_RGBA, KTX_INT, }, // RGBA32I - { KTX_RGBA32UI, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_INT, }, // RGBA32U - { KTX_RGBA32F, KTX_ZERO, KTX_RGBA, KTX_FLOAT, }, // RGBA32F - { KTX_RGB565, KTX_ZERO, KTX_RGB, KTX_UNSIGNED_SHORT_5_6_5, }, // B5G6R5 - { KTX_RGB565, KTX_ZERO, KTX_RGB, KTX_UNSIGNED_SHORT_5_6_5, }, // R5G6B5 - { KTX_RGBA4, KTX_ZERO, KTX_BGRA, KTX_UNSIGNED_SHORT_4_4_4_4, }, // BGRA4 - { KTX_RGBA4, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_SHORT_4_4_4_4, }, // RGBA4 - { KTX_RGB5_A1, KTX_ZERO, KTX_BGRA, KTX_UNSIGNED_SHORT_5_5_5_1, }, // BGR5A1 - { KTX_RGB5_A1, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_SHORT_5_5_5_1, }, // RGB5A1 - { KTX_RGB10_A2, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_INT_2_10_10_10_REV, }, // RGB10A2 - { KTX_R11F_G11F_B10F, KTX_ZERO, KTX_RGB, KTX_UNSIGNED_INT_10F_11F_11F_REV, }, // RG11B10F + { KTX_COMPRESSED_RGBA_S3TC_DXT1_EXT, KTX_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, KTX_RGBA, KTX_ZERO, }, // BC1 + { KTX_COMPRESSED_RGBA_S3TC_DXT3_EXT, KTX_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, KTX_RGBA, KTX_ZERO, }, // BC2 + { KTX_COMPRESSED_RGBA_S3TC_DXT5_EXT, KTX_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, KTX_RGBA, KTX_ZERO, }, // BC3 + { KTX_COMPRESSED_LUMINANCE_LATC1_EXT, KTX_ZERO, KTX_RED, KTX_ZERO, }, // BC4 + { KTX_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT, KTX_ZERO, KTX_RG, KTX_ZERO, }, // BC5 + { KTX_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB, KTX_ZERO, KTX_RGB, KTX_ZERO, }, // BC6H + { KTX_COMPRESSED_RGBA_BPTC_UNORM_ARB, KTX_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB, KTX_RGBA, KTX_ZERO, }, // BC7 + { KTX_ETC1_RGB8_OES, KTX_ZERO, KTX_RGB, KTX_ZERO, }, // ETC1 + { KTX_COMPRESSED_RGB8_ETC2, KTX_COMPRESSED_SRGB8_ETC2, KTX_RGB, KTX_ZERO, }, // ETC2 + { KTX_COMPRESSED_RGBA8_ETC2_EAC, KTX_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, KTX_RGBA, KTX_ZERO, }, // ETC2A + { KTX_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, KTX_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, KTX_RGB, KTX_ZERO, }, // ETC2A1 + { KTX_COMPRESSED_R11_EAC, KTX_ZERO, KTX_RED, KTX_ZERO, }, // EACR11 UNORM + { KTX_COMPRESSED_SIGNED_R11_EAC, KTX_ZERO, KTX_RED, KTX_ZERO, }, // EACR11 SNORM + { KTX_COMPRESSED_RG11_EAC, KTX_ZERO, KTX_RG, KTX_ZERO, }, // EACRG11 UNORM + { KTX_COMPRESSED_SIGNED_RG11_EAC, KTX_ZERO, KTX_RG, KTX_ZERO, }, // EACRG11 SNORM + { KTX_COMPRESSED_RGB_PVRTC_2BPPV1_IMG, KTX_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT, KTX_RGB, KTX_ZERO, }, // PTC12 + { KTX_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, KTX_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT, KTX_RGB, KTX_ZERO, }, // PTC14 + { KTX_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG, KTX_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT, KTX_RGBA, KTX_ZERO, }, // PTC12A + { KTX_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, KTX_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT, KTX_RGBA, KTX_ZERO, }, // PTC14A + { KTX_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG, KTX_ZERO, KTX_RGBA, KTX_ZERO, }, // PTC22 + { KTX_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG, KTX_ZERO, KTX_RGBA, KTX_ZERO, }, // PTC24 + { KTX_ATC_RGB_AMD, KTX_ZERO, KTX_RGB, KTX_ZERO, }, // ATC + { KTX_ATC_RGBA_EXPLICIT_ALPHA_AMD, KTX_ZERO, KTX_RGBA, KTX_ZERO, }, // ATCE + { KTX_ATC_RGBA_INTERPOLATED_ALPHA_AMD, KTX_ZERO, KTX_RGBA, KTX_ZERO, }, // ATCI + { KTX_COMPRESSED_RGBA_ASTC_4x4_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC4x4 + { KTX_COMPRESSED_RGBA_ASTC_5x4_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC5x4 + { KTX_COMPRESSED_RGBA_ASTC_5x5_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC5x5 + { KTX_COMPRESSED_RGBA_ASTC_6x5_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC6x5 + { KTX_COMPRESSED_RGBA_ASTC_6x6_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC6x6 + { KTX_COMPRESSED_RGBA_ASTC_8x5_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC8x5 + { KTX_COMPRESSED_RGBA_ASTC_8x6_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC8x6 + { KTX_COMPRESSED_RGBA_ASTC_8x8_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC8x8 + { KTX_COMPRESSED_RGBA_ASTC_10x5_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC10x5 + { KTX_COMPRESSED_RGBA_ASTC_10x6_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC10x6 + { KTX_COMPRESSED_RGBA_ASTC_10x8_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC10x8 + { KTX_COMPRESSED_RGBA_ASTC_10x10_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC10x10 + { KTX_COMPRESSED_RGBA_ASTC_12x10_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC12x10 + { KTX_COMPRESSED_RGBA_ASTC_12x12_KHR, KTX_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, KTX_RGBA, KTX_ZERO, }, // ASTC12x12 + { KTX_ZERO, KTX_ZERO, KTX_ZERO, KTX_ZERO, }, // Unknown + { KTX_ZERO, KTX_ZERO, KTX_ZERO, KTX_ZERO, }, // R1 + { KTX_ALPHA, KTX_ZERO, KTX_ALPHA, KTX_UNSIGNED_BYTE, }, // A8 + { KTX_R8, KTX_ZERO, KTX_RED, KTX_UNSIGNED_BYTE, }, // R8 + { KTX_R8I, KTX_ZERO, KTX_RED, KTX_BYTE, }, // R8S + { KTX_R8UI, KTX_ZERO, KTX_RED, KTX_UNSIGNED_BYTE, }, // R8S + { KTX_R8_SNORM, KTX_ZERO, KTX_RED, KTX_BYTE, }, // R8S + { KTX_R16, KTX_ZERO, KTX_RED, KTX_UNSIGNED_SHORT, }, // R16 + { KTX_R16I, KTX_ZERO, KTX_RED, KTX_SHORT, }, // R16I + { KTX_R16UI, KTX_ZERO, KTX_RED, KTX_UNSIGNED_SHORT, }, // R16U + { KTX_R16F, KTX_ZERO, KTX_RED, KTX_HALF_FLOAT, }, // R16F + { KTX_R16_SNORM, KTX_ZERO, KTX_RED, KTX_SHORT, }, // R16S + { KTX_R32I, KTX_ZERO, KTX_RED, KTX_INT, }, // R32I + { KTX_R32UI, KTX_ZERO, KTX_RED, KTX_UNSIGNED_INT, }, // R32U + { KTX_R32F, KTX_ZERO, KTX_RED, KTX_FLOAT, }, // R32F + { KTX_RG8, KTX_ZERO, KTX_RG, KTX_UNSIGNED_BYTE, }, // RG8 + { KTX_RG8I, KTX_ZERO, KTX_RG, KTX_BYTE, }, // RG8I + { KTX_RG8UI, KTX_ZERO, KTX_RG, KTX_UNSIGNED_BYTE, }, // RG8U + { KTX_RG8_SNORM, KTX_ZERO, KTX_RG, KTX_BYTE, }, // RG8S + { KTX_RG16, KTX_ZERO, KTX_RG, KTX_UNSIGNED_SHORT, }, // RG16 + { KTX_RG16I, KTX_ZERO, KTX_RG, KTX_SHORT, }, // RG16 + { KTX_RG16UI, KTX_ZERO, KTX_RG, KTX_UNSIGNED_SHORT, }, // RG16 + { KTX_RG16F, KTX_ZERO, KTX_RG, KTX_FLOAT, }, // RG16F + { KTX_RG16_SNORM, KTX_ZERO, KTX_RG, KTX_SHORT, }, // RG16S + { KTX_RG32I, KTX_ZERO, KTX_RG, KTX_INT, }, // RG32I + { KTX_RG32UI, KTX_ZERO, KTX_RG, KTX_UNSIGNED_INT, }, // RG32U + { KTX_RG32F, KTX_ZERO, KTX_RG, KTX_FLOAT, }, // RG32F + { KTX_RGB8, KTX_SRGB8, KTX_RGB, KTX_UNSIGNED_BYTE, }, // RGB8 + { KTX_RGB8I, KTX_ZERO, KTX_RGB, KTX_BYTE, }, // RGB8I + { KTX_RGB8UI, KTX_ZERO, KTX_RGB, KTX_UNSIGNED_BYTE, }, // RGB8U + { KTX_RGB8_SNORM, KTX_ZERO, KTX_RGB, KTX_BYTE, }, // RGB8S + { KTX_RGB9_E5, KTX_ZERO, KTX_RGB, KTX_UNSIGNED_INT_5_9_9_9_REV, }, // RGB9E5F + { KTX_BGRA, KTX_SRGB8_ALPHA8, KTX_BGRA, KTX_UNSIGNED_BYTE, }, // BGRA8 + { KTX_RGBA8, KTX_SRGB8_ALPHA8, KTX_RGBA, KTX_UNSIGNED_BYTE, }, // RGBA8 + { KTX_RGBA8I, KTX_ZERO, KTX_RGBA, KTX_BYTE, }, // RGBA8I + { KTX_RGBA8UI, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_BYTE, }, // RGBA8U + { KTX_RGBA8_SNORM, KTX_ZERO, KTX_RGBA, KTX_BYTE, }, // RGBA8S + { KTX_RGBA16, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_SHORT, }, // RGBA16 + { KTX_RGBA16I, KTX_ZERO, KTX_RGBA, KTX_SHORT, }, // RGBA16I + { KTX_RGBA16UI, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_SHORT, }, // RGBA16U + { KTX_RGBA16F, KTX_ZERO, KTX_RGBA, KTX_HALF_FLOAT, }, // RGBA16F + { KTX_RGBA16_SNORM, KTX_ZERO, KTX_RGBA, KTX_SHORT, }, // RGBA16S + { KTX_RGBA32I, KTX_ZERO, KTX_RGBA, KTX_INT, }, // RGBA32I + { KTX_RGBA32UI, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_INT, }, // RGBA32U + { KTX_RGBA32F, KTX_ZERO, KTX_RGBA, KTX_FLOAT, }, // RGBA32F + { KTX_RGB565, KTX_ZERO, KTX_RGB, KTX_UNSIGNED_SHORT_5_6_5, }, // B5G6R5 + { KTX_RGB565, KTX_ZERO, KTX_RGB, KTX_UNSIGNED_SHORT_5_6_5, }, // R5G6B5 + { KTX_RGBA4, KTX_ZERO, KTX_BGRA, KTX_UNSIGNED_SHORT_4_4_4_4, }, // BGRA4 + { KTX_RGBA4, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_SHORT_4_4_4_4, }, // RGBA4 + { KTX_RGB5_A1, KTX_ZERO, KTX_BGRA, KTX_UNSIGNED_SHORT_5_5_5_1, }, // BGR5A1 + { KTX_RGB5_A1, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_SHORT_5_5_5_1, }, // RGB5A1 + { KTX_RGB10_A2, KTX_ZERO, KTX_RGBA, KTX_UNSIGNED_INT_2_10_10_10_REV, }, // RGB10A2 + { KTX_R11F_G11F_B10F, KTX_ZERO, KTX_RGB, KTX_UNSIGNED_INT_10F_11F_11F_REV, }, // RG11B10F }; static_assert(TextureFormat::UnknownDepth == BX_COUNTOF(s_translateKtxFormat) ); diff --git a/libs/bimg/src/image_decode.cpp b/libs/bimg/src/image_decode.cpp index a5d7a9d..2f66be8 100644 --- a/libs/bimg/src/image_decode.cpp +++ b/libs/bimg/src/image_decode.cpp @@ -60,13 +60,10 @@ BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG_GCC("-Wshadow"); BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG_GCC("-Wsign-compare"); BX_PRAGMA_DIAGNOSTIC_IGNORED_GCC("-Wunused-but-set-variable"); BX_PRAGMA_DIAGNOSTIC_IGNORED_GCC("-Warray-bounds"); -#if BX_COMPILER_GCC >= 60000 BX_PRAGMA_DIAGNOSTIC_IGNORED_GCC("-Wmisleading-indentation"); BX_PRAGMA_DIAGNOSTIC_IGNORED_GCC("-Wshift-negative-value"); -# if BX_COMPILER_GCC >= 70000 BX_PRAGMA_DIAGNOSTIC_IGNORED_GCC("-Wimplicit-fallthrough"); -# endif // BX_COMPILER_GCC >= 70000 -#endif // BX_COMPILER_GCC >= 60000_ +BX_PRAGMA_DIAGNOSTIC_IGNORED_MSVC(4505); // unreferenced function with internal linkage has been removed #define STBI_MALLOC(_size) lodepng_malloc(_size) #define STBI_REALLOC(_ptr, _size) lodepng_realloc(_ptr, _size) #define STBI_FREE(_ptr) lodepng_free(_ptr) @@ -438,6 +435,26 @@ namespace bimg return output; } + static void errorSetTinyExr(int _result, bx::Error* _err) + { + switch (_result) + { + case TINYEXR_ERROR_INVALID_MAGIC_NUMBER: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid magic number."); break; + case TINYEXR_ERROR_INVALID_EXR_VERSION: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid EXR version."); break; + case TINYEXR_ERROR_INVALID_ARGUMENT: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid argument."); break; + case TINYEXR_ERROR_INVALID_DATA: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid data."); break; + case TINYEXR_ERROR_INVALID_FILE: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid file."); break; +// case TINYEXR_ERROR_INVALID_PARAMETER: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid parameter."); break; + case TINYEXR_ERROR_CANT_OPEN_FILE: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Can't open file."); break; + case TINYEXR_ERROR_UNSUPPORTED_FORMAT: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Unsupported format."); break; + case TINYEXR_ERROR_INVALID_HEADER: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid header."); break; + case TINYEXR_ERROR_UNSUPPORTED_FEATURE: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Unsupported feature."); break; + case TINYEXR_ERROR_CANT_WRITE_FILE: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Can't write file."); break; + case TINYEXR_ERROR_SERIALZATION_FAILED: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Serialization failed."); break; + default: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image."); break; + } + } + static ImageContainer* imageParseTinyExr(bx::AllocatorI* _allocator, const void* _data, uint32_t _size, bx::Error* _err) { BX_ERROR_SCOPE(_err); @@ -527,7 +544,7 @@ namespace bimg stepA = 1; } - data = (uint8_t*)bx::alloc(_allocator, exrImage.width * exrImage.height * dstBpp/8); + data = (uint8_t*)bx::alloc(_allocator, (size_t)exrImage.width * exrImage.height * dstBpp/8); width = exrImage.width; height = exrImage.height; @@ -597,29 +614,14 @@ namespace bimg } else { - switch (result) - { - case TINYEXR_ERROR_INVALID_MAGIC_NUMBER: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid magic number."); break; - case TINYEXR_ERROR_INVALID_EXR_VERSION: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid EXR version."); break; - case TINYEXR_ERROR_INVALID_ARGUMENT: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid argument."); break; - case TINYEXR_ERROR_INVALID_DATA: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid data."); break; - case TINYEXR_ERROR_INVALID_FILE: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid file."); break; -// case TINYEXR_ERROR_INVALID_PARAMETER: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid parameter."); break; - case TINYEXR_ERROR_CANT_OPEN_FILE: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Can't open file."); break; - case TINYEXR_ERROR_UNSUPPORTED_FORMAT: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Unsupported format."); break; - case TINYEXR_ERROR_INVALID_HEADER: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Invalid header."); break; - case TINYEXR_ERROR_UNSUPPORTED_FEATURE: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Unsupported feature."); break; - case TINYEXR_ERROR_CANT_WRITE_FILE: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Can't write file."); break; - case TINYEXR_ERROR_SERIALZATION_FAILED: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image. Serialization failed."); break; - default: BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse image."); break; - } + errorSetTinyExr(result, _err); } FreeEXRHeader(&exrHeader); } else { - BX_ERROR_SET(_err, BIMG_ERROR, "EXR: Failed to parse header."); + errorSetTinyExr(result, _err); } ImageContainer* output = NULL; diff --git a/libs/bimg/tools/texturec/texturec.cpp b/libs/bimg/tools/texturec/texturec.cpp index daa227b..95c9583 100644 --- a/libs/bimg/tools/texturec/texturec.cpp +++ b/libs/bimg/tools/texturec/texturec.cpp @@ -189,7 +189,7 @@ bimg::ImageContainer* convert(bx::AllocatorI* _allocator, const void* _inputData { bimg::imageFree(input); - BX_ERROR_SET(_err, TEXTRUREC_ERROR, "Input image format is not equirectangular projection."); + BX_ERROR_SET(_err, TEXTRUREC_ERROR, "Input image format is not equirectangular projection (expected aspect ratio is 2:1)."); return NULL; } } diff --git a/libs/bx/include/bx/bx.h b/libs/bx/include/bx/bx.h index 660655a..83b721f 100644 --- a/libs/bx/include/bx/bx.h +++ b/libs/bx/include/bx/bx.h @@ -115,12 +115,13 @@ namespace bx /// Assert handler function. /// /// @param[in] _location Source code location where function is called. + /// @param[in] _skip Skip top N stack frames. /// @param[in] _format Printf style format. /// @param[in] _argList Arguments for `_format` specification. /// /// @returns True if assert should stop code execution, otherwise returns false. /// - typedef bool (*AssertHandlerFn)(const Location& _location, const char* _format, va_list _argList); + typedef bool (*AssertHandlerFn)(const Location& _location, uint32_t _skip, const char* _format, va_list _argList); /// Set assert handler function. /// @@ -133,12 +134,13 @@ namespace bx /// Assert function calls AssertHandlerFn. /// /// @param[in] _location Source code location where function is called. + /// @param[in] _skip Skip top N stack frames. /// @param[in] _format Printf style format. /// @param[in] ... Arguments for `_format` specification. /// /// @returns True if assert should stop code execution, otherwise returns false. /// - bool assertFunction(const Location& _location, const char* _format, ...); + bool assertFunction(const Location& _location, uint32_t _skip, const char* _format, ...); /// Arithmetic type `Ty` limits. template()> diff --git a/libs/bx/include/bx/debug.h b/libs/bx/include/bx/debug.h index 45e18c6..82e4d32 100644 --- a/libs/bx/include/bx/debug.h +++ b/libs/bx/include/bx/debug.h @@ -49,7 +49,7 @@ namespace bx /// WriterI* getDebugOut(); - /// Capture current callstack. + /// Capture current callstack fast. /// /// @param[in] _skip Skip top N stack frames. /// @param[in] _max Maximum frame to capture. @@ -57,7 +57,17 @@ namespace bx /// /// @returns Number of stack frames captured. /// - uint32_t getCallStack(uint32_t _skip, uint32_t _max, uintptr_t* _outStack); + uint32_t getCallStackFast(uint32_t _skip, uint32_t _max, uintptr_t* _outStack); + + /// Capture current callstack with slower but more accurate method. + /// + /// @param[in] _skip Skip top N stack frames. + /// @param[in] _max Maximum frame to capture. + /// @param[out] _outStack Stack frames array. Must be at least `_max` elements. + /// + /// @returns Number of stack frames captured. + /// + uint32_t getCallStackExact(uint32_t _skip, uint32_t _max, uintptr_t* _outStack); /// Write callstack. /// @@ -68,14 +78,17 @@ namespace bx /// /// @returns Number of bytes writen to `_writer`. /// - int32_t writeCallstack(WriterI* _writer, uintptr_t* _stack, uint32_t _num, Error* _err); + int32_t writeCallstack(WriterI* _writer, const uintptr_t* _stack, uint32_t _num, Error* _err); - /// Capture call stack, and write it to debug output. + /// Capture call stack with `bx::getCallStackExact`, and write it to debug output. /// /// @param[in] _skip Skip top N stack frames. /// void debugOutputCallstack(uint32_t _skip); + /// Install BX exception handler. + void installExceptionHandler(); + } // namespace bx #endif // BX_DEBUG_H_HEADER_GUARD diff --git a/libs/bx/include/bx/filepath.h b/libs/bx/include/bx/filepath.h index ca38985..9a8429f 100644 --- a/libs/bx/include/bx/filepath.h +++ b/libs/bx/include/bx/filepath.h @@ -60,6 +60,10 @@ namespace bx /// FilePath(const StringView& _str); + /// Assign file path from string. + /// + FilePath& operator=(const char* _rhs); + /// Assign file path from string. /// FilePath& operator=(const StringView& _rhs); diff --git a/libs/bx/include/bx/inline/hash.inl b/libs/bx/include/bx/inline/hash.inl index 62eb5fc..63d078a 100644 --- a/libs/bx/include/bx/inline/hash.inl +++ b/libs/bx/include/bx/inline/hash.inl @@ -61,6 +61,8 @@ namespace bx template inline void HashCrc32::add(const Ty& _data) { + static_assert(isTriviallyCopyable(), "Ty must be trivially copyable type."); + add(&_data, sizeof(Ty) ); } @@ -91,6 +93,8 @@ namespace bx template inline void HashMurmur2A::add(const Ty& _data) { + static_assert(isTriviallyCopyable(), "Ty must be trivially copyable type."); + add(&_data, sizeof(Ty) ); } @@ -115,6 +119,8 @@ namespace bx template inline void HashMurmur3::add(const Ty& _data) { + static_assert(isTriviallyCopyable(), "Ty must be trivially copyable type."); + add(&_data, sizeof(Ty) ); } @@ -142,7 +148,7 @@ namespace bx template inline uint32_t hash(const Ty& _data) { - static_assert(isTriviallyCopyable() ); + static_assert(isTriviallyCopyable(), "Ty must be trivially copyable type."); return hash(&_data, sizeof(Ty) ); } diff --git a/libs/bx/include/bx/inline/string.inl b/libs/bx/include/bx/inline/string.inl index 0a84264..c526a56 100644 --- a/libs/bx/include/bx/inline/string.inl +++ b/libs/bx/include/bx/inline/string.inl @@ -187,17 +187,112 @@ namespace bx return m_0terminated; } + inline bool operator==(const StringView& _lhs, const StringView& _rhs) + { + return 0 == strCmp(_lhs, _rhs); + } + + inline bool overlap(const StringView& _a, const StringView& _b) + { + return _a.getTerm() > _b.getPtr() + && _b.getTerm() > _a.getPtr() + ; + } + + inline bool contain(const StringView& _a, const StringView& _b) + { + return _a.getPtr() <= _b.getPtr() + && _a.getTerm() >= _b.getTerm() + ; + } + + template + inline FixedStringT::FixedStringT() + : m_len(0) + { + } + + template + inline FixedStringT::FixedStringT(const char* _str) + : FixedStringT() + { + set(_str); + } + + template + inline FixedStringT::FixedStringT(const StringView& _str) + : FixedStringT() + { + set(_str); + } + + template + inline FixedStringT::~FixedStringT() + { + } + + template + inline void FixedStringT::set(const char* _str) + { + set(StringView(_str) ); + } + + template + inline void FixedStringT::set(const StringView& _str) + { + int32_t copied = strCopy(m_storage, MaxCapacityT, _str); + m_len = copied; + } + + template + inline void FixedStringT::append(const StringView& _str) + { + m_len += strCopy(&m_storage[m_len], MaxCapacityT-m_len, _str); + } + + template + inline void FixedStringT::clear() + { + m_len = 0; + m_storage[0] = '\0'; + } + + template + inline bool FixedStringT::isEmpty() const + { + return 0 == m_len; + } + + template + inline int32_t FixedStringT::getLength() const + { + return m_len; + } + + template + inline const char* FixedStringT::getCPtr() const + { + return m_storage; + } + + template + inline FixedStringT::operator StringView() const + { + return StringView(m_storage, m_len); + } + template inline StringT::StringT() - : StringView() + : m_ptr("") + , m_len(0) , m_capacity(0) { - clear(); } template inline StringT::StringT(const StringT& _rhs) - : StringView() + : m_ptr("") + , m_len(0) , m_capacity(0) { set(_rhs); @@ -205,7 +300,8 @@ namespace bx template inline StringT::StringT(const StringView& _rhs) - : StringView() + : m_ptr("") + , m_len(0) , m_capacity(0) { set(_rhs); @@ -264,21 +360,38 @@ namespace bx template inline void StringT::clear() { - m_0terminated = true; - if (0 != m_capacity) { free(*AllocatorT, const_cast(m_ptr) ); - StringView::clear(); + m_ptr = ""; + m_len = 0; m_capacity = 0; } } + template + inline bool StringT::isEmpty() const + { + return 0 == m_len; + } + + template + inline int32_t StringT::getLength() const + { + return m_len; + } + template inline const char* StringT::getCPtr() const { - return getPtr(); + return m_ptr; + } + + template + inline StringT::operator StringView() const + { + return StringView(m_ptr, m_len); } inline StringView strSubstr(const StringView& _str, int32_t _start, int32_t _len) diff --git a/libs/bx/include/bx/macros.h b/libs/bx/include/bx/macros.h index 89ed230..637efb1 100644 --- a/libs/bx/include/bx/macros.h +++ b/libs/bx/include/bx/macros.h @@ -100,8 +100,8 @@ extern "C" void* __cdecl _alloca(size_t _size); #define BX_ALIGN_DECL_CACHE_LINE(_decl) BX_ALIGN_DECL(BX_CACHE_LINE_SIZE, _decl) /// -#define BX_MACRO_BLOCK_BEGIN for(;;) { -#define BX_MACRO_BLOCK_END break; } +#define BX_MACRO_BLOCK_BEGIN do { +#define BX_MACRO_BLOCK_END } while (false) #define BX_NOOP(...) BX_MACRO_BLOCK_BEGIN BX_MACRO_BLOCK_END /// @@ -214,7 +214,7 @@ extern "C" void* __cdecl _alloca(size_t _size); # if BX_CONFIG_DEBUG # define BX_ASSERT_LOC _BX_ASSERT_LOC # else -# define BX_ASSERT_LOC(_location, ...) BX_MACRO_BLOCK_BEGIN BX_UNUSED(_location) BX_MACRO_BLOCK_END +# define BX_ASSERT_LOC(_location, ...) BX_MACRO_BLOCK_BEGIN BX_UNUSED(_location); BX_MACRO_BLOCK_END # endif // BX_CONFIG_DEBUG #endif // BX_ASSERT_LOC @@ -230,7 +230,7 @@ extern "C" void* __cdecl _alloca(size_t _size); # if BX_CONFIG_DEBUG # define BX_TRACE_LOC _BX_TRACE_LOC # else -# define BX_TRACE_LOC(_location, ...) BX_MACRO_BLOCK_BEGIN BX_UNUSED(_location) BX_MACRO_BLOCK_END +# define BX_TRACE_LOC(_location, ...) BX_MACRO_BLOCK_BEGIN BX_UNUSED(_location); BX_MACRO_BLOCK_END # endif // BX_CONFIG_DEBUG #endif // BX_TRACE_LOC @@ -246,7 +246,7 @@ extern "C" void* __cdecl _alloca(size_t _size); # if BX_CONFIG_DEBUG # define BX_WARN_LOC _BX_WARN_LOC # else -# define BX_WARN_LOC(_location, ...) BX_MACRO_BLOCK_BEGIN BX_UNUSED(_location) BX_MACRO_BLOCK_END +# define BX_WARN_LOC(_location, ...) BX_MACRO_BLOCK_BEGIN BX_UNUSED(_location); BX_MACRO_BLOCK_END # endif // BX_CONFIG_DEBUG #endif // BX_WARN_LOC @@ -260,22 +260,22 @@ extern "C" void* __cdecl _alloca(size_t _size); bx::debugPrintf("%s(%d): BX " _format "\n", _location.filePath, _location.line, ##__VA_ARGS__); \ BX_MACRO_BLOCK_END -#define _BX_ASSERT(_condition, _format, ...) \ - BX_MACRO_BLOCK_BEGIN \ - if (!BX_IGNORE_C4127(_condition) \ - && bx::assertFunction(bx::Location::current(), "ASSERT %s -> " _format, #_condition, ##__VA_ARGS__) ) \ - { \ - bx::debugBreak(); \ - } \ +#define _BX_ASSERT(_condition, _format, ...) \ + BX_MACRO_BLOCK_BEGIN \ + if (!BX_IGNORE_C4127(_condition) \ + && bx::assertFunction(bx::Location::current(), 0, "ASSERT %s -> " _format, #_condition, ##__VA_ARGS__) ) \ + { \ + bx::debugBreak(); \ + } \ BX_MACRO_BLOCK_END -#define _BX_ASSERT_LOC(_location, _condition, _format, ...) \ - BX_MACRO_BLOCK_BEGIN \ - if (!BX_IGNORE_C4127(_condition) \ - && bx::assertFunction(_location, "ASSERT %s -> " _format, #_condition, ##__VA_ARGS__) ) \ - { \ - bx::debugBreak(); \ - } \ +#define _BX_ASSERT_LOC(_location, _condition, _format, ...) \ + BX_MACRO_BLOCK_BEGIN \ + if (!BX_IGNORE_C4127(_condition) \ + && bx::assertFunction(_location, 0, "ASSERT %s -> " _format, #_condition, ##__VA_ARGS__) ) \ + { \ + bx::debugBreak(); \ + } \ BX_MACRO_BLOCK_END #define _BX_WARN(_condition, _format, ...) \ diff --git a/libs/bx/include/bx/os.h b/libs/bx/include/bx/os.h index a676ed8..f5075fb 100644 --- a/libs/bx/include/bx/os.h +++ b/libs/bx/include/bx/os.h @@ -59,7 +59,7 @@ namespace bx void* exec(const char* const* _argv); /// - [[noreturn]] void exit(int32_t _exitCode); + [[noreturn]] void exit(int32_t _exitCode, bool _cleanup = true); /// void* memoryMap(void* _address, size_t _size, Error* _err); diff --git a/libs/bx/include/bx/string.h b/libs/bx/include/bx/string.h index c6e8a2f..9452806 100644 --- a/libs/bx/include/bx/string.h +++ b/libs/bx/include/bx/string.h @@ -137,9 +137,75 @@ namespace bx bool m_0terminated; }; - /// ASCII string + /// Compare two string views. + bool operator==(const StringView& _lhs, const StringView& _rhs); + + /// Returns true if two string views overlap. + bool overlap(const StringView& _a, const StringView& _b); + + /// Returns true if string view `_a` contains string view `_b`. + bool contain(const StringView& _a, const StringView& _b); + + /// Fixed capacity string. + /// + template + class FixedStringT + { + public: + /// + FixedStringT(); + + /// + FixedStringT(const char* _str); + + /// + FixedStringT(const StringView& _str); + + /// + ~FixedStringT(); + + /// + void set(const char* _str); + + /// + void set(const StringView& _str); + + /// + void append(const StringView& _str); + + /// + void clear(); + + /// Returns `true` if string is empty. + /// + bool isEmpty() const; + + /// Returns string length. + /// + int32_t getLength() const; + + /// Returns zero-terminated C string pointer. + /// + const char* getCPtr() const; + + /// Implicitly converts FixedStringT to StringView. + /// + operator StringView() const; + + private: + char m_storage[MaxCapacityT]; + int32_t m_len; + }; + + /// + using FixedString64 = FixedStringT<64>; + using FixedString256 = FixedStringT<256>; + using FixedString1024 = FixedStringT<1024>; + + /// Dynamic string + /// template - class StringT : public StringView + class StringT { public: /// @@ -169,12 +235,26 @@ namespace bx /// void clear(); + /// Returns `true` if string is empty. + /// + bool isEmpty() const; + + /// Returns string length. + /// + int32_t getLength() const; + /// Returns zero-terminated C string pointer. /// const char* getCPtr() const; + /// Implicitly converts StringT to StringView. + /// + operator StringView() const; + protected: - int32_t m_capacity; + const char* m_ptr; + int32_t m_len; + int32_t m_capacity; }; /// Returns true if character is part of white space set. diff --git a/libs/bx/src/bx.cpp b/libs/bx/src/bx.cpp index 1ea805a..a89f214 100644 --- a/libs/bx/src/bx.cpp +++ b/libs/bx/src/bx.cpp @@ -5,6 +5,7 @@ #include #include +#include #if !BX_CRT_NONE # include // memcpy, memmove, memset @@ -22,7 +23,7 @@ namespace bx return LocationFull(_function, _filePath, _line); } - static bool defaultAssertHandler(const Location& _location, const char* _format, va_list _argList) + static bool defaultAssertHandler(const Location& _location, uint32_t _skip, const char* _format, va_list _argList) { char temp[8192]; int32_t total = 0; @@ -41,7 +42,7 @@ namespace bx total += write(&smb, "\n\n", &err); uintptr_t stack[32]; - const uint32_t num = getCallStack(2 /* skip self */, BX_COUNTOF(stack), stack); + const uint32_t num = getCallStackExact(2 /* skip self */ + _skip, BX_COUNTOF(stack), stack); total += writeCallstack(&smb, stack, num, &err); total += write(&smb, &err, @@ -80,11 +81,11 @@ namespace bx } } - bool assertFunction(const Location& _location, const char* _format, ...) + bool assertFunction(const Location& _location, uint32_t _skip, const char* _format, ...) { va_list argList; va_start(argList, _format); - const bool result = s_assertHandler(_location, _format, argList); + const bool result = s_assertHandler(_location, _skip + 1 /* skip self */, _format, argList); va_end(argList); return result; diff --git a/libs/bx/src/debug.cpp b/libs/bx/src/debug.cpp index e4ea549..b557ffd 100644 --- a/libs/bx/src/debug.cpp +++ b/libs/bx/src/debug.cpp @@ -6,8 +6,34 @@ #include #include // isPrint #include // WriterI +#include // exit +#include // ProcessReader + #include // PRIx* +#if BX_PLATFORM_LINUX || BX_PLATFORM_OSX +# include // abi::__cxa_demangle +# include // backtrace, backtrace_symbols +# include // _Unwind_Backtrace +# include +#endif // BX_PLATFORM_* + +#ifndef BX_CONFIG_CALLSTACK_USE_EXECINFO +# if defined(_EXECINFO_H) || defined(_EXECINFO_H_) +# define BX_CONFIG_CALLSTACK_USE_EXECINFO 1 +# else +# define BX_CONFIG_CALLSTACK_USE_EXECINFO 0 +# endif // defined... +#endif // BX_CONFIG_CALLSTACK_USE_EXECINFO + +#ifndef BX_CONFIG_CALLSTACK_USE_UNWIND +# if defined(_UNWIND_H) || defined(__UNWIND_H__) +# define BX_CONFIG_CALLSTACK_USE_UNWIND 1 +# else +# define BX_CONFIG_CALLSTACK_USE_UNWIND 0 +# endif // defined... +#endif // BX_CONFIG_CALLSTACK_USE_UNWIND + #ifndef BX_CONFIG_CALLSTACK_USE_LIB_BACKTRACE # define BX_CONFIG_CALLSTACK_USE_LIB_BACKTRACE 0 #elif BX_CONFIG_CALLSTACK_USE_LIB_BACKTRACE @@ -17,11 +43,24 @@ #endif // BX_CONFIG_CALLSTACK_USE_LIB_BACKTRACE #if BX_CONFIG_CALLSTACK_USE_LIB_BACKTRACE -# include // backtrace # include // backtrace_syminfo -# include // abi::__cxa_demangle #endif // BX_CONFIG_CALLSTACK_* +#ifndef BX_CONFIG_EXCEPTION_HANDLING_USE_WINDOWS_SEH +# define BX_CONFIG_EXCEPTION_HANDLING_USE_WINDOWS_SEH BX_PLATFORM_WINDOWS +#endif // BX_CONFIG_EXCEPTION_HANDLING_USE_WINDOWS_SEH + +#ifndef BX_CONFIG_EXCEPTION_HANDLING_USE_POSIX_SIGNALS +# define BX_CONFIG_EXCEPTION_HANDLING_USE_POSIX_SIGNALS ( (0 \ + | BX_PLATFORM_LINUX \ + | BX_PLATFORM_OSX \ + ) && !BX_CRT_NONE) +#endif // BX_CONFIG_EXCEPTION_HANDLING_USE_POSIX_SIGNALS + +#if BX_CONFIG_EXCEPTION_HANDLING_USE_POSIX_SIGNALS +# include +#endif // BX_CONFIG_EXCEPTION_HANDLING_* + #if BX_CRT_NONE # include #elif BX_PLATFORM_ANDROID @@ -213,21 +252,331 @@ namespace bx return &s_debugOut; } -#if BX_CONFIG_CALLSTACK_USE_LIB_BACKTRACE - uint32_t getCallStack(uint32_t _skip, uint32_t _max, uintptr_t* _outStack) +#if BX_CONFIG_CALLSTACK_USE_UNWIND + struct UnwindCallbackData + { + uint32_t skip; + uint32_t max; + uint32_t num; + uintptr_t* outStack; + }; + + static _Unwind_Reason_Code unwindCallback(struct _Unwind_Context* _ctx, void* _arg) + { + UnwindCallbackData& ucd = *(UnwindCallbackData*)_arg; + + if (ucd.num < ucd.max) + { + if (0 < ucd.skip) + { + --ucd.skip; + return _URC_NO_REASON; + } + + uintptr_t addr = _Unwind_GetIP(_ctx); + if (0 == addr) + { + return _URC_END_OF_STACK; + } + + ucd.outStack[ucd.num++] = uintptr_t(addr); + return _URC_NO_REASON; + } + + return _URC_END_OF_STACK; + } +#endif // BX_CONFIG_CALLSTACK_USE_UNWIND + + BX_NO_INLINE uint32_t getCallStackUnwind(uint32_t _skip, uint32_t _max, uintptr_t* _outStack) + { +#if BX_CONFIG_CALLSTACK_USE_UNWIND + UnwindCallbackData ucd = + { + .skip = _skip + 1, + .max = _max, + .num = 0, + .outStack = _outStack, + }; + + _Unwind_Backtrace(unwindCallback, &ucd); + + return ucd.num; +#else + BX_UNUSED(_skip, _max, _outStack); + return 0; +#endif // BX_CONFIG_CALLSTACK_USE_UNWIND + } + + BX_NO_INLINE uint32_t getCallStackExecInfoBacktrace(uint32_t _skip, uint32_t _max, uintptr_t* _outStack) { +#if BX_CONFIG_CALLSTACK_USE_EXECINFO const uint32_t max = _skip+_max+1; - void** tmp = (void**)BX_STACK_ALLOC(sizeof(uintptr_t)*max); + uintptr_t* tmp = (uintptr_t*)BX_STACK_ALLOC(sizeof(uintptr_t)*max); - const uint32_t numFull = backtrace(tmp, max); + const uint32_t numFull = backtrace( (void**)tmp, max); const uint32_t skip = min(_skip + 1 /* skip self */, numFull); const uint32_t num = numFull - skip; memCopy(_outStack, tmp + skip, sizeof(uintptr_t)*num); return num; +#else + BX_UNUSED(_skip, _max, _outStack); + return 0; +#endif // BX_CONFIG_CALLSTACK_USE_EXECINFO + } + + static const uintptr_t* nextStackFrame(const uintptr_t* _stackFrame) + { + const uintptr_t* newStackFrame = (const uintptr_t*)*_stackFrame; + + if (newStackFrame <= _stackFrame) + { + return NULL; + } + + if (uintptr_t(newStackFrame) & (sizeof(uintptr_t) - 1) ) + { + return NULL; + } + + return newStackFrame; + } + + BX_NO_INLINE uint32_t getCallStackSystemVAbi(uint32_t _skip, uint32_t _max, uintptr_t* _outStack) + { + if (BX_ENABLED( (BX_PLATFORM_LINUX || BX_PLATFORM_OSX) && BX_ARCH_64BIT) ) + { +#if BX_COMPILER_GCC || BX_COMPILER_CLANG + const uintptr_t* stackFrame = (const uintptr_t*)__builtin_frame_address(0); +#else + const uintptr_t* stackFrame = NULL; +#endif // BX_COMPILER_... + + uint32_t num = 0; + + while (NULL != stackFrame + && num < _max) + { + if (uintptr_t(0) == stackFrame[1]) + { + break; + } + + if (BX_UNLIKELY(0 < _skip) ) + { + --_skip; + } + else + { + _outStack[num++] = stackFrame[1]; + } + + stackFrame = nextStackFrame(stackFrame); + } + + return num; + } + + return 0; + } + + BX_NO_INLINE uint32_t getCallStackGccBuiltin(uint32_t _skip, uint32_t _max, uintptr_t* _outStack) + { +#if BX_COMPILER_GCC || BX_COMPILER_CLANG + BX_PRAGMA_DIAGNOSTIC_PUSH(); + BX_PRAGMA_DIAGNOSTIC_IGNORED_CLANG_GCC("-Wframe-address"); + + uint32_t num = 0; + +#define RETURN_ADDRESS(_x) \ + if (num < _max) \ + { \ + if (0 < _skip) \ + { \ + --_skip; \ + } \ + else \ + { \ + if (NULL == __builtin_frame_address(_x) ) \ + { \ + return num; \ + } \ + \ + void* addr = __builtin_return_address(_x); \ + \ + if (NULL == addr) \ + { \ + return num; \ + } \ + \ + _outStack[num++] = uintptr_t(addr); \ + } \ + } \ + else \ + { \ + return num; \ + } + + RETURN_ADDRESS(0); + RETURN_ADDRESS(1); + RETURN_ADDRESS(2); + RETURN_ADDRESS(3); + RETURN_ADDRESS(4); + RETURN_ADDRESS(5); + RETURN_ADDRESS(6); + RETURN_ADDRESS(7); + RETURN_ADDRESS(8); + RETURN_ADDRESS(9); + + RETURN_ADDRESS(10); + RETURN_ADDRESS(11); + RETURN_ADDRESS(12); + RETURN_ADDRESS(13); + RETURN_ADDRESS(14); + RETURN_ADDRESS(15); + RETURN_ADDRESS(16); + RETURN_ADDRESS(17); + RETURN_ADDRESS(18); + RETURN_ADDRESS(19); + + RETURN_ADDRESS(20); + RETURN_ADDRESS(21); + RETURN_ADDRESS(22); + RETURN_ADDRESS(23); + RETURN_ADDRESS(24); + RETURN_ADDRESS(25); + RETURN_ADDRESS(26); + RETURN_ADDRESS(27); + RETURN_ADDRESS(28); + RETURN_ADDRESS(29); + + RETURN_ADDRESS(30); + RETURN_ADDRESS(31); + +#undef RETURN_ADDRESS + + BX_PRAGMA_DIAGNOSTIC_POP(); + + return num; +#else + BX_UNUSED(_skip, _max, _outStack); + return 0; +#endif // BX_COMPILER_GCC || BX_COMPILER_CLANG + } + +#if !BX_PLATFORM_WINDOWS +# define __stdcall +#endif // !BX_PLATFORM_WINDOWS + + typedef uint16_t (__stdcall* RtlCaptureStackBackTraceFn)(uint32_t _framesToSkip, uint32_t _framesToCapture, void** _outBacktrace, uint32_t* _outhash); + + uint16_t __stdcall stubTryLoadRtlCaptureStackBackTrace(uint32_t _framesToSkip, uint32_t _framesToCapture, void** _outBacktrace, uint32_t* _outhash); + RtlCaptureStackBackTraceFn RtlCaptureStackBackTrace = stubTryLoadRtlCaptureStackBackTrace; + + uint16_t __stdcall stubRtlCaptureStackBackTrace(uint32_t _framesToSkip, uint32_t _framesToCapture, void** _outBacktrace, uint32_t* _outhash) + { + BX_UNUSED(_framesToSkip, _framesToCapture, _outBacktrace, _outhash); + return 0; + } + + uint16_t __stdcall stubTryLoadRtlCaptureStackBackTrace(uint32_t _framesToSkip, uint32_t _framesToCapture, void** _outBacktrace, uint32_t* _outhash) + { + void* kernel32Dll = bx::dlopen("kernel32.dll"); + + RtlCaptureStackBackTraceFn fn = NULL != kernel32Dll + ? bx::dlsym(kernel32Dll, "RtlCaptureStackBackTrace") + : NULL + ; + + RtlCaptureStackBackTrace = NULL != fn + ? fn + : stubRtlCaptureStackBackTrace + ; + + return RtlCaptureStackBackTrace(_framesToSkip, _framesToCapture, _outBacktrace, _outhash); + } + + BX_NO_INLINE uint32_t getCallStackWinRtl(uint32_t _skip, uint32_t _max, uintptr_t* _outStack) + { +#if BX_PLATFORM_WINDOWS + return RtlCaptureStackBackTrace(_skip + 1 /* skip self */, _max, (void**)_outStack, NULL); +#else + BX_UNUSED(_skip, _max, _outStack); + return 0; +#endif // BX_PLATFORM_WINDOWS } + BX_NO_INLINE uint32_t getCallStackWinAbi(uint32_t _skip, uint32_t _max, uintptr_t* _outStack) + { + if (BX_ENABLED(BX_PLATFORM_WINDOWS && BX_CPU_X86 && BX_ARCH_32BIT) ) + { + const uintptr_t* stackFrame = (uintptr_t*)&_skip - 2; + + uint32_t num = 0; + + while (NULL != stackFrame + && num < _max) + { + if (uintptr_t(0) == stackFrame[1]) + { + break; + } + + if (BX_UNLIKELY(0 < _skip) ) + { + --_skip; + } + else + { + _outStack[num++] = stackFrame[1]; + } + + stackFrame = nextStackFrame(stackFrame); + } + + return num; + } + else if (BX_ENABLED(BX_PLATFORM_WINDOWS && BX_CPU_X86 && BX_ARCH_64BIT) ) + { + return getCallStackWinRtl(_skip + 1 /* skip self */, _max, _outStack); + } + + return 0; + } + + BX_NO_INLINE uint32_t getCallStackFast(uint32_t _skip, uint32_t _max, uintptr_t* _outStack) + { +#if BX_PLATFORM_LINUX || BX_PLATFORM_OSX + return getCallStackSystemVAbi(_skip + 1 /* skip self */, _max, _outStack); +#elif BX_PLATFORM_WINDOWS + return getCallStackWinAbi(_skip + 1 /* skip self */, _max, _outStack); +#elif BX_COMPILER_GCC || BX_COMPILER_CLANG + return getCallStackGccBuiltin(_skip + 1 /* skip self */, _max, _outStack); +#else + BX_UNUSED(_skip, _max, _outStack); + return 0; +#endif // BX_PLATFORM_* + } + + BX_NO_INLINE uint32_t getCallStackExact(uint32_t _skip, uint32_t _max, uintptr_t* _outStack) + { +#if BX_PLATFORM_LINUX + return getCallStackUnwind(_skip + 1 /* skip self */, _max, _outStack); +#elif BX_PLATFORM_OSX + return getCallStackExecInfoBacktrace(_skip + 1 /* skip self */, _max, _outStack); +#elif BX_PLATFORM_WINDOWS + return getCallStackWinRtl(_skip + 1 /* skip self */, _max, _outStack); +#else + BX_UNUSED(_skip, _max, _outStack); + return 0; +#endif // BX_PLATFORM_* + } + + static constexpr uint32_t kWidth = 80; + static constexpr uint32_t kWidthPc = 16; + +#if BX_CONFIG_CALLSTACK_USE_LIB_BACKTRACE struct StackTraceContext { StackTraceContext() @@ -274,7 +623,7 @@ namespace bx return 1; } - int32_t writeCallstack(WriterI* _writer, uintptr_t* _stack, uint32_t _num, Error* _err) + int32_t writeCallstack(WriterI* _writer, const uintptr_t* _stack, uint32_t _num, Error* _err) { BX_ERROR_SCOPE(_err); @@ -283,15 +632,18 @@ namespace bx int32_t total = write(_writer, _err, "Callstack (%d):\n", _num); + total += write(_writer, _err, "\t #: %-*s Line %-*s Function ---\n", kWidth, "File ---", kWidthPc, "PC ---"); + CallbackData cbData; for (uint32_t ii = 0; ii < _num && _err->isOk(); ++ii) { backtrace_pcinfo(s_stCtx.state, _stack[ii], backtraceFullCb, NULL, &cbData); - StringView demangledName; + StringView demangledName = ""; - if (1 == backtrace_syminfo(s_stCtx.state, _stack[ii], backtraceSymInfoCb, NULL, &cbData) ) + if (1 == backtrace_syminfo(s_stCtx.state, _stack[ii], backtraceSymInfoCb, NULL, &cbData) + && !cbData.resolvedName.isEmpty() ) { demangleLen = BX_COUNTOF(demangleBuf); int32_t demangleStatus; @@ -299,27 +651,19 @@ namespace bx if (0 == demangleStatus) { - demangledName.set(demangleBuf, demangleLen); - } - else - { - demangledName = cbData.resolvedName; + demangledName.set({demangleBuf, narrowCast(demangleLen) }); } } - else - { - demangledName = "???"; - } - constexpr uint32_t width = 40; - const StringView fn = strTail(cbData.fileName, width); + const StringView fileName = strTail(cbData.fileName, kWidth); total += write(_writer, _err - , "\t%2d: %-*S % 5d: %p %S\n" + , "\t%2d: %-*S % 5d %*p %S\n" , ii - , width - , &fn + , kWidth + , &fileName , cbData.line + , kWidthPc , _stack[ii] , &demangledName ); @@ -340,27 +684,662 @@ namespace bx return total; } -#else +#elif BX_PLATFORM_WINDOWS - uint32_t getCallStack(uint32_t _skip, uint32_t _max, uintptr_t* _outStack) + struct DbgHelpSymbolInfo { - BX_UNUSED(_skip, _max, _outStack); - return 0; + uint32_t SizeOfStruct; + uint32_t TypeIndex; + uint64_t Reserved[2]; + uint32_t Index; + uint32_t Size; + uint64_t ModBase; + uint32_t Flags; + uint64_t Value; + uint64_t Address; + uint32_t Register; + uint32_t Scope; + uint32_t Tag; + uint32_t NameLen; + uint32_t MaxNameLen; + char Name[512]; + }; + + struct ImageHlpLine + { + uint32_t SizeOfStruct; + void* Key; + uint32_t LineNumber; + const char* FileName; + uintptr_t Address; + }; + + typedef bool (__stdcall* SymInitializeFn)(void* _process, const char* _userSearchPath, bool _invadeProcess); + typedef bool (__stdcall* SymCleanupFn)(void* _process); + typedef bool (__stdcall* SymFromAddrFn)(void* _process, uint64_t _address, uint64_t* _outDisplacement, DbgHelpSymbolInfo* _inoutSymbol); + typedef bool (__stdcall* SymGetLineFromAddrFn)(void* _process, uintptr_t _address, uint32_t* _outDisplacement, ImageHlpLine* _inoutLine); + + constexpr uint32_t kSymOptUndName = 0x00000002; + constexpr uint32_t kSymOptDeferredLoads = 0x00000004; + constexpr uint32_t kSymOptLoadLines = 0x00000010; + + static void* kCurrentProcess = (void*)UINTPTR_MAX; + + typedef uint32_t (__stdcall* SymSetOptionsFn)(uint32_t _options); + + struct DbgHelpSymbolResolve + { + DbgHelpSymbolResolve() + { + m_imageHlpDll = dlopen("dbghelp.dll"); + + if (NULL != m_imageHlpDll) + { + m_symInitialize = dlsym(m_imageHlpDll, "SymInitialize"); + m_symCleanup = dlsym(m_imageHlpDll, "SymCleanup"); + m_symFromAddr = dlsym(m_imageHlpDll, "SymFromAddr"); + m_symSetOptions = dlsym(m_imageHlpDll, "SymSetOptions"); + m_symGetLineFromAddr = dlsym(m_imageHlpDll, BX_ARCH_32BIT ? "SymGetLineFromAddr" : "SymGetLineFromAddr64"); + + if (true + && NULL != m_symInitialize + && NULL != m_symCleanup + && NULL != m_symFromAddr + && NULL != m_symSetOptions + && NULL != m_symGetLineFromAddr + ) + { + m_symSetOptions(kSymOptUndName | kSymOptDeferredLoads | kSymOptLoadLines); + + char symCache[1024] = "SRV*"; + uint32_t len = BX_COUNTOF(symCache) - 4; + if (getEnv(symCache + 4, &len, "TEMP") ) + { + len += 4; + snprintf(symCache + len, BX_COUNTOF(symCache) - len, "\\SymbolCache*http://msdl.microsoft.com/download/symbols;"); + } + else + { + symCache[0] = '\0'; + } + + if (!m_symInitialize(kCurrentProcess, symCache, true) ) + { + cleanup(); + } + } + } + } + + ~DbgHelpSymbolResolve() + { + cleanup(); + } + + bool hasSymbols() const + { + return NULL != m_imageHlpDll; + } + + bool resolve(uintptr_t _addr, FixedString1024& _outFunctionName, FilePath& _outFilePath, int32_t& _outLine) const + { + if (hasSymbols() ) + { + DbgHelpSymbolInfo dhsi = {}; + dhsi.SizeOfStruct = sizeof(DbgHelpSymbolInfo) - sizeof(dhsi.Name); + dhsi.MaxNameLen = sizeof(dhsi.Name); + + ImageHlpLine ihl = {}; + ihl.SizeOfStruct = sizeof(ImageHlpLine); + + uint32_t lineDisplacement; + + if (true + && m_symFromAddr(kCurrentProcess, _addr, NULL, &dhsi) + && m_symGetLineFromAddr(kCurrentProcess, _addr, &lineDisplacement, &ihl) + ) + { + _outFunctionName.set(dhsi.Name); + _outFilePath.set(ihl.FileName); + _outLine = ihl.LineNumber; + + return true; + } + } + + return false; + } + + void cleanup() + { + m_symCleanup(kCurrentProcess); + + m_symInitialize = NULL; + m_symCleanup = NULL; + m_symFromAddr = NULL; + m_symSetOptions = NULL; + m_symGetLineFromAddr = NULL; + + dlclose(m_imageHlpDll); + + m_imageHlpDll = NULL; + } + + void* m_imageHlpDll = NULL; + + SymInitializeFn m_symInitialize = NULL; + SymCleanupFn m_symCleanup = NULL; + SymFromAddrFn m_symFromAddr = NULL; + SymSetOptionsFn m_symSetOptions = NULL; + SymGetLineFromAddrFn m_symGetLineFromAddr = NULL; + }; + + static DbgHelpSymbolResolve s_dbgHelpSymbolResolve; + + int32_t writeCallstack(WriterI* _writer, const uintptr_t* _stack, uint32_t _num, Error* _err) + { + int32_t total = write(_writer, _err, "Callstack (%d):\n", _num); + + total += write(_writer, _err, "\t #: %-*s Line %-*s Function ---\n", kWidth, "File ---", kWidthPc, "PC ---"); + + for (uint32_t ii = 0; ii < _num && _err->isOk(); ++ii) + { + FixedString1024 functionName; + FilePath filePath; + int32_t line; + + if (!s_dbgHelpSymbolResolve.resolve(_stack[ii], functionName, filePath, line)) + { + functionName = ""; + filePath = ""; + line = -1; + } + + const StringView fileName = strTail(filePath, kWidth); + + total += write(_writer, _err + , "\t%2d: %-*S % 5d %*p %s\n" + , ii + , kWidth + , &fileName + , line + , kWidthPc + , _stack[ii] + , functionName.getCPtr() + ); + } + + return total; } - int32_t writeCallstack(WriterI* _writer, uintptr_t* _stack, uint32_t _num, Error* _err) +#elif BX_CONFIG_CALLSTACK_USE_EXECINFO + + StringView strConsumeTo(StringView& _input, const StringView& _find) { - BX_UNUSED(_writer, _stack, _num, _err); - return 0; + const StringView to = strFind(_input, _find); + + if (!to.isEmpty() ) + { + const StringView result(_input.getPtr(), to.getPtr() ); + + _input.set(to.getTerm(), _input.getTerm() ); + + return result; + } + + return StringView(); + } + + int32_t writeCallstack(WriterI* _writer, const uintptr_t* _stack, uint32_t _num, Error* _err) + { + int32_t total = write(_writer, _err, "Callstack (%d):\n", _num); + + // Linux: + // ([function]<+offset>)[
] + // + // macOS: + //
+ + char** symbols = backtrace_symbols( (void* const*) _stack, _num); + +# if BX_PLATFORM_LINUX + + struct Addr2Line + { + StringView functionName; + StringView filePath; + int32_t line; + }; + + char addr2LineBuffer[32<<10]; + Addr2Line* addr2Line = (Addr2Line*)BX_STACK_ALLOC(_num * sizeof(Addr2Line) ); + + { + FixedStringT<4096> args; + FilePath first; + + for (uint32_t ii = 0; ii < _num; ++ii) + { + Addr2Line& a2l = addr2Line[ii]; + + a2l.functionName = ""; + a2l.filePath = ""; + a2l.line = -1; + } + + for (uint32_t ii = 0; ii < _num; ++ii) + { + const StringView line(symbols[ii]); + + const StringView parenS = strFind(line, '('); + + if (parenS.isEmpty() ) + { + continue; + } + + const FilePath filePath({ line.getPtr(), parenS.getPtr() }); + + StringView offset(parenS.getTerm(), line.getTerm() ); + const StringView parenE = strFind(offset, ')'); + + if (parenE.isEmpty() ) + { + continue; + } + + offset.set(parenS.getTerm(), parenE.getPtr() ); + + if (first.isEmpty() ) + { + first.set(filePath); + + args.append("-C -f -e "); + args.append(filePath); + } + + if (first != filePath) + { + continue; + } + + args.append(" "); + args.append(offset); + } + + { + ProcessReader reader; + if (open(&reader, "addr2line", args, ErrorIgnore{}) ) + { + int32_t bytes = read(&reader, addr2LineBuffer, sizeof(addr2LineBuffer), ErrorIgnore{}); + + if (-1 != bytes) + { + uint32_t ii = 0; + for (LineReader lr({addr2LineBuffer, bytes}); !lr.isDone(); ++ii) + { + const StringView functionName = lr.next(); + + const StringView filePath = lr.next(); + + const StringView colon = strFind(filePath, ':'); + + if (!colon.isEmpty() ) + { + Addr2Line& a2l = addr2Line[ii]; + + a2l.functionName = functionName; + a2l.filePath = StringView(filePath.getPtr(), colon.getPtr() ); + fromString(&a2l.line, StringView(strWord({ colon.getTerm(), filePath.getTerm() }) ) ); + } + } + } + + close(&reader); + } + } + } +# elif BX_PLATFORM_OSX + + char atosBuffer[32<<10]; + +# endif // BX_PLATFORM_* + + total += write(_writer, _err, "\t #: %-*s Line %-*s Function ---\n", kWidth, "File ---", kWidthPc, "PC ---"); + + for (uint32_t ii = 0; ii < _num && _err->isOk(); ++ii) + { + FixedString1024 functionName; + FilePath filePath(""); + int32_t line = -1; + +# if BX_PLATFORM_LINUX + filePath = addr2Line[ii].filePath; + line = addr2Line[ii].line; + functionName = addr2Line[ii].functionName; + +# elif BX_PLATFORM_OSX + StringView atosFunctionName(""); + + functionName.set( + strWord( + strLTrimSpace( + strLTrimNonSpace( + strLTrimSpace( + strLTrimNonSpace( + strLTrimSpace( + strLTrimNonSpace( + symbols[ii] + ) ) ) ) ) ) ) + ); + + Dl_info info; + dladdr( (const void*)_stack[ii], &info); + + { + char args[4096]; + + snprintf(args, BX_COUNTOF(args), "--fullPath -o %s -l %x %x" + , info.dli_fname + , info.dli_fbase + , _stack[ii] + ); + + ProcessReader reader; + if (open(&reader, "atos", args, ErrorIgnore{}) ) + { + int32_t bytes = read(&reader, atosBuffer, sizeof(atosBuffer), ErrorIgnore{}); + + if (-1 != bytes) + { + for (LineReader lr({atosBuffer, bytes}); !lr.isDone();) + { + StringView input = lr.next(); + + atosFunctionName = strConsumeTo(input, " ("); + + if (atosFunctionName.isEmpty() ) + { + break; + } + + filePath = strConsumeTo(input, ":"); + + if (filePath.isEmpty() ) + { + filePath = ""; + break; + } + + const StringView lineStr = strConsumeTo(input, ")"); + + if (!lineStr.isEmpty() ) + { + fromString(&line, lineStr); + } + } + } + + close(&reader); + } + } + + char demangleBuf[4096]; + size_t demangleLen = BX_COUNTOF(demangleBuf); + int32_t demangleStatus; + abi::__cxa_demangle(functionName.getCPtr(), demangleBuf, &demangleLen, &demangleStatus); + + if (0 == demangleStatus) + { + functionName.set({demangleBuf, narrowCast(demangleLen) }); + } + else + { + functionName = atosFunctionName; + } + +# endif // BX_PLATFORM_* + + const StringView fileName = strTail(filePath, kWidth); + + total += write(_writer, _err + , "\t%2d: %-*S % 5d %*p %s\n" + , ii + , kWidth + , &fileName + , line + , kWidthPc + , _stack[ii] + , functionName.getCPtr() + ); + } + + /*backtrace_symbols_*/::free(symbols); + + return total; + } + +#else + + int32_t writeCallstack(WriterI* _writer, const uintptr_t* _stack, uint32_t _num, Error* _err) + { + int32_t total = write(_writer, _err, "Callstack (%d): - symbol resolve is not available\n", _num); + + total += write(_writer, _err, "\t #: %-*s Line %-*s Function ---\n", kWidth, "File ---", kWidthPc, "PC ---"); + + const StringView fileName = ""; + const StringView demangledName = ""; + + for (uint32_t ii = 0; ii < _num && _err->isOk(); ++ii) + { + total += write(_writer, _err + , "\t%2d: %-*S % 5d %*p %S\n" + , ii + , kWidth + , &fileName + , -1 + , kWidthPc + , _stack[ii] + , &demangledName + ); + } + + return total; } #endif // BX_CONFIG_CALLSTACK_* void debugOutputCallstack(uint32_t _skip) { + char temp[8192]; + StaticMemoryBlockWriter smb(temp, BX_COUNTOF(temp) ); + uintptr_t stack[32]; - const uint32_t num = getCallStack(_skip + 1 /* skip self */, BX_COUNTOF(stack), stack); - writeCallstack(getDebugOut(), stack, num, ErrorIgnore{}); + const uint32_t num = getCallStackExact(_skip + 1 /* skip self */, BX_COUNTOF(stack), stack); + const int32_t total = writeCallstack(&smb, stack, num, ErrorIgnore{}); + + write(getDebugOut(), temp, total, ErrorIgnore{}); + } + +#if BX_CONFIG_EXCEPTION_HANDLING_USE_POSIX_SIGNALS + struct SignalInfo + { + int32_t signalId; + const char* name; + }; + + static const SignalInfo s_signalInfo[] = + { // Linux + { /* 4 */ SIGILL, "SIGILL - Illegal instruction signal." }, + { /* 6 */ SIGABRT, "SIGABRT - Abort signal." }, + { /* 8 */ SIGFPE, "SIGFPE - Floating point error signal." }, + { /* 11 */ SIGSEGV, "SIGSEGV - Segmentation violation signal." }, + }; + + struct ExceptionHandler + { + ExceptionHandler() + { + BX_TRACE("ExceptionHandler - POSIX"); + + stack_t stack = {}; + stack.ss_sp = s_stack; + stack.ss_size = sizeof(s_stack); + stack.ss_flags = 0; + sigaltstack(&stack, &m_oldStack); + + struct sigaction sa = {}; + sa.sa_handler = NULL; + sa.sa_sigaction = signalActionHandler; + sa.sa_mask = { 0 }; + sa.sa_flags = SA_ONSTACK | SA_SIGINFO; + + for (uint32_t ii = 0; ii < BX_COUNTOF(s_signalInfo); ++ii) + { + sigaction(s_signalInfo[ii].signalId, &sa, &m_oldSignalAction[ii]); + } + } + + ~ExceptionHandler() + { + } + + static void signalActionHandler(int32_t _signalId, siginfo_t* _info, void* _context) + { + BX_UNUSED(_context); + + const char* name = "Unknown signal?"; + + for (uint32_t ii = 0; ii < BX_COUNTOF(s_signalInfo); ++ii) + { + const SignalInfo& signalInfo = s_signalInfo[ii]; + + if (signalInfo.signalId == _signalId) + { + name = signalInfo.name; + break; + } + } + + if (assertFunction(Location("Exception Handler", UINT32_MAX), 2 + , "%s SIGNAL %d, ERRNO %d, CODE %d" + , name + , _info->si_signo + , _info->si_errno + , _info->si_code + ) ) + { + exit(kExitFailure, false); + } + } + + static constexpr uint32_t kExceptionStackSize = 64<<10; + + static char s_stack[kExceptionStackSize]; + + stack_t m_oldStack; + struct sigaction m_oldSignalAction[BX_COUNTOF(s_signalInfo)]; + }; + + char ExceptionHandler::s_stack[kExceptionStackSize]; + +#elif BX_CONFIG_EXCEPTION_HANDLING_USE_WINDOWS_SEH + + struct ExceptionInfo + { + uint32_t exceptionCode; + const char* name; + }; + + static const ExceptionInfo s_exceptionInfo[] = + { // Windows + { /* EXCEPTION_ACCESS_VIOLATION */ 0xc0000005u, "Access violation." }, + { /* EXCEPTION_ILLEGAL_INSTRUCTION */ 0xc000001du, "Illegal instruction." }, + { /* EXCEPTION_STACK_OVERFLOW */ 0xc00000fdu, "Stack overflow." }, + }; + + struct ExceptionRecord + { + uint32_t exceptionCode; + uint32_t exceptionFlags; + + ExceptionRecord* exceptionRecord; + + uintptr_t exceptionAddress; + uint32_t numberParameters; + uintptr_t exceptionInformation[15]; + }; + + struct ExceptionPointers + { + ExceptionRecord* exceptionRecord; + void* contextRecord; + }; + + typedef uint32_t (__stdcall* TopLevelExceptionFilterFn)(ExceptionPointers* _exceptionInfo); + + extern "C" __declspec(dllimport) TopLevelExceptionFilterFn __stdcall SetUnhandledExceptionFilter(TopLevelExceptionFilterFn _topLevelExceptionFilter); + + struct ExceptionHandler + { + ExceptionHandler() + { + BX_TRACE("ExceptionHandler - Windows SEH"); + SetUnhandledExceptionFilter(topLevelExceptionFilter); + } + + static uint32_t __stdcall topLevelExceptionFilter(ExceptionPointers* _info) + { + const char* name = "Unknown signal?"; + + const uint32_t exceptionCode = _info->exceptionRecord->exceptionCode; + + for (uint32_t ii = 0; ii < BX_COUNTOF(s_exceptionInfo); ++ii) + { + const ExceptionInfo& signal = s_exceptionInfo[ii]; + + if (signal.exceptionCode == exceptionCode) + { + name = signal.name; + break; + } + } + + if (assertFunction(Location("Exception Handler", UINT32_MAX), 7 /* topLevelExceptionFilter function + 6 deep stack of OS exception handler */ + , "%s Exception Code %x" + , name + , _info->exceptionRecord->exceptionCode + ) ) + { + exit(kExitFailure, false); + } + + return 0 /* EXCEPTION_CONTINUE_SEARCH */; + } + }; + +#else // Noop exception handler + + class ExceptionHandler + { + public: + ExceptionHandler() + { + BX_TRACE("ExceptionHandler - Noop"); + } + }; + +#endif // BX_CONFIG_EXCEPTION_HANDLING_* + + void installExceptionHandler() + { + static bool s_installed = false; + + if (!s_installed) + { + s_installed = true; + + static ExceptionHandler s_exceptionHandler; + } } } // namespace bx diff --git a/libs/bx/src/filepath.cpp b/libs/bx/src/filepath.cpp index ec3b652..9dfc78e 100644 --- a/libs/bx/src/filepath.cpp +++ b/libs/bx/src/filepath.cpp @@ -303,6 +303,12 @@ namespace bx set(_filePath); } + FilePath& FilePath::operator=(const char* _rhs) + { + set(_rhs); + return *this; + } + FilePath& FilePath::operator=(const StringView& _rhs) { set(_rhs); diff --git a/libs/bx/src/os.cpp b/libs/bx/src/os.cpp index 41b97a0..47465a2 100644 --- a/libs/bx/src/os.cpp +++ b/libs/bx/src/os.cpp @@ -361,9 +361,18 @@ namespace bx #endif // BX_PLATFORM_LINUX } - void exit(int32_t _exitCode) + void exit(int32_t _exitCode, bool _cleanup) { - ::exit(_exitCode); + if (_cleanup) + { + ::exit(_exitCode); + } + +#if BX_PLATFORM_WINDOWS + TerminateProcess(GetCurrentProcess(), _exitCode); +#else + _Exit(_exitCode); +#endif // BX_PLATFORM_* } void* memoryMap(void* _address, size_t _size, Error* _err) diff --git a/src/bgfx.zig b/src/bgfx.zig index d5a4344..b35ae19 100644 --- a/src/bgfx.zig +++ b/src/bgfx.zig @@ -1,4 +1,4 @@ -// Copyright 2011-2024 Branimir Karadzic. All rights reserved. +// Copyright 2011-2025 Branimir Karadzic. All rights reserved. // License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE // @@ -373,31 +373,31 @@ pub const DebugFlags_Text: DebugFlags = 0x00000008; pub const DebugFlags_Profiler: DebugFlags = 0x00000010; pub const BufferFlags = u16; -/// 1 8-bit value +/// 1 x 8-bit value pub const BufferFlags_ComputeFormat8x1: BufferFlags = 0x0001; -/// 2 8-bit values +/// 2 x 8-bit values pub const BufferFlags_ComputeFormat8x2: BufferFlags = 0x0002; -/// 4 8-bit values +/// 4 x 8-bit values pub const BufferFlags_ComputeFormat8x4: BufferFlags = 0x0003; -/// 1 16-bit value +/// 1 x 16-bit value pub const BufferFlags_ComputeFormat16x1: BufferFlags = 0x0004; -/// 2 16-bit values +/// 2 x 16-bit values pub const BufferFlags_ComputeFormat16x2: BufferFlags = 0x0005; -/// 4 16-bit values +/// 4 x 16-bit values pub const BufferFlags_ComputeFormat16x4: BufferFlags = 0x0006; -/// 1 32-bit value +/// 1 x 32-bit value pub const BufferFlags_ComputeFormat32x1: BufferFlags = 0x0007; -/// 2 32-bit values +/// 2 x 32-bit values pub const BufferFlags_ComputeFormat32x2: BufferFlags = 0x0008; -/// 4 32-bit values +/// 4 x 32-bit values pub const BufferFlags_ComputeFormat32x4: BufferFlags = 0x0009; pub const BufferFlags_ComputeFormatShift: BufferFlags = 0; pub const BufferFlags_ComputeFormatMask: BufferFlags = 0x000f; @@ -639,84 +639,87 @@ pub const CapsFlags_ConservativeRaster: CapsFlags = 0x0000000000000008; /// Draw indirect is supported. pub const CapsFlags_DrawIndirect: CapsFlags = 0x0000000000000010; +/// Draw indirect with indirect count is supported. +pub const CapsFlags_DrawIndirectCount: CapsFlags = 0x0000000000000020; + /// Fragment depth is available in fragment shader. -pub const CapsFlags_FragmentDepth: CapsFlags = 0x0000000000000020; +pub const CapsFlags_FragmentDepth: CapsFlags = 0x0000000000000040; /// Fragment ordering is available in fragment shader. -pub const CapsFlags_FragmentOrdering: CapsFlags = 0x0000000000000040; +pub const CapsFlags_FragmentOrdering: CapsFlags = 0x0000000000000080; /// Graphics debugger is present. -pub const CapsFlags_GraphicsDebugger: CapsFlags = 0x0000000000000080; +pub const CapsFlags_GraphicsDebugger: CapsFlags = 0x0000000000000100; /// HDR10 rendering is supported. -pub const CapsFlags_Hdr10: CapsFlags = 0x0000000000000100; +pub const CapsFlags_Hdr10: CapsFlags = 0x0000000000000200; /// HiDPI rendering is supported. -pub const CapsFlags_Hidpi: CapsFlags = 0x0000000000000200; +pub const CapsFlags_Hidpi: CapsFlags = 0x0000000000000400; /// Image Read/Write is supported. -pub const CapsFlags_ImageRw: CapsFlags = 0x0000000000000400; +pub const CapsFlags_ImageRw: CapsFlags = 0x0000000000000800; /// 32-bit indices are supported. -pub const CapsFlags_Index32: CapsFlags = 0x0000000000000800; +pub const CapsFlags_Index32: CapsFlags = 0x0000000000001000; /// Instancing is supported. -pub const CapsFlags_Instancing: CapsFlags = 0x0000000000001000; +pub const CapsFlags_Instancing: CapsFlags = 0x0000000000002000; /// Occlusion query is supported. -pub const CapsFlags_OcclusionQuery: CapsFlags = 0x0000000000002000; +pub const CapsFlags_OcclusionQuery: CapsFlags = 0x0000000000004000; + +/// PrimitiveID is available in fragment shader. +pub const CapsFlags_PrimitiveId: CapsFlags = 0x0000000000008000; /// Renderer is on separate thread. -pub const CapsFlags_RendererMultithreaded: CapsFlags = 0x0000000000004000; +pub const CapsFlags_RendererMultithreaded: CapsFlags = 0x0000000000010000; /// Multiple windows are supported. -pub const CapsFlags_SwapChain: CapsFlags = 0x0000000000008000; - -/// 2D texture array is supported. -pub const CapsFlags_Texture2DArray: CapsFlags = 0x0000000000010000; - -/// 3D textures are supported. -pub const CapsFlags_Texture3D: CapsFlags = 0x0000000000020000; +pub const CapsFlags_SwapChain: CapsFlags = 0x0000000000020000; /// Texture blit is supported. pub const CapsFlags_TextureBlit: CapsFlags = 0x0000000000040000; -/// Transparent back buffer supported. -pub const CapsFlags_TransparentBackbuffer: CapsFlags = 0x0000000000080000; -pub const CapsFlags_TextureCompareReserved: CapsFlags = 0x0000000000100000; - /// Texture compare less equal mode is supported. -pub const CapsFlags_TextureCompareLequal: CapsFlags = 0x0000000000200000; +pub const CapsFlags_TextureCompareLequal: CapsFlags = 0x0000000000080000; +pub const CapsFlags_TextureCompareReserved: CapsFlags = 0x0000000000100000; /// Cubemap texture array is supported. -pub const CapsFlags_TextureCubeArray: CapsFlags = 0x0000000000400000; +pub const CapsFlags_TextureCubeArray: CapsFlags = 0x0000000000200000; /// CPU direct access to GPU texture memory. -pub const CapsFlags_TextureDirectAccess: CapsFlags = 0x0000000000800000; +pub const CapsFlags_TextureDirectAccess: CapsFlags = 0x0000000000400000; /// Read-back texture is supported. -pub const CapsFlags_TextureReadBack: CapsFlags = 0x0000000001000000; +pub const CapsFlags_TextureReadBack: CapsFlags = 0x0000000000800000; + +/// 2D texture array is supported. +pub const CapsFlags_Texture2DArray: CapsFlags = 0x0000000001000000; + +/// 3D textures are supported. +pub const CapsFlags_Texture3D: CapsFlags = 0x0000000002000000; + +/// Transparent back buffer supported. +pub const CapsFlags_TransparentBackbuffer: CapsFlags = 0x0000000004000000; + +/// Variable Rate Shading +pub const CapsFlags_VariableRateShading: CapsFlags = 0x0000000008000000; /// Vertex attribute half-float is supported. -pub const CapsFlags_VertexAttribHalf: CapsFlags = 0x0000000002000000; +pub const CapsFlags_VertexAttribHalf: CapsFlags = 0x0000000010000000; /// Vertex attribute 10_10_10_2 is supported. -pub const CapsFlags_VertexAttribUint10: CapsFlags = 0x0000000004000000; +pub const CapsFlags_VertexAttribUint10: CapsFlags = 0x0000000020000000; /// Rendering with VertexID only is supported. -pub const CapsFlags_VertexId: CapsFlags = 0x0000000008000000; - -/// PrimitiveID is available in fragment shader. -pub const CapsFlags_PrimitiveId: CapsFlags = 0x0000000010000000; +pub const CapsFlags_VertexId: CapsFlags = 0x0000000040000000; /// Viewport layer is available in vertex shader. -pub const CapsFlags_ViewportLayerArray: CapsFlags = 0x0000000020000000; - -/// Draw indirect with indirect count is supported. -pub const CapsFlags_DrawIndirectCount: CapsFlags = 0x0000000040000000; +pub const CapsFlags_ViewportLayerArray: CapsFlags = 0x0000000080000000; /// All texture compare modes are supported. -pub const CapsFlags_TextureCompareAll: CapsFlags = 0x0000000000300000; +pub const CapsFlags_TextureCompareAll: CapsFlags = 0x0000000000180000; pub const CapsFormatFlags = u32; /// Texture format is not supported. @@ -981,6 +984,18 @@ pub const TextureFormat = enum(c_int) { /// ETC2 RGB8A1 ETC2A1, + /// EAC R11 UNORM + EACR11, + + /// EAC R11 SNORM + EACR11S, + + /// EAC RG11 UNORM + EACRG11, + + /// EAC RG11 SNORM + EACRG11S, + /// PVRTC1 RGB 2BPP PTC12, @@ -1138,6 +1153,19 @@ pub const UniformType = enum(c_int) { Count, }; +pub const UniformFreq = enum(c_int) { + /// Changing per draw call. + Draw, + + /// Changing per view. + View, + + /// Changing per frame. + Frame, + + Count, +}; + pub const BackbufferRatio = enum(c_int) { /// Equal to backbuffer. Equal, @@ -1229,6 +1257,31 @@ pub const ViewMode = enum(c_int) { Count, }; +pub const ShadingRate = enum(c_int) { + /// 1x1 + Rate1x1, + + /// 1x2 + Rate1x2, + + /// 2x1 + Rate2x1, + + /// 2x2 + Rate2x2, + + /// 2x4 + Rate2x4, + + /// 4x2 + Rate4x2, + + /// 4x4 + Rate4x4, + + Count, +}; + pub const NativeWindowHandleType = enum(c_int) { /// Platform default handle type (X11 on Linux). Default, @@ -1284,8 +1337,9 @@ pub const Caps = extern struct { maxOcclusionQueries: u32, maxEncoders: u32, minResourceCbSize: u32, - transientVbSize: u32, - transientIbSize: u32, + maxTransientVbSize: u32, + maxTansientIbSize: u32, + minUniformBufferSize: u32, }; rendererType: RendererType, @@ -1297,7 +1351,7 @@ pub const Caps = extern struct { numGPUs: u8, gpu: [4]GPU, limits: Limits, - formats: [96]u16, + formats: [100]u16, }; pub const InternalData = extern struct { @@ -1315,7 +1369,8 @@ pub const PlatformData = extern struct { }; pub const Resolution = extern struct { - format: TextureFormat, + formatColor: TextureFormat, + formatDepthStencil: TextureFormat, width: u32, height: u32, reset: u32, @@ -1328,8 +1383,9 @@ pub const Init = extern struct { pub const Limits = extern struct { maxEncoders: u16, minResourceCbSize: u32, - transientVbSize: u32, - transientIbSize: u32, + maxTransientVbSize: u32, + maxTransientIbSize: u32, + minUniformBufferSize: u32, }; type: RendererType, @@ -1505,11 +1561,6 @@ pub const VertexLayout = extern struct { pub inline fn decode(self: *const VertexLayout, _attrib: Attrib, _num: [*c]u8, _type: [*c]AttribType, _normalized: [*c]bool, _asInt: [*c]bool) void { return bgfx_vertex_layout_decode(self, _attrib, _num, _type, _normalized, _asInt); } - /// Returns `true` if VertexLayout contains attribute. - /// Attribute semantics. See: `bgfx::Attrib` - pub inline fn has(self: *const VertexLayout, _attrib: Attrib) bool { - return bgfx_vertex_layout_has(self, _attrib); - } /// Skip `_num` bytes in vertex stream. /// Number of bytes to skip. pub inline fn skip(self: *VertexLayout, _num: u8) *VertexLayout { @@ -1698,6 +1749,7 @@ pub const Encoder = opaque { /// Set number of instances for auto generated instances use in conjunction /// with gl_InstanceID. /// @attention Availability depends on: `BGFX_CAPS_VERTEX_ID`. + /// Number of instances. pub inline fn setInstanceCount(self: ?*Encoder, _numInstances: u32) void { return bgfx_encoder_set_instance_count(self, _numInstances); } @@ -1933,10 +1985,6 @@ extern fn bgfx_vertex_layout_add(self: [*c]VertexLayout, _attrib: Attrib, _num: /// Attribute is packed as int. extern fn bgfx_vertex_layout_decode(self: [*c]const VertexLayout, _attrib: Attrib, _num: [*c]u8, _type: [*c]AttribType, _normalized: [*c]bool, _asInt: [*c]bool) void; -/// Returns `true` if VertexLayout contains attribute. -/// Attribute semantics. See: `bgfx::Attrib` -extern fn bgfx_vertex_layout_has(self: [*c]const VertexLayout, _attrib: Attrib) bool; - /// Skip `_num` bytes in vertex stream. /// Number of bytes to skip. extern fn bgfx_vertex_layout_skip(self: [*c]VertexLayout, _num: u8) [*c]VertexLayout; @@ -2714,6 +2762,7 @@ extern fn bgfx_destroy_frame_buffer(_handle: FrameBufferHandle) void; /// - `u_model mat4[BGFX_CONFIG_MAX_BONES]` - array of model matrices. /// - `u_modelView mat4` - concatenated model view matrix, only first /// model matrix from array is used. +/// - `u_invModelView mat4` - inverted concatenated model view matrix. /// - `u_modelViewProj mat4` - concatenated model view projection matrix. /// - `u_alphaRef float` - alpha reference value for alpha test. /// Uniform name in shader. @@ -2724,6 +2773,39 @@ pub inline fn createUniform(_name: [*c]const u8, _type: UniformType, _num: u16) } extern fn bgfx_create_uniform(_name: [*c]const u8, _type: UniformType, _num: u16) UniformHandle; +/// Create shader uniform parameter. +/// @remarks +/// 1. Uniform names are unique. It's valid to call `bgfx::createUniform` +/// multiple times with the same uniform name. The library will always +/// return the same handle, but the handle reference count will be +/// incremented. This means that the same number of `bgfx::destroyUniform` +/// must be called to properly destroy the uniform. +/// 2. Predefined uniforms (declared in `bgfx_shader.sh`): +/// - `u_viewRect vec4(x, y, width, height)` - view rectangle for current +/// view, in pixels. +/// - `u_viewTexel vec4(1.0/width, 1.0/height, undef, undef)` - inverse +/// width and height +/// - `u_view mat4` - view matrix +/// - `u_invView mat4` - inverted view matrix +/// - `u_proj mat4` - projection matrix +/// - `u_invProj mat4` - inverted projection matrix +/// - `u_viewProj mat4` - concatenated view projection matrix +/// - `u_invViewProj mat4` - concatenated inverted view projection matrix +/// - `u_model mat4[BGFX_CONFIG_MAX_BONES]` - array of model matrices. +/// - `u_modelView mat4` - concatenated model view matrix, only first +/// model matrix from array is used. +/// - `u_invModelView mat4` - inverted concatenated model view matrix. +/// - `u_modelViewProj mat4` - concatenated model view projection matrix. +/// - `u_alphaRef float` - alpha reference value for alpha test. +/// Uniform name in shader. +/// Uniform change frequency (See: `bgfx::UniformFreq`). +/// Type of uniform (See: `bgfx::UniformType`). +/// Number of elements in array. +pub inline fn createUniformWithFreq(_name: [*c]const u8, _freq: UniformFreq, _type: UniformType, _num: u16) UniformHandle { + return bgfx_create_uniform_with_freq(_name, _freq, _type, _num); +} +extern fn bgfx_create_uniform_with_freq(_name: [*c]const u8, _freq: UniformFreq, _type: UniformType, _num: u16) UniformHandle; + /// Retrieve uniform info. /// Handle to uniform object. /// Uniform info. @@ -2768,6 +2850,17 @@ pub inline fn setPaletteColor(_index: u8, _rgba: [4]f32) void { } extern fn bgfx_set_palette_color(_index: u8, _rgba: [4]f32) void; +/// Set palette color value. +/// Index into palette. +/// Red value (RGBA floating point values) +/// Green value (RGBA floating point values) +/// Blue value (RGBA floating point values) +/// Alpha value (RGBA floating point values) +pub inline fn setPaletteColorRgba32f(_index: u8, _r: f32, _g: f32, _b: f32, _a: f32) void { + return bgfx_set_palette_color_rgba32f(_index, _r, _g, _b, _a); +} +extern fn bgfx_set_palette_color_rgba32f(_index: u8, _r: f32, _g: f32, _b: f32, _a: f32) void; + /// Set palette color value. /// Index into palette. /// Packed 32-bit RGBA value. @@ -2895,7 +2988,17 @@ pub inline fn setViewOrder(_id: ViewId, _num: u16, _order: [*c]const ViewId) voi } extern fn bgfx_set_view_order(_id: ViewId, _num: u16, _order: [*c]const ViewId) void; +/// Set view shading rate. +/// @attention Availability depends on: `BGFX_CAPS_VARIABLE_RATE_SHADING`. +/// View id. +/// Shading rate. +pub inline fn setViewShadingRate(_id: ViewId, _shadingRate: ShadingRate) void { + return bgfx_set_view_shading_rate(_id, _shadingRate); +} +extern fn bgfx_set_view_shading_rate(_id: ViewId, _shadingRate: ShadingRate) void; + /// Reset all view settings to default. +/// _id View id. pub inline fn resetView(_id: ViewId) void { return bgfx_reset_view(_id); } @@ -2984,6 +3087,27 @@ extern fn bgfx_encoder_alloc_transform(self: ?*Encoder, _transform: [*c]Transfor /// Number of elements. Passing `UINT16_MAX` will use the _num passed on uniform creation. extern fn bgfx_encoder_set_uniform(self: ?*Encoder, _handle: UniformHandle, _value: ?*const anyopaque, _num: u16) void; +/// Set shader uniform parameter for view. +/// @attention Uniform must be created with `bgfx::UniformFreq::View` argument. +/// View id. +/// Uniform. +/// Pointer to uniform data. +/// Number of elements. Passing `UINT16_MAX` will use the _num passed on uniform creation. +pub inline fn setViewUniform(_id: ViewId, _handle: UniformHandle, _value: ?*const anyopaque, _num: u16) void { + return bgfx_set_view_uniform(_id, _handle, _value, _num); +} +extern fn bgfx_set_view_uniform(_id: ViewId, _handle: UniformHandle, _value: ?*const anyopaque, _num: u16) void; + +/// Set shader uniform parameter for frame. +/// @attention Uniform must be created with `bgfx::UniformFreq::View` argument. +/// Uniform. +/// Pointer to uniform data. +/// Number of elements. Passing `UINT16_MAX` will use the _num passed on uniform creation. +pub inline fn setFrameUniform(_handle: UniformHandle, _value: ?*const anyopaque, _num: u16) void { + return bgfx_set_frame_uniform(_handle, _value, _num); +} +extern fn bgfx_set_frame_uniform(_handle: UniformHandle, _value: ?*const anyopaque, _num: u16) void; + /// Set index buffer for draw primitive. /// Index buffer. /// First index to render. @@ -3068,6 +3192,7 @@ extern fn bgfx_encoder_set_instance_data_from_dynamic_vertex_buffer(self: ?*Enco /// Set number of instances for auto generated instances use in conjunction /// with gl_InstanceID. /// @attention Availability depends on: `BGFX_CAPS_VERTEX_ID`. +/// Number of instances. extern fn bgfx_encoder_set_instance_count(self: ?*Encoder, _numInstances: u32) void; /// Set texture stage for draw primitive. @@ -3255,10 +3380,11 @@ extern fn bgfx_get_internal_data() [*c]const InternalData; /// @warning Must be called only on render thread. /// Texture handle. /// Native API pointer to texture. -pub inline fn overrideInternalTexturePtr(_handle: TextureHandle, _ptr: usize) usize { - return bgfx_override_internal_texture_ptr(_handle, _ptr); +/// Layer index for texture arrays (only implemented for D3D11). +pub inline fn overrideInternalTexturePtr(_handle: TextureHandle, _ptr: usize, _layerIndex: u16) usize { + return bgfx_override_internal_texture_ptr(_handle, _ptr, _layerIndex); } -extern fn bgfx_override_internal_texture_ptr(_handle: TextureHandle, _ptr: usize) usize; +extern fn bgfx_override_internal_texture_ptr(_handle: TextureHandle, _ptr: usize, _layerIndex: u16) usize; /// Override internal texture by creating new texture. Previously created /// internal texture will released. @@ -3506,6 +3632,7 @@ extern fn bgfx_set_instance_data_from_dynamic_vertex_buffer(_handle: DynamicVert /// Set number of instances for auto generated instances use in conjunction /// with gl_InstanceID. /// @attention Availability depends on: `BGFX_CAPS_VERTEX_ID`. +/// Number of instances. pub inline fn setInstanceCount(_numInstances: u32) void { return bgfx_set_instance_count(_numInstances); }